DOT Android Face library

v7.5.2

Introduction

DOT Android Face as a part of the DOT Android libraries family provides components for the digital onboarding process using the latest Innovatrics IFace image processing library. It wraps the core functionality of IFace library to a higher-level module which is easy to integrate into an Android application.

Requirements

DOT Android Face has the following requirements:

Minimum Android API level 21
Minimum Kotlin Gradle plugin version 1.6.0 (if used)

Distribution

Modularization

DOT Android Face is divided into core module and optional feature modules. This enables you to reduce the size of the library and include only modules that are actually used in your use case.

DOT Android Face is divided into following modules:

dot-face-core (Required) - provides API for all the features and functionalities.
dot-face-detection-fast (Optional) - enables the fast face detection feature.
dot-face-detection-balanced (Optional) - enables the balanced face detection feature.
dot-face-verification (Optional) - enables template extraction and face and template matching features.
dot-face-eye-gaze-liveness (Optional) - enables the eye gaze liveness feature.
dot-face-passive-liveness (Optional) - enables the passive liveness feature.
dot-face-background-uniformity (Optional) - enables the background uniformity evaluation feature.
dot-face-expression-neutral (Optional) - enables the face expression evaluation feature.

Each feature module can have other modules as their dependency and cannot be used without it, see the table below. Modules dot-face-detection-fast and dot-face-detection-balanced belong to one category, therefore only one of them can be activated.

Table 1. Module dependencies
Module	Dependency
`dot-face-detection-fast`	`dot-face-core`
`dot-face-detection-balanced`	`dot-face-core`
`dot-face-verification`	`dot-face-detection-*`
`dot-face-eye-gaze-liveness`	`dot-face-detection-*`
`dot-face-passive-liveness`	`dot-face-detection-*`
`dot-face-background-uniformity`	`dot-face-detection-*`
`dot-face-expression-neutral`	`dot-face-detection-*`

dot-face-detection-* stands for either dot-face-detection-fast or dot-face-detection-balanced.

For example, if you want to use Eye Gaze Liveness you will have to use these three modules: dot-face-eye-gaze-liveness, dot-face-detection-*(required by dot-face-eye-gaze-liveness) and dot-face-core(always required).

Maven Repository

DOT Android Face is distributed as a set of Android libraries (.aar packages) stored in the Innovatrics maven repository. Each library represents a single module.

In order to integrate DOT Android Face into your project, the first step is to include the Innovatrics maven repository and Google repository to your top level build.gradle file.

build.gradle

allprojects {
    repositories {
        maven {
            url 'https://maven.innovatrics.com/releases'
        }
    }
}

Then, specify the dependencies of DOT Android Face libraries in the app build.gradle file. Dependencies of these libraries will be downloaded alongside them.

build.gradle

dependencies {
    //…
    implementation "com.innovatrics.dot:dot-face-core:$dotVersion"
    implementation "com.innovatrics.dot:dot-face-detection-fast:$dotVersion"
    implementation "com.innovatrics.dot:dot-face-verification:$dotVersion"
    implementation "com.innovatrics.dot:dot-face-eye-gaze-liveness:$dotVersion"
    implementation "com.innovatrics.dot:dot-face-passive-liveness:$dotVersion"
    implementation "com.innovatrics.dot:dot-face-background-uniformity:$dotVersion"
    implementation "com.innovatrics.dot:dot-face-expression-neutral:$dotVersion"
    //…
}

In order to optimize application size, we also recommend adding the following excludes to your application’s build.gradle file.

build.gradle

android {
    //…
    packagingOptions {
        exclude("**/libjnidispatch.a")
        exclude("**/jnidispatch.dll")
        exclude("**/libjnidispatch.jnilib")
        exclude("**/*.proto")
    }
}

Supported Architectures

DOT Android Face provides binaries for these architectures:

armeabi-v7a
arm64-v8a
x86
x86_64

If your target application format is APK and not Android App Bundle, and the APK splits are not specified, the generated APK file will contain binaries for all available architectures. Therefore we recommend to use APK splits. For example, to generate arm64-v8a APK, add the following section into your module build.gradle:

build.gradle

splits {
    abi {
        enable true
        reset()
        include 'arm64-v8a'
        universalApk false
    }
}

