Android

App de demostración

Descargue la última versión de la app de demostración:

Quick start guideQuick start guide

Para obtener el código fuente de las aplicaciones de muestra de Oz Liveness SDK, recurra al repositorio de GitLab:

oz-forensics / oz-liveness-androidGitLab

Cómo agregar el SDK a un proyecto

Agregue lo siguiente al build.gradle del proyecto:

allprojects {
  repositories {
    maven { url "https://ozforensics.jfrog.io/artifactory/main" }
  }
}

Agruegue al build.gradle odel módulo (VERSION es la versión que necesita implementar. Consulte el Registro de cambios):

dependencies {
  implementation 'com.ozforensics.liveness:sdk:VERSION'
}

y:

android {
  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }
}

Licencia

A partir de la versión 5.0, el SDK requiere una licencia para funcionar. Póngase en contacto con nosotros por correo electrónico para obtener una copia de la licencia. Para crear la licencia, se requiere su applicationId (bundle id).

Para pasar su archivo de licencia al SDK, llame el método OzLivenessSDK.init con una lista de LicenseSources. Utilice uno de los siguientes:

LicenseSource.LicenseAssetId debe contener una ruta de acceso a un archivo de licencia llamado forensics.license, que tiene que estar ubicado en la carpeta res/raw del proyecto.

LicenseSource.LicenseFilePath debe contener una ruta de acceso al lugar del almacenamiento del dispositivo donde se encuentra el archivo de licencia.

Kotlin

OzLivenessSDK.init(
    listOf(
        LicenseSource.LicenseAssetId(R.raw.your_license_name),
        LicenseSource.LicenseFilePath("absolute_path_to_your_license_file")
    ),
    object : StatusListener<LicensePayload> {
        override fun onSuccess(result: LicensePayload) { /*comprobación de la información de la licencia*/ }
        override fun onError(error: OzException) { /*procesamiento de la excepción */ }
    }
  )

Java

OzLivenessSDK.INSTANCE.getConfig().setBaseURL(BASE_URL);
OzLivenessSDK.INSTANCE.init(
    Arrays.asList(
        new LicenseSource.LicenseAssetId(R.raw.forensics),
        new LicenseSource.LicenseFilePath("absolute_path_to_your_license_file")
    ),
    new StatusListener<LicensePayload>() {
        @Override public void onStatusChanged(@Nullable String s) {}
        @Override public void onSuccess(LicensePayload licensePayload) { /*comprobación de la información de la licencia*/ }
        @Override public void onError(@NonNull OzException e) { /*procesamiento de la excepción */ }
    }
);

Ajustes

Se recomienda aplicar estos ajustes al iniciar la app.

Kotlin

// URL del servidor de Oz API con el que el SDK va a interactuar
OzLivenessSDK.config.baseURL = BASE_URL 
// el token para acceder al servidor de Oz API (sólo si tiene un solo token para todos los usuarios)
OzLivenessSDK.config.permanentAccessToken = ACCESS_TOKEN 
// ajustes para el número de intentos de detectar una acción
OzLivenessSDK.config.attemptSettings = attemptSettings 
// la posibilidad de mostrar información de depuración adicional (puede verla haciendo clic en el número de versión del SDK)
OzLivenessSDK.config.allowDebugVisualization = allowDebugVisualization 
// ajustes del registro
OzLivenessSDK.config.logging = ozLogging 

Java

OzConfig config = OzLivenessSDK.INSTANCE.getConfig();
// URL del servidor de Oz API con el que el SDK va a interactuar
config.setBaseURL(BASE_URL); 
// el token para acceder al servidor de Oz API (sólo si tiene un solo token para todos los usuarios)
config.setPermanentAccessToken(ACCESS_TOKEN); 
// ajustes para el número de intentos de detectar una acción
config.setAttemptSettings(attemptSettings); 
// la posibilidad de mostrar información de depuración adicional (puede verla haciendo clic en el número de versión del SDK)
config.setAllowDebugVisualization(allowDebugVisualization); 
// ajustes del registro
config.setLogging(ozLogging); 

Cómo personalizar la interfaz

Puede personalizar la interfaz de Oz Liveness con la ayuda de la clase OzCustomization y sus subclases:

Kotlin

OzLivenessSDK.config.customization = OzCustomization(
    OzCancelButtonCustomization(R.drawable.ic_arrow),
    OzCenterHintCustomization(16f, Typeface.MONOSPACE, Color.CYAN, 1.3f),
    OzDialogCustomization(R.style.Custom_Dialog_Theme),
    OzFaceFrameCustomization(OzFaceFrameCustomization.GeometryType.OVAL, 8f, 5f, Color.RED, Color.GREEN),
    OzVersionTextCustomization(Color.WHITE)
)

