Redirecionar Usuário

Este artigo explica como redirecionar um usuário para a experiência do Cadastro By Unico de autenticação através da API REST.

O campo userRedirectUrl é usado para direcionar o usuário. Esse campo é recebido na resposta de sucesso da criação do processo.

Web

Para fazer a integração com sua aplicação web existem duas opções:

1) Usando window.open()

A opção window.open() consiste em abrir uma nova aba do navegador do usuário para que ele possa completar o processo. Ao final essa aba é fechada e redirecionada para sua aplicação.

Para isso é recomendado:

• Seguir a documentação pública sobre isso, que se encontra aqui;

• Monitorar se houve alteração de URL (para a redirectUrl) e então fechar a aba utilizando window.close();

2) Usando redirect

Recomenda-se seguir os seguintes passos:

• Em seu fluxo comum (que está inserido o Cadastro by Unico) você irá redirecionar o cliente para o link gerado através da API;
• Após isso o cliente de dentro da plataforma realiza os procedimentos necessários para continuar o fluxo;
• Quando concluído, ele é redirecionado para a sua página (utilizando o redirectUrl passado na criação do processo);

Importante

A aplicação não funciona Via iFrame por questões de segurança.

Android

Em Android, o uso de Webview é recomendado.

Após criar o processo e obter o link desse processo, a seguinte implementação é recomendada:

• Em seu fluxo comum (que está inserido o Cadastro by Unico), você abre a Webview com o link gerado através da API;
• Você pode customizar essa abertura da maneira que for ideal para seu aplicativo;
• Monitore se houve alteração de URL (para a redirectUrl) e então feche a Webview;

Para abrir uma Webview faça o seguinte:

import android.webkit.PermissionRequest
import android.webkit.WebChromeClient
import android.webkit.WebView
import android.webkit.WebViewClient

@SuppressLint("SetJavaScriptEnabled")
override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_camera)

    findViewById<WebView>(R.id.webView).apply {
        settings.javaScriptEnabled = true
        settings.domStorageEnabled = true
        settings.mediaPlaybackRequiresUserGesture = false
        clearCache(true)
        webViewClient = myWebViewClient
        webChromeClient = object : WebChromeClient() {
            override fun onPermissionRequest(request: PermissionRequest?) {
                request?.grant(request.resources)
            }
        }
        loadUrl("<URL_TO_LOAD>")
    }
}

O controle de quando é necessário fechar o Webview pode ser feito da seguinte maneira:

private val myWebViewClient = object : WebViewClient() {
    override fun shouldOverrideUrlLoading(
        view: WebView?,
        request: WebResourceRequest?
    ): Boolean {
        if (request?.url.toString() == "<URL_TO_OBSERVER>") {
            // close here your webview
        }
        return super.shouldOverrideUrlLoading(view, request)
    }
}

Para isso é necessário habilitar permissões na Android Manifest:

<uses-feature android:name="android.hardware.camera" android:required="false"/>
<uses-permission android:name="android.permission.CAMERA"/>

Importante

As seguintes permissões são necessárias para funcionar corretamente:

• Câmera;
• Geolocalização;

iOS

Passo 1: Criar o controlador de autenticação

O primeiro passo é criar o controlador de autenticação, e, para isso crie uma classe chamada UnicoAuthenticationController (ou como preferir chamar).

Na sequência, importe o framework AuthenticationServices no topo da classe.

Declare a classe como NSObject e implemente o protocolo ASWebAuthenticationPresentationContextProviding.

O resultado deve ser:

import AuthenticationServices

class UnicoAuthenticationController: NSObject, ASWebAuthenticationPresentationContextProviding {
    func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
           if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
               if let mainWindow = windowScene.windows.first {
                   return mainWindow
               }
           }
           return ASPresentationAnchor()
       }
}

Passo 2: Implementar a autenticação

Abra o arquivo onde você executa a autenticação e adicione as importações necessárias (como exemplo, o ContentView.swift é usado).

import SwiftUI
import AuthenticationServices

Para controlar o estado do fluxo é preciso criar a propriedade @State.

@State private var finished = false

Crie uma instância da classe UnicoAuthenticationController fora do corpo da estrutura ContentView.

let unicoController = UnicoAuthenticationController()

Para a validação do processo, crie uma função chamada redirectUser.

func redirectUser() {
        guard let url = URL(string: "URL_AUTHENTICATION") else { return }

        var session: ASWebAuthenticationSession?
        session = ASWebAuthenticationSession(url: url, callbackURLScheme: "BUNDLE") { callbackURL, error in
            guard callbackURL != nil else {
                if let error = error {
                    return print("Erro durante o processo: \(error.localizedDescription)")
                }
                return
            }

            // Processa o URL de callback para verificar se o processo foi finalizado
            session?.cancel()
            finished = true
        }

        session?.presentationContextProvider = unicoController
        session?.prefersEphemeralWebBrowserSession = true
        session?.start()
    }

Ambientes

Lembre-se de alterar a url URL_AUTHENTICATION para a URL de autenticação recebida em seu processo e também o callbackURLScheme BUNDLE para o redirect informado na criação do processo (o uso do Bundle Identifier de seu aplicativo é recomendado).

Autenticação única

É importante setar prefersEphemeralWebBrowserSession para true para garantir uma autenticação única por processo.

Dúvidas?

Não encontrou algo ou ainda precisa de ajuda? Se já é um cliente ou parceiro, pode entrar em contato através da Central de Ajuda.