If you do not specify this section, the resulting application can become too large in size.

Licensing

In order to use DOT SDK in other apps, it must be licensed. The license can be compiled into the application as it is bound to the application ID specified in build.gradle:

build.gradle

defaultConfig {
    applicationId "com.innovatrics.dot.sample"
    //…
}

The application ID can be also retrieved in runtime by calling DotSdk.getApplicationId().

In order to obtain the license, please contact your Innovatrics’ representative specifying the application ID. If the application uses build flavors with different application IDs, each flavor must contain a separate license. Put the license file into the raw resource folder.

Permissions

DOT Android Face declares the following permission in AndroidManifest.xml:

AndroidManifest.xml

<uses-permission android:name="android.permission.CAMERA" />

Basic Setup

Initialization

Before using any of the components, you need to initialize DOT SDK with the license, DotFaceLibrary object and list of feature modules you want to use. Each feature module can be activated by a *Module class. See the table below.

Table 2. DOT Android Face feature modules
Feature module	Class
`dot-face-detection-fast`	`DotFaceDetectionFastModule`
`dot-face-detection-balanced`	`DotFaceDetectionBalancedModule`
`dot-face-verification`	`DotFaceVerificationModule`
`dot-face-eye-gaze-liveness`	`DotFaceEyeGazeLivenessModule`
`dot-face-passive-liveness`	`DotFacePassiveLivenessModule`
`dot-face-background-uniformity`	`DotFaceBackgroundUniformityModule`
`dot-face-expression-neutral`	`DotFaceExpressionNeutralModule`

InitializeDotSdkUseCase class in the Samples project shows how to initialize DOT SDK with DotFaceLibrary and all feature modules. DotSdk.initialize() method should be called on background thread.

As a result of the initialization a dot folder under the application files folder is created.

Keep in mind that if you try to use any feature which was not added during initialization, it will throw an exception.

Deinitialization

When a process (e.g. onboarding) using the DOT Android Face has been completed, it is usually a good practice to free the resources used by it.

You can perform this by calling DotSdk.deinitialize(). If you want to use the DOT Android Face components again after that point, you need to call DotSdk.initialize() again. This shouldn’t be performed within the lifecycle of individual Android components.

Logging

By default, logging is disabled. You can enable it by using the following method from the com.innovatrics.dot.core.Logger class.

Logger.setLoggingEnabled(true)

The appropriate place for this call is within the onCreate() method of your subclass of android.app.Application. Each tag of a log message starts with the dot-face: prefix.

This setting enables logging for all DOT Android libraries.

Please note that logging should be used just for debugging purposes as it might produce a lot of log messages.

Components

Overview

DOT Android Face provides both non-UI and UI components. Non-UI components are aimed to be used by developers who want to build their own UI using the DOT Android Face functionality. UI components are build on top of non-UI components. These are available as abstract fragments and can be extended and then embedded into the application’s existing activity providing more control.

List of Non-UI Components

FACE DETECTOR: A component for performing face detection on an image, creating templates and evaluating face attributes.
TEMPLATE MATCHER: A component for performing template matching.
FACE MATCHER: A component for performing face matching.

List of UI Components

FACE AUTO CAPTURE: A visual component for capturing good quality images of a human face.
FACE SIMPLE CAPTURE: A visual component for capturing face images and creating templates suitable for matching without considering image quality requirements.
EYE GAZE LIVENESS: A visual component which performs the liveness check based on object tracking. An object is shown on the screen and the user is instructed to follow the movement of this object by her/his eyes.
SMILE LIVENESS: A visual component which performs the liveness check based on the changes in the face expression.
MAGNIFEYE LIVENESS: A visual component for capturing images suitable for MagnifEye liveness evaluation.

Non-UI Components

Face Detector

The FaceDetector interface provides the face detection functionality. Face detection stops when maximumFaces is reached. This component requires dot-face-detection-* module.

Create a FaceDetector:

val faceDetector = FaceDetectorFactory.create()

To perform detection, call the following method on the background thread:

val detectedFaces = faceDetector.detect(faceImage, maximumFaces)

Template Matcher

In order to match face templates (1:1), use the TemplateMatcher interface. The recommended approach is to create face templates using FaceDetector or Face Auto Capture component and use only templates for matching. This component requires dot-face-verification module.

