Saltar al contenido principal
Version: 1.5.5

Flow Component

0. Requisitos base de SDK Mobile​

SDK Mobile es un conjunto de librerías (Componentes) que ofrece una serie de funcionalidades y servicios, permitiendo a su vez su integración en una aplicación Mobile de forma sencilla y totalmente escalable. Dependiendo del caso de uso que se requiera, se deberá realizar la instalación de unos determinados componentes. Su alto nivel de modularidad permite que, en un futuro, se puedan añadir otros componentes nuevos sin afectar en absoluto a los ya integrados en el proyecto.

Para más información sobre la configuración base, vaya a la sección de Primeros Pasos.

1. Introducción​

Este documento de Flow es un anexo al común de SDK, ya que esta funcionalidad está contenida en el propio componente de SDK.

Flow es una funcionalidad que conecta la sección de Design Studio de la Plataforma con el SDK y la implementación que realiza el cliente. A través de un identificador de Flow, podrá lanzar un flujo diseñado en la web, que puede contener de 1 a N pasos de los componentes existentes en el SDK.

2. Integración del componente​

Antes de integrar este componente se recomienda leer la documentación relativa a:

Primeros Pasos y seguir las instrucciones indicadas en dicho documento.

En esta sección se explicará paso a paso cómo integrar el componente actual en un proyecto ya existente.

2.1. Dependencias requeridas para la integración​

No es necesaria ninguna dependencia extra para utilizar Flow.

Se deberán añadir las dependencias requeridas de cada componente que se quiera lanzar dentro del Flow. Si se quiere lanzar reconocimiento facial, deberá ser necesario instalar el componente de Selphi, y así sucesivamente con el resto de componentes.

3. Iniciar nueva operación​

Al iniciar el lanzamiento de una operación de Flow, internamente se genera una nueva operación de manera completamente transparente.

No es necesario realizar una nueva operación con anterioridad.

4. Controladores disponibles​

ControladorDescripción
FlowControllerControlador principal de Flow. Lanzamiento de flujos publicados.
FlowPreviewControllerControlador para el lanzamiento de flujos pendientes de publicar (pruebas)

4.1. Controladores de componentes con flow​

ControladorDescripción
FSelphiControllerReconocimiento facial
FSelphIDControllerReconocimiento documental
FVoiceControllerCaptura de voz
FPhingersControllerCaptura de huellas
FNfcControllerLectura de NFC
FQrReaderControllerLectura de QR
FPhacturasReaderControllerCaptura de facturas
FVideoIdControllerVideo Identificación
FVideoCallControllerVideo Asistencia

5. Inicialización del SDK con flow​

La función de inicialización del SDK tiene el parámetro activateFlow para gestionar su activación:

SDKController.initSdk(
     ...,
      activateFlow = true,
      ..
      ) {
          when (it) {
              is SdkResult.Success -> Napier.d("APP: INIT SDK: OK")
              is SdkResult.Error -> Napier.d(
                     "APP: INIT SDK: KO - ${it.error}"
                    )
           }
 })

6. Uso del componente​

6.1 Lanzamiento de un flujo publicado​

Se usará el FlowController para lanzar un flujo que el cliente tiene publicado en la plataforma:

SDKController.launch(
   FlowController(
        FlowConfigurationData(
            id = "flowId",
            controllers = listOf(FSelphiController(), FSelphIDController()),
            customerId = "customerId",
            newOperation = true
        )) { flowResult ->
        Napier.d("APP: FLOW STEP KEY ${flowResult.step?.key}")
        when (val sdkResult = flowResult.result) {
             is SdkResult.Error -> {
                Napier.d("APP: FLOW ERROR: ${sdkResult.error}")
             }
             is SdkResult.Success -> {

                when (flowResult.step?.key) {
                    FlowKeys.SELPHI_COMPONENT.name -> {
                          val result = sdkResult.data.getSelphiResult()
                     }

                     FlowKeys.SELPHID_COMPONENT.name -> {
                           val result = sdkResult.data.getSelphIDResult()
                     }
                }
             }
        }

        if (flowResult.flowFinish) {
           Napier.d("APP: FLOW FINISH")

         }
    }
}

6.2 Lanzamiento de un flujo pendiente de publicar​

Se usará el FlowPreviewController para probar un flujo que el cliente tiene pendiente de publicar en la plataforma:

SDKController.launch(
   FlowPreviewController(
        FlowConfigurationData(
            id = "flowId",
            controllers = listOf(FSelphiController(), FSelphIDController()),
            customerId = "customerId",
            newOperation = true
        )) { flowResult ->
        Napier.d("APP: FLOW STEP KEY ${flowResult.step?.key}")
        when (val sdkResult = flowResult.result) {
             is SdkResult.Error -> {
                Napier.d("APP: FLOW ERROR: ${sdkResult.error}")
             }
             is SdkResult.Success -> {

                when (flowResult.step?.key) {
                    FlowKeys.SELPHI_COMPONENT.name -> {
                          val result = sdkResult.data.getSelphiResult()
                     }

                     FlowKeys.SELPHID_COMPONENT.name -> {
                           val result = sdkResult.data.getSelphIDResult()
                     }
                }
             }
        }

        if (flowResult.flowFinish) {
           Napier.d("APP: FLOW FINISH")

         }
    })

7. Recepción del resultado​

El resultado del flow tendrá 3 campos:

  • step: Información del paso del flujo que se ha realizado. Con el valor de “key” se podrá identificar el componente ejecutado en el paso.

  • result: Resultado del paso en formato SdkResult. Más información en la sección de 6. Retorno de resultado del Android Mobile SDK.

  • flowFinish: Flag que indicará si ha terminado el proceso

7.1. Recepción de errores​

En la parte del error, dentro de SdkResult.Error dispondremos flowResult.step.key para identificar que componente ha fallado y el flowResult.result.error que contiene el error que ha ocurrido.

7.2. Recepción de ejecución correcta - data​

En la ejecución correcta de un flujo, se lanzarán los componentes correspondientes hasta la finalización del mismo o hasta obtener un error.

Si el resultado de un paso lanzado es SdkResult.Success, se podrá localizar, por un lado, la key que identifica al componente y por otro lado el data con el resultado del componente, como es un resultado genérico, dentro del SDK, se ha creado un conversor para cada tipo de resultado. Ej:

flowResult ->
        when (val sdkResult = flowResult.result) {
             is SdkResult.Error -> {
                Napier.d("APP: FLOW ERROR: ${sdkResult.error}")
             }

             is SdkResult.Success -> {

                when (flowResult.step?.key) {
                    FlowKeys.SELPHI_COMPONENT.name -> {
                          val result = sdkResult.data.getSelphiResult()
                     }

                     FlowKeys.SELPHID_COMPONENT.name -> {
                           val result = sdkResult.data.getSelphIDResult()
                     }
                }
             }
        }
    })

Tras comprobar los resultados, deberemos revisar si el flow ha finalizado o aún quedan pasos, para poder gestionar los siguientes pasos fuera del SDK.

if (flowResult.flowFinish) {
    Napier.d("APP: FLOW FINISH")
}