Java

OzLivenessSDK.INSTANCE.getConfig().setCustomization(
        new OzCustomization(
                new OzCancelButtonCustomization(R.drawable.ic_declined),
                new OzCenterHintCustomization(16f, Typeface.MONOSPACE, Color.CYAN, 1.3f),
                new OzDialogCustomization(R.style.FullScreenDialogStyle),
                new OzFaceFrameCustomization(OzFaceFrameCustomization.GeometryType.OVAL, 8f, 5f, Color.RED, Color.GREEN),
                new OzVersionTextCustomization(COLOR.WHITE)
        )
);

Por defecto, el SDK utiliza la localización regional del dispositivo. Para cambiar la localización regional, utilice el siguiente código:

Kotlin

OzLivenessSDK.config.localizationCode = OzLivenessSDK.OzLocalizationCode.RU

Java

OzLivenessSDK.INSTANCE.getConfig().setLocalizationCode(OzLivenessSDK.OzLocalizationCode.RU);

Autorización

Para autorizar Oz API y obtener el token de acceso, utilice el método OzLivenessSDK.login con el nombre de usuario y la contraseña proporcionados por su administrador de cuentas de Oz Forensics:

Kotlin

val loginListener = object: StatusListener<String> {
    override fun onSuccess(token: String) { /*guardar token*/ }
    override fun onError(error: OzException) {/* procesamiento de la excepción */}
}
OzLivenessSDK.login(USER_NAME, PASSWORD, loginListener)

Java

StatusListener<String> loginListener = new StatusListener<String>() {
    @Override public void onStatusChanged(@Nullable String s) {}
    @Override public void onSuccess(String token) { /* guardar token */ }
    @Override public void onError(@NonNull OzException e) { /* procesamiento de la excepción */ }
};
Cancelable loginCancelable = OzLivenessSDK.INSTANCE.login(userName, password, loginListener);

Si ya tiene el token de acceso, especifique la URL de la API y el token de forma manual:

Kotlin

OzLivenessSDK.config.baseURL = BASE_URL
OzLivenessSDK.config.permanentAccessToken = ACCESS_TOKEN

Java

OzLivenessSDK.INSTANCE.getConfig().setBaseURL(BASE_URL);
OzLivenessSDK.INSTANCE.getConfig().setPermanentAccessToken(BASE_URL);

Captura de videos

Para iniciar la grabación, utilice el métodostartActivityForResult:

Kotlin

val intent = OzLivenessSDK.createStartIntent(listOf(OzAction.Smile, OzAction.Scan))
startActivityForResult(intent, REQUEST_CODE)

Java

List<OzAction> actions  = Arrays.asList(OzAction.Smile, OzAction.Scan);
Intent intent = OzLivenessSDK.createStartIntent(actions);
startActivityForResult(intent, REQUEST_CODE);

actions: lista de acciones del usuario durante la grabación de video. Las acciones posibles son:

• OzAction.Smile

• OzAction.EyeBlink

• OzAction.HeadUp

• OzAction.HeadDown

• OzAction.HeadLeft

• OzAction.HeadRight

• OzAction.Scan

• OzAction.Blank

• OzAction.OneShot

Para obtener el video capturado, utilice el métodoonActivityResult:

Kotlin

override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
  super.onActivityResult(requestCode, resultCode, data)
    if (requestCode == REQUEST_CODE) {
      sdkMediaResult = OzLivenessSDK.getResultFromIntent(data)
      sdkErrorString = OzLivenessSDK.getErrorFromIntent(data)
    }
}

Java

@Override
protected void onActivityResult(int requestCode, int resultCode, @androidx.annotation.Nullable Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_CODE) {
        List<OzAbstractMedia> sdkMediaResult = OzLivenessSDK.INSTANCE.getResultFromIntent(data);
        String sdkErrorString = OzLivenessSDK.INSTANCE.getErrorFromIntent(data);
    }

• sdkMediaResult: objeto con los resultados de captura de video para las interacciones con Oz API

• sdkErrorString: descripción de los errores, si los hay

Carga de archivos multimedia para su análisis

Hay dos formas de enviar archivos multimedia para su análisis:

• análisis en el servidor: el sistema envía archivos multimedia a un servidor remoto y luego espera su respuesta.

• análisis en el dispositivo: los archivos multimedia se analizan en el dispositivo, sin enviarlos a ninguna parte

Análisis en el servidor