Create a TemplateMatcher:

val templateMatcher = TemplateMatcherFactory.create()

To perform matching, call the following method on the background thread:

val result = templateMatcher.match(referenceTemplate, probeTemplate)

Face Matcher

In order to match face images (1:1), use the FaceMatcher interface. It is also possible to match a face image against a template (This is a recommended approach if you already have an available reference template). This component requires dot-face-verification module.

Create a FaceMatcher:

val faceMatcher = FaceMatcherFactory.create()

To perform matching, call one of the following methods on the background thread:

val result = faceMatcher.match(referenceFaceImage, probeFaceImage)
val result = faceMatcher.match(referenceTemplate, probeFaceImage)
val result = faceMatcher.match(referenceTemplate, probeTemplate)

UI Components

Fragment Configuration

Components containing UI are embedded into the application as fragments from Android Support Library. All fragments are abstract. They must be subclassed and override their abstract methods.

Fragments requiring runtime interaction provide public methods, for example start().

class DemoFaceAutoCaptureFragment : FaceAutoCaptureFragment() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        start()
    }

    //…
}

The FaceAutoCaptureFragment requires a configuration. To provide configuration data, you should override the provideConfiguration() method in your subclass implementation. This method should return an instance of the FaceAutoCaptureFragment.Configuration data class with the desired parameters.

class DemoFaceAutoCaptureFragment : FaceAutoCaptureFragment() {

    override fun provideConfiguration() = Configuration(
        cameraFacing = CameraFacing.FRONT,
        cameraPreviewScaleType = CameraPreviewScaleType.FIT,
        //…
    )

    //…
}

Face size ratio interval

If a face present in an image has the face size out of the face size ratio interval, it won’t be detected. Please note that a wider interval results in a lower performance (detection FPS).

Camera permission

A fragment (UI component) will check the camera permission (Manifest.permission.CAMERA) right before the camera is started. If the camera permission is granted the fragment will start the camera. If the camera permission is not granted the fragment will use Android API - ActivityResultContracts.RequestPermission to request the camera permission. Android OS will present the system dialog to the user of the app. If the user explicitly denies the permission at this point, onNoCameraPermission() callback is called. Implement this callback in order to navigate the user further in your app workflow.

Orientation Change

In order to handle the orientation change in multi-window mode correctly, configure the activity in your AndroidManifest.xml file as follows:

<activity
    android:name=".MyActivity"
    android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation" />

Face Auto Capture

The fragment with instructions for obtaining quality face images suitable for further processing. This component requires dot-face-detection-* module. If you want to evaluate background uniformity during the face auto capture process, you will also need dot-face-background-uniformity module. If you want to evaluate face mask during the face auto capture process, you will need dot-face-detection-balanced module.

In order to configure the behaviour of FaceAutoCaptureFragment, use FaceAutoCaptureFragment.Configuration (see Fragment Configuration).

To use the fragment, create a subclass of FaceAutoCaptureFragment and override appropriate callbacks.

Start the face auto capture process:

Check whether DOT Android Face is initialized. This step is important, because Android OS can terminate an application running in background in order to free resources and then it creates an instance of the top activity in the activity stack. At this point the DOT Android Face is no longer initialized and the face auto capture process must not be started.
If DOT Android Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT Android Face and call start() in the DotFaceLibrary.InitializationListener callback.

In case you want to handle detection data, implement onProcessed() callback. This callback is called with each processed camera frame. The callback onCandidateSelectionStarted() is called only once for the whole process, when candidate selection is started. When the face auto capture process finishes successfully, the result will be returned via the onCaptured() callback.

In case you want to force the capture event, call the requestCapture() method. The most recent image will be returned via the onCaptured() callback asynchronously.

Call start() method again in case you need to start over the face auto capture process. You can also call start() method to stop and start over ongoing process as well.

In case you want to stop the face auto capture process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the face auto capture process has started, it is not safe to deinitialize the DOT Android Face until one of these callbacks is called:

onCaptured()
callback argument of stopAsync() method

Quality Attributes of the Output Image

