3.4.3

Link para download do xcframework para adição manual do sdk

Release Notes

Principais alterações

App de integração atualizado com a versão 3.4.3: O nosso app de integração foi atualizado com as novas possibilidades de uso, com chamadas assíncronas aos métodos de inicialização e sessão antes do pagamento, facilitando o entendimento do uso do SDK.
Novos eventos: Novos eventos para os fluxos de ativação, criação de sessão e kernel, além de eventos descrevendo também quando esses fluxos ocorrem durante a inicialização automática no pagamento.
Termos e condições sem inicialização: Agora é possível chamar o método TapOnPhone.processTermsAndConditions sem chamada prévia ao TapOnPhone.initialize().
Fluxo assíncrono melhorado: Agora é possível chamar a inicialização, a sessão e pagamento sem aguardar a resposta, e todo o fluxo vai ser encadeado para processar, não exigindo a espera em cada chamada. É possível verificar exemplos no app sample disponível aqui
Correção de bug: Bug no envio de eventos onde o evento de inicio de animação de bandeira (.brandAnimationStarted) era disparado mesmo quando não existia animação a ser tocada (bandeira diferente de visa e elo)

Novos eventos

Foram adicionados os novos eventos conforme abaixo: Para maiores detalhes sobre os eventos, confira a documentação específica dos eventos aqui

enum ApplicationEvent {
    // ....

    // Esses eventos complementam eventos que já existiam:
   case terminalActivationSucceeded
   case terminalActivationFailed
   case zoopActivationFinished
   case kernelActivationFinished
   case sessionActivationFinished
   case paymentConfirmationFinished
   case brandAnimationSucceeded

   // Esses evento são similares aos que já existem, mas são chamados quando algum dos processos está sendo processado durante o fluxo do pagamento:

    case zoopActivationInPaymentStarted
    case zoopActivationInPaymentSucceeded
    case zoopActivationInPaymentFailed
    case zoopActivationInPaymentFinished

    case kernelActivationInPaymentStarted
    case kernelActivationInPaymentSucceeded
    case kernelActivationInPaymentFailed
    case kernelActivationInPaymentFinished

    case sessionActivationInPaymentStarted
    case sessionActivationInPaymentSucceeded
    case sessionActivationInPaymentFailed
    case sessionActivationInPaymentFinished
   // ...
}

Fluxo assíncrono

Nessa versão, caso você chame o método TapOnPhone.initialize() e TapOnPhone.pay(), o SDK vai, automaticamente, iniciar o pagamento e aguardar a finalização da inicialização, não sendo necessário a gestão do lado do app integrador.

O primeiro passo, continua sendo chamar o método TapOnPhone.setConfig() apenas uma vez. (não chamar novamente).

Após o TapOnPhone.setConfig(), agora é possível utilizar o SDK de 3 maneiras:

Diretamente o método TapOnPhone.pay()
- Nesse formato, o SDK lidará internamente com a inicialização e a sessão.

Exemplo:

    TapOnPhone.pay(
    payRequest: PaymentRequest(
        amount: amount,
        paymentType: paymentType,
        installments: installments,
        metadata: metadata
    ),
    onSuccess: { success in
        isLoadingPayment = false
        paySuccess = success
    },
    onError: { error in
        print("error \(error)")
        isLoadingPayment = false
        if error.type == .payment {
            payError = error.error as? PaymentErrorResponse
        } else {
            initializeError = error.error as? TapOnPhoneError
        }
    },
    onEvent: { event in
        print(event)
    }
)

Dica

Os próximos dois tipos de processamento, podem ser chamados por exemplo, na hora que o cliente estiver digitando o valor, e pode seguir pra venda normalmente, ao chamar o pay, o sdk se resolve automaticamente.

Chamar o TapOnPhone.initialize() e, sem espera, o método TapOnPhone.pay().
- Nesse formato, o SDK vai subir a tela do pagamento e aguardar a execução da inicialização, e então automaticamente iniciar o pagamento.

Exemplo:

// Nesse caso, caso a inicializalação falhe, você pode capturar o erro, mas se não for desejado, pode seguir com a venda, e, durante a venda, vai dar erro ao tentar inicializar.

TapOnPhone.initialize(
    onSuccess: { },
    onError: { _ in },
    onEvent: { event in print(event) }
)

TapOnPhone.pay(
    payRequest: PaymentRequest(
        amount: amount,
        paymentType: paymentType,
        installments: installments,
        metadata: metadata
    ),
    onSuccess: { success in
        isLoadingPayment = false
        paySuccess = success
    },
    onError: { error in
        print("error \(error)")
        isLoadingPayment = false
        if error.type == .payment {
            payError = error.error as? PaymentErrorResponse
        } else {
            initializeError = error.error as? TapOnPhoneError
        }
    },
    onEvent: { event in
        print(event)
    }
)

Chamar o TapOnPhone.initialize(), sem esperar, o método TapOnPhone.activateSession() e ainda sem espera, o método TapOnPhone.pay().
- Nesse formato, o SDK ao iniciar o pagamento vai subir a tela, e, caso ainda esteja lidando com a inicialização, vai informar na tela, caso tenha terminado a inicialização, seguirá para o pagamento.

Exemplo:

// Nesse caso, caso a inicializalação ou a sessão falhe, você pode capturar o erro, mas se não for desejado, pode seguir com a venda, e, durante a venda, vai dar erro ao tentar inicializar.

TapOnPhone.initialize(
    onSuccess: { },
    onError: { _ in },
    onEvent: { event in print(event) }
)

TapOnPhone.activateSession(
        onSuccess: { _ in },
        onError: { _ in },
        onEvent: { event in print(event) }
    )

TapOnPhone.pay(
    payRequest: PaymentRequest(
        amount: amount,
        paymentType: paymentType,
        installments: installments,
        metadata: metadata
    ),
    onSuccess: { success in
        isLoadingPayment = false
        paySuccess = success
    },
    onError: { error in
        print("error \(error)")
        isLoadingPayment = false
        if error.type == .payment {
            payError = error.error as? PaymentErrorResponse
        } else {
            initializeError = error.error as? TapOnPhoneError
        }
    },
    onEvent: { event in
        print(event)
    }
)