Los datos que se cargan y analizan se almacenan en el objeto sdkMediaResult, obtenido tras la captura y grabación de video. Cárguelo en el servidor e inicie los análisis necesarios mediante Oz API.

Un escenario simple de interacción con Oz API puede implementarse con el método uploadMediaAndAnalyze como se describe a continuación.

Kotlin

val statusListener = object: StatusListener<List<OzAnalysisResult>> {
            override fun onStatusChanged(status: String?) { /*su código para mostrar el mensaje de estado*/ }
            override fun onSuccess(result:List <OzAnalysisResult>) { /*su código para manejar el resultado del análisis*/ }
            override fun onError(error: OzException) { /*su código para manejar el error de análisis*/ }
        }
        val analysisCancelable = OzLivenessSDK.uploadMediaAndAnalyze(
            mediaList,
            listOf(OzAnalysis.QUALITY, OzAnalysis.BIOMETRY),
            statusListener
        )

Java

StatusListener<List<OzAnalysisResult>> statusListener = new StatusListener<List<OzAnalysisResult>>() {
            @Override public void onStatusChanged(@Nullable String s) { /*su código para mostrar el mensaje de estado*/ }
            @Override public void onSuccess(List<OzAnalysisResult> result) { /* su código para manejar el resultado del análisis */ }
            @Override public void onError(@NonNull OzException e) { /* su código para manejar el error de análisis */ }
        };
        Cancelable analysisCancelable = OzLivenessSDK.INSTANCE.uploadMediaAndAnalyze(
            mediaList,
            Arrays.asList(OzAnalysis.QUALITY, OzAnalysis.BIOMETRY),
            statusListener
        );

Análisis en el dispositivo

Utilice los siguientes métodos para ejecutar el análisis en el dispositivo:

Kotlin

OzLivenessSDK.runOnDeviceLivenessAnalysis(mediaList)
OzLivenessSDK.runOnDeviceBiometryAnalysis(mediaList)

Java

OzLivenessSDK.INSTANCE.runOnDeviceLivenessAnalysis(mediaList);
OzLivenessSDK.INSTANCE.runOnDeviceBiometryAnalysis(mediaList);

Other Oz Mobile SDK Methods

Otros métodos del SDK de Oz Mobile

Comprueba la presencia del token de acceso a la Oz API guardado:

Kotlin

val isLoggedIn = OzLivenessSDK.isLoggedIn

Java

boolean isLoggedIn = OzLivenessSDK.INSTANCE.isLoggedIn();

LogOut:

Kotlin

OzLivenessSDK.logout()

Java

OzLivenessSDK.INSTANCE.logout();

Interacciones con el servidor de Oz API

Retrofit API

El SDK contiene la interfaz IOzForensicsAPI, que describe las llamadas de red a la API, que se pueden usar para crear una instancia de Retrofit.

Esta interfaz utiliza un convertidor gson y opera con clases del paquete com.ozforensics.liveness.sdk.api.model.

Aparte de esto, la interfaz especifica un método estático para crear una instancia de Retrofit por defecto (sin escritura en registro, interceptores y con tiempos de espera de 15 segundos). Esta instancia buscará el servidor en la dirección especificada:

Kotlin

val apiService = OzForensicsAPI.create(BASE_URL)

Java

OzForensicsAPI apiService = OzForensicsAPI.Factory.create(BASE_URL);

Clase OzForensicsService

El SDK incluye la clase OzForensicsService que utiliza una instancia de Retrofit de OzForensicsAPI.create(). Esta clase envuelve las llamadas de red de la interfaz de Retrofit y comprueba la presencia de un token. Cuando se realiza una solicitud de autentificación, el token se almacena automáticamente para objetivos internos. Además, se agregan los metadatos necesarios cuando se realizan las solicitudes de red (creación de una carpeta, carga de datos multimedia para su análisis). Las llamadas a métodos de esta clase son asíncronas (se utiliza la interfaz StatusListener<>). Puede obtener una instancia de esta clase de la siguiente manera:

Kotlin

val service = OzForensicsService(BASE_URL, ACCESS_TOKEN)

Java

OzForensicsService service = OzForensicsService(BASE_URL, ACCESS_TOKEN);

Si el valor del parámetro TOKEN es null, se requiere autorización antes de realizar cualquier llamada a la API (excepto auth):

Kotlin

service.auth(EMAIL, PASSWORD, listener)

Java

service.auth(EMAIL, PASSWORD, listener);

Después de una solicitud correcta, se ejecuta onSuccessCallback para que el token de acceso se pueda transferir con AuthResponse.