You may adjust quality requirements for the output image. To perform this, you can use pre-defined instances - QualityAttributeThresholds - from QualityAttributeThresholdPresets with recommended thresholds and pass it to FaceAutoCaptureFragment.Configuration by setting the qualityAttributeThresholds. You can also create your own instance of QualityAttributeThresholds from scratch or based on pre-defined instances according to your needs.

Possible ways how to create QualityAttributeThresholds:

// The standard preset
val standard = QualityAttributeThresholdPresets.standard

// Modified thresholds based on the standard preset
val modified = QualityAttributeThresholdPresets.standard.copy(
    minConfidence = minConfidence,
    minSharpness = null,
)

// Custom thresholds
val custom = QualityAttributeThresholds(
    minConfidence = minConfidence,
    minSharpness = minSharpness,
)

Available presets (pre-defined instances with thresholds) in QualityAttributeThresholdPresets:

standard - The resulting image suitable for matching. See the thresholds.
passiveLiveness - The resulting image suitable for evaluation of the passive liveness. See the thresholds.
icao - The resulting image passing ICAO checks. See the thresholds.

Face Simple Capture

The fragment for obtaining images for matching without considering any image quality requirements. This component requires dot-face-detection-* module.

In order to configure the behaviour of FaceSimpleCaptureFragment, use FaceSimpleCaptureFragment.Configuration (see Fragment Configuration).

To use the fragment, create a subclass of FaceSimpleCaptureFragment and override appropriate callbacks.

Start the face simple capture process:

Check whether DOT Android Face is initialized. This step is important, because Android OS can terminate an application running in background in order to free resources and then it creates an instance of the top activity in the activity stack. At this point the DOT Android Face is no longer initialized and the face simple capture process must not be started.
If DOT Android Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT Android Face and call start() in the DotFaceLibrary.InitializationListener callback.

You need to call requestCapture() method in order to request a capture. The component will capture a face as soon as it is detected. The result will be returned via the onCaptured() callback.

In case you want to stop the face simple capture process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the face simple capture process has started, it is not safe to deinitialize the DOT Android Face until one of these callbacks is called:

callback argument of stopAsync() method

Eye Gaze Liveness

The fragment with a moving or a fading object on the screen. This component requires dot-face-eye-gaze-liveness module.

In order to configure the behaviour of EyeGazeLivenessFragment, use EyeGazeLivenessFragment.Configuration (see Fragment Configuration).

To use the fragment, create a subclass of EyeGazeLivenessFragment and override appropriate callbacks:

class DemoEyeGazeLivenessFragment : EyeGazeLivenessFragment() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        start()
    }

    override fun onStateChanged(state: EyeGazeLivenessState) {
        // Callback implementation
    }

    override fun onFinished(score: Float, segmentImages: List<SegmentImage>) {
        // Callback implementation
    }

    override fun onNoMoreSegments() {
        // Callback implementation
    }

    override fun onEyesNotDetected() {
        // Callback implementation
    }

    override fun onFaceTrackingFailed() {
        // Callback implementation
    }

    override fun onNoCameraPermission() {
        // Callback implementation
    }

    override fun onStopped() {
        // Callback implementation
    }
}

Start the eye gaze liveness process:

Check whether DOT Android Face is initialized. This step is important, because Android OS can terminate an application running in background in order to free resources and then it creates an instance of the top activity in the activity stack. At this point the DOT Android Face is no longer initialized and the eye gaze liveness process must not be started.
If DOT Android Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT Android Face and call start() in the DotFaceLibrary.InitializationListener callback.

The eye gaze liveness follows segments: List<Segment> and renders an object in the specified corners of the screen. For the best accuracy it is recommended to display the object in at least three different corners.

If the user’s eyes can’t be detected in the first segment, the process will be terminated with the onEyesNotDetected() callback.

The process is automatically finished when the number of valid items in segmentImages reaches minValidSegmentCount. After that, onFinished() callback is called and the score can be evaluated.

The process fails with the onNoMoreSegments() callback when all the segments in segments: List<Segment> were displayed but it wasn’t possible to collect a number of valid images specified in minValidSegmentCount. You can use SegmentImage items for matching purposes, even when the eyes weren’t detected in a segment.

