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.

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

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.

let tmgClient = TMGClient.sharedInstance
tmgClient.createVisaCTFHelper(tmgClientConfiguration: configuration,
                              completion: { (visaCTFHelper, error) in
  // Obtiene el objeto VisaCTFHelper
  // Verifica 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:

// 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
})

// 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.

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)

// 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.

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

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:

// 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
    } 
})

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.

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

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.

// 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
    }  
})

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.

// 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
    } 
})

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
}

AnteriorAPI de iOS SiguienteGestión de errores

Última actualización hace 5 meses

¿Te fue útil?

Buenos días

Inicializar el SDK

Qué cambió

Inicializar VisaCTFHelper

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

Reanudar una vinculación (resumeBinding)

Obtener el estado de la vinculación (bindingState)