For a better user experience, it is recommended to provide the user more attempts, so the size of segments: List<Segment> should be greater than minValidSegmentCount. However, this should be limited, as it is better to terminate the process if the user is failing in many segments. The recommended way of segment generation is to use a RandomSegmentsGenerator:

val segmentsGenerator = RandomSegmentsGenerator()
val segmentCount = 8
val segmentDurationMillis = 800
val segments = segmentsGenerator.generate(segmentCount, segmentDurationMillis)

If you want to perform a server side validation of the liveness check, please follow this recommended approach:

The object movement is generated on your server and then rendered on the device using segments: List<Segment>. When the process is finished successfully, the segmentImages: List<SegmentImage> ` is transferred to the server to evaluate the liveness check. Please note that `segments is no longer transferred and you should store it in the session of the server. You can evaluate the liveness check by combining the corresponding segmentImages with segments and sending the request to DOT Core Server. If the user could finish the process without using all segments, the remaining items of segments should be dropped to match the number of items in segmentImages.

In case you want to stop the eye gaze liveness process prematurely, call the stopAsync() method. The onStopped() callback indicates that the processing is over.

Once the eye gaze liveness process has started, it is not safe to deinitialize the DOT Android Face until one of these callbacks is called:

onFinished()
onNoMoreSegments()
onEyesNotDetected()
onFaceTrackingFailed()
onStopped()

Custom object on the screen

The moving or fading object on the screen is a drawable resource res/drawable/eye_gaze_liveness_object.xml. It is a circle filled by ?attr/colorAccent color. If you want to use a custom object, override this resource.

If the device is in power save mode, the object can change its position without an animated transition. This is because Android OS in Power Save mode can force all animations on the phone including Eye Gaze Liveness animations to be turned off.

Smile Liveness

The fragment which performs the liveness check based on the changes in the face expression. This component requires dot-face-expression-neutral module.

In order to configure the behaviour of SmileLivenessFragment, use SmileLivenessFragment.Configuration (see Fragment Configuration).

To use the fragment, create a subclass of SmileLivenessFragment and override appropriate callbacks.

Start the smile liveness process:

Check whether DOT Android Face is initialized. This step is important, because Android OS can terminate an application running in background in order to free resources and then it creates an instance of the top activity in the activity stack. At this point the DOT Android Face is no longer initialized and the smile liveness process must not be started.
If DOT Android Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT Android Face and call start() in the DotFaceLibrary.InitializationListener callback.

In case you want to handle detection data, implement onProcessed() callback. This callback is called with each processed camera frame.

The process is automatically finished when both the neutral and the smile face expression images are captured. After that, onFinished() callback is called and the passive liveness and face matching can be evaluated.

If the face presence is lost after the neutral face expression image is captured, onCriticalFacePresenceLost() callback is called. If the face presence between the neutral and the smile face expression images is required, call start() method. Otherwise the callback can be ignored.

Call start() method in order to start over the smile liveness process. You can also call start() method to stop and start over ongoing process.

In case you want to stop the smile liveness process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the smile liveness process has started, it is not safe to deinitialize the DOT Android Face until one of these callbacks is called:

onFinished()
callback argument of stopAsync() method

MagnifEye Liveness

The fragment with instructions for obtaining face data suitable for MagnifEye liveness evaluation. This component requires dot-face-detection-* module.

In order to configure the behaviour of MagnifEyeLivenessFragment, use MagnifEyeLivenessFragment.Configuration (see Fragment Configuration).

To use the fragment, create a subclass of MagnifEyeLivenessFragment and override appropriate callbacks.

Start the MagnifEye liveness process:

Check whether DOT Android Face is initialized. This step is important, because Android OS can terminate an application running in background in order to free resources and then it creates an instance of the top activity in the activity stack. At this point the DOT Android Face is no longer initialized and the smile liveness process must not be started.
If DOT Android Face is initialized, you can call the start() method immediately. If not, you need to initialize DOT Android Face and call start() in the DotFaceLibrary.InitializationListener callback.

In case you want to handle detection data, implement onProcessed() callback. This callback is called with each processed camera frame. When the MagnifEye liveness process finishes successfully, the result will be returned via the onFinished() callback.

In case you want to stop the MagnifEye liveness process prematurely, call the stopAsync() method. The callback in the method argument indicates that the processing is over.

Once the MagnifEye liveness process has started, it is not safe to deinitialize the DOT Android Face until one of these callbacks is called:

onFinished()
callback argument of stopAsync() method

Customization of UI components

Strings

You can override the string resources in your application and provide alternative strings for supported languages using the standard Android localization mechanism.

<string name="dot_eye_gaze_liveness_instruction_face_not_present">Look straight</string>
<string name="dot_eye_gaze_liveness_instruction_face_too_close">Move back</string>
<string name="dot_eye_gaze_liveness_instruction_face_too_far">Move closer</string>
<string name="dot_eye_gaze_liveness_instruction_lighting">Turn towards light</string>
<string name="dot_eye_gaze_liveness_instruction_watch_object">Watch the object</string>
<string name="dot_face_auto_capture_instruction_background_nonuniform">Plain background required</string>
<string name="dot_face_auto_capture_instruction_candidate_selection">Stay still&#8230;</string>
<string name="dot_face_auto_capture_instruction_device_pitch_too_high">Hold your phone at eye level</string>
<string name="dot_face_auto_capture_instruction_eyes_too_closed">Open your eyes</string>
<string name="dot_face_auto_capture_instruction_face_centering">Center your face</string>
<string name="dot_face_auto_capture_instruction_face_not_present">Position your face into the circle</string>
<string name="dot_face_auto_capture_instruction_face_too_close">Move back</string>
<string name="dot_face_auto_capture_instruction_face_too_far">Move closer</string>
<string name="dot_face_auto_capture_instruction_expression_neutral_too_high">Smile :)</string>
<string name="dot_face_auto_capture_instruction_expression_neutral_too_low">Keep neutral expression</string>
<string name="dot_face_auto_capture_instruction_glasses_present">Remove glasses</string>
<string name="dot_face_auto_capture_instruction_lighting">Turn towards light</string>
<string name="dot_face_auto_capture_instruction_mask_present">Remove mask</string>
<string name="dot_face_auto_capture_instruction_mouth_too_open">Close your mouth</string>
<string name="dot_face_auto_capture_instruction_pitch_too_high">Lower your chin</string>
<string name="dot_face_auto_capture_instruction_pitch_too_low">Lift your chin</string>
<string name="dot_face_auto_capture_instruction_yaw_too_left">Look right</string>
<string name="dot_face_auto_capture_instruction_yaw_too_right">Look left</string>
<string name="dot_face_magnifeye_liveness_instruction_eye_centering">Fit your eye into square</string>

Colors

You may customize the colors used by DOT Android Face in your application. To use custom colors, override the specific color.

<color name="dot_detection_layer">#ffffffff</color>
<color name="dot_eye_gaze_liveness_background">#ffffffff</color>
<color name="dot_face_auto_capture_background_overlay">#80131313</color>
<color name="dot_face_auto_capture_circle_outline">#ffffff</color>
<color name="dot_face_auto_capture_circle_outline_stay_still">#ff00bfb2</color>
<color name="dot_face_auto_capture_tracking_circle_outline">#ffffffff</color>
<color name="dot_face_auto_capture_instruction_text">#ff131313</color>
<color name="dot_face_auto_capture_instruction_text_background">#fff8fbfb</color>
<color name="dot_face_auto_capture_instruction_text_stay_still">#ff131313</color>
<color name="dot_face_auto_capture_instruction_text_background_stay_still">#ff00bfb2</color>
<color name="dot_instruction_background">#fff8fbfb</color>
<color name="dot_instruction_candidate_selection_background">#ff00bfb2</color>
<color name="dot_instruction_text">#ff131313</color>
<color name="dot_placeholder">#ffffffff</color>
<color name="dot_placeholder_candidate_selection">#ff00bfb2</color>
<color name="dot_placeholder_overlay">#80131313</color>

Styles

You can style the text views and buttons by overriding the parent style in the application. The default style is AppCompat.

<style name="TextAppearance.Dot.Medium" />
<style name="TextAppearance.Dot.Medium.Instruction" />

Permission android.permission.INTERNET from Android manifest.

7.5.1 - 2024-04-15

Added

Section about optimization of application size to integration manual.

DOT Android Face library

v7.5.2#

v7.5.2