### Set Environment Variables for Credentials (Windows)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.1.0/installation

Provides instructions for setting system environment variables MYCLOUDREPO_CLIENT_USERNAME and MYCLOUDREPO_CLIENT_PASSWORD on Windows. This is an alternative to adding credentials directly to gradle.properties.

```shell
1. Right-click the Computer icon and choose Properties, or in Windows Control Panel, choose System. 
2. Choose Advanced system settings. 
3. On the Advanced tab, click Environment Variables. 
4. Click New to create two new environment variables:
    Variable name: MYCLOUDREPO_CLIENT_USERNAME Varaible value:<Your username>
    Variable name: MYCLOUDREPO_CLIENT_PASSWORD Variable value:<Your password>
```

--------------------------------

### Configure Gradle for Paravision SDK Installation (.groovy)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.11.2/readme

This snippet shows how to configure your project's build.gradle file to include the Paravision Face Recognition SDK. It specifies packaging options for JNI libraries and declares the necessary SDK and its dependencies. Ensure you have the correct versions of the SDK and its dependencies.

```groovy
packagingOptions {
	jniLibs {
		pickFirsts += ['**/*.so']
		doNotStrip += ['**/*.so']
	}
}

implementation "ai.paravision.sdk.corelibs:ParavisionCore@aar"
implementation "ai.paravision.sdk.fd:ParavisionFR@aar"

// SDK dependencies
// LiteRT
implementation 'com.google.ai.edge.litert:litert:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu-api:1.4.0'
implementation 'com.google.ai.edge.litert:litert-support:1.4.0'
// QNN
implementation 'com.qualcomm.qti:qnn-litert-delegate:2.36.0'
implementation 'com.qualcomm.qti:qnn-runtime:2.36.0'
// Math
implementation 'org.ejml:ejml-simple:0.43.1'
```

--------------------------------

### Configure build.gradle for Paravision Android SDK Installation

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v2.11.2/readme

This snippet configures the `build.gradle` file for the Paravision Android SDK. It includes packaging options for JNI libraries and specifies the implementation dependencies for the Paravision SDK core and face validness modules, along with their required libraries like LiteRT, QNN, and EJML.

```gradle
packagingOptions {
	jniLibs {
		pickFirsts += ['**/*.so']
		doNotStrip += ['**/*.so']
	}
}

implementation "ai.paravision.sdk.corelibs:ParavisionCore@aar"
implementation "ai.paravision.sdk.fd:ParavisionFV@aar"

// SDK dependencies
// LiteRT
implementation 'com.google.ai.edge.litert:litert:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu-api:1.4.0'
implementation 'com.google.ai.edge.litert:litert-support:1.4.0'
// QNN
implementation 'com.qualcomm.qti:qnn-litert-delegate:2.36.0'
implementation 'com.qualcomm.qti:qnn-runtime:2.36.0'
// Math
implementation 'org.ejml:ejml-simple:0.43.1'
```

--------------------------------

### Add Paravision Android SDK Dependency

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.2.0/installation

This snippet shows how to include the Paravision Android SDK as an implementation dependency in the app's `build.gradle` file. It also includes example `packagingOptions` to resolve potential library conflicts.

```groovy
android{
    ...
    packagingOptions {
        pickFirst 'lib/*/libfbjni.so'
        pickFirst 'lib/*/libc++_shared.so'
    
    }
    ...
}
dependencies {
    ...
    implementation 'ai.paravision:AndroidFaceSDK:2.2.0-CPU'
    //implementation 'ai.paravision:AndroidFaceSDK:2.2.0-NNAPI'
    ...
}
```

--------------------------------

### Configure Gradle for Paravision SDK Integration

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.2/readme

This configuration snippet is added to the project's `build.gradle` file to correctly handle JNI libraries and declare the Paravision SDK core and face detection modules as dependencies. It ensures proper packaging of native libraries and resolves potential conflicts.

```gradle
packagingOptions {
	jniLibs {
		pickFirsts += ['**/*.so']
		doNotStrip += ['**/*.so']
	}
}

implementation "ai.paravision.sdk.corelibs:ParavisionCore@aar"
implementation "ai.paravision.sdk.fd:ParavisionFD@aar"

// SDK dependencies
// LiteRT
implementation 'com.google.ai.edge.litert:litert:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu-api:1.4.0'
implementation 'com.google.ai.edge.litert:litert-support:1.4.0'
// QNN
implementation 'com.qualcomm.qti:qnn-litert-delegate:2.36.0'
implementation 'com.qualcomm.qti:qnn-runtime:2.36.0'
// Math
implementation 'org.ejml:ejml-simple:0.43.1'
```

--------------------------------

### Example: Asynchronous Video Frame Processing (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/usage

An example demonstrating how to call the `processFullVideoFrame` function in Kotlin. It shows how to set up display and detection options, provide a tracking ID, image proxy, overlay, and a listener to handle the detection results or any exceptions.

```kotlin
sdkInstance.processFullVideoFrame(
    inputTrackingId = youTrackingId, 
    proxy = yourImageProxyFromCameraX, 
    paravisionGraphicOverlay = paravisionGraphicOverlay,
    displayOptions = arrayOf(SHOW_BOUNDING_BOX, SHOW_LANDMARKS), 
    detectionOptions = arrayOf(BOUNDING_BOX, QUALITY, LANDMARK),
    findMostProminentFace = true,
    faceDetectionListener = object : ParavisionFaceSDK.ProcessResultListener<ParavisionFaceResult> {
        override fun onResult(result: ParavisionFaceResult) {
            // getting the detection result
            val trackingId = result.inputTrackingId
            val mostProminentFaceIdx =  result.mostProminentFaceIdx
            val faces = result.faces
            for (face:Face in faces){
                // ... Iterate each face in the result
            }
        }
        override fun onError(exception: ParavisionException) {
            // Handle exception
        }
    }
)
```

--------------------------------

### Load Image from Camera using Kotlin

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.6.0/usage

Configures and initializes the camera to capture images for analysis. It sets up preview, image analysis with backpressure strategy, and binds these use cases to the camera lifecycle. This example utilizes `ProcessCameraProvider`, `ImageAnalysis`, and `UseCaseGroup` from Android's CameraX library.

```kotlin
ProcessCameraProvider.getInstance(this).let { provider ->
    provider.addListener({
        val cameraProvider: ProcessCameraProvider = provider.get()
        val preview = Preview.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
            .build()
            .also {
                it.setSurfaceProvider(binding.cameraPreview.surfaceProvider)
            }
        val imageAnalysis = ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setTargetResolution(Size(3000, 4000))
            .build()
            .also {
                it.setAnalyzer(executor) { proxy ->
                    processFrame(proxy.image!!, proxy.imageInfo)
                    proxy.close()
                }
            }
        val useCaseGroup = UseCaseGroup.Builder()
            .addUseCase(preview)
            .addUseCase(imageAnalysis)
            .addUseCase(imageCapture)
            .build()

        try {
            cameraProvider.unbindAll()
            cameraProvider.bindToLifecycle(this, CameraSelector.DEFAULT_FRONT_CAMERA, useCaseGroup)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }, ContextCompat.getMainExecutor(this))
}

private fun processFrame(image: Image, info: ImageInfo) {
    imageToBitmap(image)?.let {
        val bitmap = rotateBitmap(it, info.rotationDegrees)
        processBitmap(bitmap)
    }
}
```

--------------------------------

### Load Image from Camera (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.10.0/usage

Configures and starts the camera to capture images for analysis. It sets up preview and image analysis use cases, including image rotation and a strategy to keep only the latest frame for processing. The image analysis uses a provided executor and processes the image to be converted to a bitmap.

```kotlin
ProcessCameraProvider.getInstance(this).let { provider ->
    provider.addListener({
        val cameraProvider: ProcessCameraProvider = provider.get()
        val preview = Preview.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
            .build()
            .also {
                it.setSurfaceProvider(binding.cameraPreview.surfaceProvider)
            }
        val imageAnalysis = ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setTargetResolution(Size(3000, 4000))
            .build()
            .also {
                it.setAnalyzer(executor) { proxy ->
                    imageToBitmap(proxy.image!!)?.let {
                    	val rotatedBitmap = rotateBitmap(bitmap, proxy.imageInfo.rotationDegrees)
                    	processImage(Image(rotatedBitmap))
                    }
                    proxy.close()
                }
            }
        val useCaseGroup = UseCaseGroup.Builder()
            .addUseCase(preview)
            .addUseCase(imageAnalysis)
            .addUseCase(imageCapture)
            .build()

        try {
            cameraProvider.unbindAll()
            cameraProvider.bindToLifecycle(this, CameraSelector.DEFAULT_FRONT_CAMERA, useCaseGroup)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }, ContextCompat.getMainExecutor(this))
}
```

--------------------------------

### Configure Gradle Properties for Credentials

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.1.0/installation

Sets up client credentials for accessing the Paravision Maven repository by defining MYCLOUDREPO_CLIENT_USERNAME and MYCLOUDREPO_CLIENT_PASSWORD in the gradle.properties file. This step can be skipped if using environment variables.

```properties
MYCLOUDREPO_CLIENT_USERNAME=<Your username>
MYCLOUDREPO_CLIENT_PASSWORD=<Your password>
```

--------------------------------

### Configure Maven Repository for Gradle < 7.0.0

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.2.0/installation

This snippet shows how to add the Paravision Maven repository to the project-level `build.gradle` file for older Gradle versions. It includes the repository URL and placeholder credentials.

```groovy
allprojects {
    repositories {
        google()
        mavenCentral()
        maven {
            url 'https://paravision.mycloudrepo.io/repositories/android-sdk-kotlin'
            credentials {
                username "MYCLOUDREPO_CLIENT_USERNAME"
                password "MYCLOUDREPO_CLIENT_PASSWORD"
            }

            // You can also specify system envrioment variables
            //credentials {
            //    username System.getenv(MYCLOUDREPO_CLIENT_USERNAME)
            //    password System.getenv(MYCLOUDREPO_CLIENT_PASSWORD)
            //}
        }
        ...
    }
}
```

--------------------------------

### Android App Initialization for Paravision Face Detection SDK Libraries

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.7.0/installation

This code demonstrates how to initialize the necessary native libraries for the Paravision Face Detection SDK, PyTorch, and OpenCV within your Android application's onCreate method. It checks if NativeLoader is already initialized before proceeding.

```kotlin
override fun onCreate() {
    super.onCreate()

    if (!NativeLoader.isInitialized()) {
        NativeLoader.init(SystemDelegate())
    }
    NativeLoader.loadLibrary("pytorch_jni")
    NativeLoader.loadLibrary("torchvision_ops")
    NativeLoader.loadLibrary("opencv_java4")
}
```

--------------------------------

### Add Paravision SDK and Dependencies to build.gradle

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/readme

These lines are added to the `dependencies` section of the `build.gradle` file to include the Paravision Core and Face Detection SDKs, along with their required runtime libraries for different hardware acceleration backends (LiteRT, Hexagon, QNN) and mathematical operations.

```gradle
implementation "ai.paravision.sdk.corelibs:ParavisionCore@aar"
implementation "ai.paravision.sdk.fd:ParavisionFD@aar"

// SDK dependencies
// LiteRT
implementation 'com.google.ai.edge.litert:litert:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu:1.4.0'
implementation 'com.google.ai.edge.litert:litert-gpu-api:1.4.0'
implementation 'com.google.ai.edge.litert:litert-support:1.4.0'
// Hexagon
implementation 'io.github.google-ai-edge:litert-hexagon:0.1.0'
// QNN
implementation 'com.qualcomm.qti:qnn-litert-delegate:2.36.0'
implementation 'com.qualcomm.qti:qnn-runtime:2.36.0'
// Math
implementation 'org.ejml:ejml-simple:0.43.1'
```

--------------------------------

### Android build.gradle Configuration for Paravision Face Detection SDK

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.7.0/installation

This snippet shows how to configure your project's build.gradle file to include the Paravision Face Detection SDK, OpenCV, PyTorch, and Facebook SoLoader as dependencies. Ensure these versions are compatible with your project.

```gradle
api "org.opencv:opencv@aar"
api "ai.paravision.sdk.fd:ParavisionFD@aar"

// additional packages
api "org.pytorch:pytorch_android_lite:1.10.0"
api "org.pytorch:pytorch_android_torchvision_lite:1.10.0"
api "org.pytorch:torchvision_ops:0.10.0"

api 'com.facebook.soloader:soloader:0.10.3'
```

--------------------------------

### Specify ABI Filters for App Bundle Size

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.2.0/installation

This snippet demonstrates how to configure `abiFilters` within the `app/build.gradle` file to reduce the final APK/AAB size by including only specific ABIs.

```groovy
android {
 ...
  defaultConfig {
     ndk {
             abiFilters 'arm64-v8a' //"x86", "armeabi-v7a"
         }
  }
  ...
 }
```

--------------------------------

### Example: Asynchronous Video Frame Processing (Java)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/usage

An example demonstrating how to call the `processFullVideoFrame` function in Java. It illustrates setting up display and detection options, passing necessary parameters including a tracking ID, image proxy, overlay, and a listener for processing results and errors.

```java
DisplayOption[] displayOptions = {SHOW_BOUNDING_BOX, SHOW_LANDMARKS};
FaceDetectionOption[] detectionOptions = {BOUNDING_BOX, QUALITY, LANDMARK};
sdkInstance.processFullVideoFrame(
    yourTrackingId, 
    yourImageProxyFromCameraX, 
    paravisionGraphicOverlay, 
    displayOptions
    detectionOptions,
    true, //findMostProminentFace 
    new ParavisionFaceSDK.ProcessResultListener<ParavisionFaceResult> () {
        @override 
        void onResult(ParavisionFaceResult result) {
            // getting the detection result
            String trackingId = result.inputTrackingId
            Int mostProminentFaceIdx =  result.mostProminentFaceIdx
            List<Face> faces = result.faces
            for (Face face : faces){
                // ... Iterate each face in the result
            }
        }
        @override 
        void onError(ParavisionException exception) {
                // Handle exception
        }
    }
);
```

--------------------------------

### Configure Maven Repository for Gradle >= 7.0.0

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.2.0/installation

This snippet demonstrates adding the Paravision Maven repository to the `settings.gradle` file for projects using Android Studio Arctic Fox or newer with Gradle version 7.0.0 or higher. It specifies the repository name, URL, and credentials.

```groovy
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven {
            name 'Paravision Android SDK'
            url 'https://paravision.mycloudrepo.io/repositories/android-sdk-kotlin'
            credentials {
                username "MYCLOUDREPO_CLIENT_USERNAME"
                password "MYCLOUDREPO_CLIENT_USERNAME"
            }

            // You can also specify system envrioment variables
            //credentials {
            //    System.getenv(MYCLOUDREPO_CLIENT_USERNAME)
            //    System.getenv(MYCLOUDREPO_CLIENT_PASSWORD)
            //}
        }
    }
}
```

--------------------------------

### Configure Android Build for Paravision SDK

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/readme

This configuration snippet is added to the `build.gradle` file of an Android project to ensure proper handling of native libraries (.so files) included in the Paravision SDK. It ensures that .so files are picked first and are not stripped, which is crucial for the SDK's functionality.

```gradle
packagingOptions {
  jniLibs {
	pickFirsts += ['**/*.so']
	doNotStrip += ['**/*.so']
  }
}
```

--------------------------------

### Add Paravision SDK Dependency

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/installation

Includes the Paravision Android SDK as an implementation dependency in the app's build.gradle file. This line makes the SDK's functionality available for use in your Android application.

```groovy
android{
    ...
    packagingOptions {
        pickFirst 'lib/*/*.so'
    }
    ...
}
dependencies {
    ...
    implementation 'ai.paravision:AndroidFaceSDK:2.3.0-CPU'
    //implementation 'ai.paravision:AndroidFaceSDK:2.3.0-NNAPI'
    ...
}
```

--------------------------------

### Add Paravision Maven Repository (Gradle < 7.0)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.1.0/installation

Configures the project-level build.gradle file to include the Paravision Maven repository for projects using Gradle versions older than 7.0 or prior to Android Studio Arctic Fox. This allows Gradle to download the SDK artifacts.

```groovy
allprojects {
    repositories {
        google()
        mavenCentral()
        maven {
            url 'https://paravision.mycloudrepo.io/repositories/android-sdk-kotlin'
            credentials {
                username "MYCLOUDREPO_CLIENT_USERNAME"
                password "MYCLOUDREPO_CLIENT_PASSWORD"
            }

            // You can also specify system envrioment variables
            //credentials {
            //    username System.getenv(MYCLOUDREPO_CLIENT_USERNAME) 
            //    password System.getenv(MYCLOUDREPO_CLIENT_PASSWORD)
            //}
        }
        ...
    }
}
```

--------------------------------

### Optimize App Bundle Size with abiFilters

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/installation

Configures the abiFilters within the app's build.gradle file to specify which Application Binary Interfaces (ABIs) to include in the app bundle. This helps reduce the final APK/AAB size by only including necessary native libraries.

```groovy
android {
 ...
  defaultConfig {
     ndk {
             abiFilters 'arm64-v8a' //"x86", "x86_64", "armeabi-v7a"
         }
  }
  ...
 }
```

--------------------------------

### Load Image from Camera (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/usage

Configures and binds camera use cases (preview, image analysis, capture) to the lifecycle. It sets up an ImageAnalysis analyzer to process frames from the camera, converting them to Bitmaps for further processing. This example uses ProcessCameraProvider for camera operations.

```kotlin
ProcessCameraProvider.getInstance(this).let { provider ->
    provider.addListener({
        val cameraProvider: ProcessCameraProvider = provider.get()
        val preview = Preview.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
            .build()
            .also {
                it.setSurfaceProvider(binding.cameraPreview.surfaceProvider)
            }
        val imageAnalysis = ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setTargetResolution(Size(3000, 4000))
            .build()
            .also {
                it.setAnalyzer(executor) { proxy ->
                    imageToBitmap(proxy.image!!)?.let { bitmap ->
                    	val rotatedBitmap = rotateBitmap(bitmap, proxy.imageInfo.rotationDegrees)
                    	processImage(Image(rotatedBitmap))
                    }
                    proxy.close()
                }
            }
        val useCaseGroup = UseCaseGroup.Builder()
            .addUseCase(preview)
            .addUseCase(imageAnalysis)
            .addUseCase(imageCapture)
            .build()

        try {
            cameraProvider.unbindAll()
            cameraProvider.bindToLifecycle(this, CameraSelector.DEFAULT_FRONT_CAMERA, useCaseGroup)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }, ContextCompat.getMainExecutor(this))
}
```

--------------------------------

### Add Paravision SDK Dependencies to build.gradle

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.7.0/installation

Specifies the necessary dependencies for Paravision Face Recognition SDK, OpenCV, PyTorch Lite, and other required libraries in the Android project's build.gradle file. These lines ensure that the SDK and its components are correctly linked and available for use.

```gradle
api "org.opencv:opencv@aar"
api "ai.paravision.sdk.fr:ParavisionFR@aar"

// additional packages
api "org.pytorch:pytorch_android_lite:1.10.0"
api "org.pytorch:pytorch_android_torchvision_lite:1.10.0"
api "org.pytorch:torchvision_ops:0.10.0"

api 'com.facebook.soloader:soloader:0.10.3'
```

--------------------------------

### Start Camera Preview (Kotlin/Java)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/usage

This function initiates the camera preview. It requires an instance of ParavisionFaceSDK, an array of FaceDetectionOption, and a ProcessResultListener to handle the results of video stream detection.

```kotlin
 /**
  * Function start camera preview
  * @param instance ParavisionFaceSDK
  * @param detectionOptions Array<FaceDetectionOption>
  * @param videoStreamDetectionListener ProcessResultListener<ParavisionFaceResult>
  */
fun startPreview(
    instance:ParavisionFaceSDK,
    detectionOptions:Array<FaceDetectionOption>,
    videoStreamDetectionListener: ProcessResultListener<ParavisionFaceResult>
)
```

```java
 /**
  * Function start camera preview
  * @param instance ParavisionFaceSDK
  * @param detectionOptions Array<FaceDetectionOption>
  * @param videoStreamDetectionListener ProcessResultListener<ParavisionFaceResult>
  */
void startPreview(
    ParavisionFaceSDK instance,
    FaceDetectionOption[] detectionOptions,
    ProcessResultListener<ParavisionFaceResult> videoStreamDetectionListener
 )
```

--------------------------------

### Configure Gradle for Paravision Android SDK Installation

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.11.0/readme

This snippet configures the `build.gradle` file to correctly package the native libraries for the Paravision SDK. It ensures that shared object files are picked first and not stripped, which is crucial for native library integration.

```gradle
packagingOptions {
	jniLibs {
		pickFirsts += ['**/*.so']
		doNotStrip += ['**/*.so']
	}
}
```

--------------------------------

### Initialize Native Libraries in App's onCreate Method

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v2.7.0/installation

This code demonstrates how to initialize the NativeLoader and load the required native libraries for the Paravision Face Validness SDK within your Android application's onCreate method. It ensures that PyTorch, torchvision_ops, OpenCV, and the Paravision FV library are loaded before use. The initialization checks if NativeLoader is already initialized to avoid redundant calls.

```kotlin
override fun onCreate() {
    super.onCreate()

    if (!NativeLoader.isInitialized()) {
        NativeLoader.init(SystemDelegate())
    }
    NativeLoader.loadLibrary("pytorch_jni")
    NativeLoader.loadLibrary("torchvision_ops")
    NativeLoader.loadLibrary("opencv_java4")
    NativeLoader.loadLibrary("fv")
}
```

--------------------------------

### Add .aar Dependencies to Gradle (Android)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.6.0/installation

This snippet shows how to add the Paravision Face Detection SDK and its OpenCV dependency to your Android project's `build.gradle` file. Ensure the `.aar` files are placed in the `libs` folder and this configuration is applied at the project level.

```gradle
api "org.opencv:opencv@aar"
api "ai.paravision.sdk.fd:ParavisionFD@aar"
```

--------------------------------

### Instantiate BoundingBoxDetector

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/types/boundingboxdetector

Initializes the BoundingBoxDetector with a Context and an optional AccelerationConfig. This is the default constructor.

```kotlin
BoundingBoxDetector(context: Context, accelerationConfig: AccelerationConfig? = null)
```

--------------------------------

### Android SDK Dependencies in build.gradle

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v2.10.0/readme

Adds the Paravision Face Validness SDK core and FV modules, along with TensorFlow Lite dependencies, to your Android project's build.gradle file. These are required for the SDK to function.

```gradle
implementation "ai.paravision.sdk.corelibs:ParavisionCore@aar"
implementation "ai.paravision.sdk.fv:ParavisionFV@aar"

// additional packages
implementation 'org.tensorflow:tensorflow-lite:2.16.1'
implementation 'org.tensorflow:tensorflow-lite-gpu:2.16.1'
implementation 'org.tensorflow:tensorflow-lite-gpu-api:2.16.1'
implementation 'org.tensorflow:tensorflow-lite-support:0.4.4'
```

--------------------------------

### Initialize BoundingBoxDetector in Kotlin

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.10.0/types/boundingboxdetector

Demonstrates the initialization of the BoundingBoxDetector class, which requires an Android Context. This is the first step before performing any detection operations.

```kotlin
val detector = BoundingBoxDetector(context)
```

--------------------------------

### Calculate Similarity and Match Scores (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.11.2/usage

Provides examples of calculating similarity and match scores between two embeddings using the `embeddingEstimator`. It shows how to use `getSimilarity` and `getMatchScore` methods with different parameters, including `ScoringMode.STANDARD`.

```kotlin
embeddingEstimator.getSimilarity(embedding1, embedding2, ScoringMode.STANDARD)

embeddingEstimator.getMatchScore(embedding1, embedding2, ScoringMode.STANDARD)

embeddingEstimator.getMatchScore(similarity, ScoringMode.STANDARD)
```

--------------------------------

### Analyze Image from Camera (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v3.4.0/usage

Sets up image analysis using the device's camera. It configures preview, image analysis with backpressure strategy, and binds these use cases to the lifecycle. The analyzer processes the camera image, converts it to a bitmap, rotates it, and passes it for further processing. Dependencies include CameraX libraries.

```kotlin
ProcessCameraProvider.getInstance(this).let { provider ->
    provider.addListener({
        val cameraProvider: ProcessCameraProvider = provider.get() 
        val preview = Preview.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
            .build()
            .also {
                it.setSurfaceProvider(binding.cameraPreview.surfaceProvider)
            }
        val imageAnalysis = ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setTargetResolution(Size(3000, 4000))
            .build()
            .also {
                it.setAnalyzer(executor) { proxy ->
                    imageToBitmap(proxy.image!!)?.let { bitmap ->
                    	 val rotatedBitmap = rotateBitmap(bitmap, proxy.imageInfo.rotationDegrees)
                    	 processImage(Image(rotatedBitmap))
                    }
                    proxy.close()
                }
            }
        val useCaseGroup = UseCaseGroup.Builder()
            .addUseCase(preview)
            .addUseCase(imageAnalysis)
            .addUseCase(imageCapture)
            .build()

        try {
            cameraProvider.unbindAll()
            cameraProvider.bindToLifecycle(this, CameraSelector.DEFAULT_FRONT_CAMERA, useCaseGroup)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }, ContextCompat.getMainExecutor(this))
}
```

--------------------------------

### Proguard Configuration for Paravision SDK

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/installation

Specifies Proguard rules to prevent obfuscation or removal of classes related to the Paravision SDK, Facebook SDK, and PyTorch. This is crucial for ensuring the SDK functions correctly after code shrinking and optimization.

```proguard
-keep class ai.paravision.sdk.android.** {*;} 
-keep class com.facebook.** {*;} 
-keep class org.pytorch.** {*;}
```

--------------------------------

### LandmarkDetector Constructor

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.2/types/landmarkdetector

Initializes the LandmarkDetector with the provided context and optional acceleration configuration.

```APIDOC
## LandmarkDetector Constructor

### Description
Initializes the LandmarkDetector with the provided context and optional acceleration configuration.

### Method
CONSTRUCTOR

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "example": "LandmarkDetector(context)"
}
```

### Response
#### Success Response (200)
- **LandmarkDetector** (Object) - An instance of the LandmarkDetector.

#### Response Example
```json
{
  "example": "Instance of LandmarkDetector"
}
```
```

--------------------------------

### Android Native Library Initialization

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.10.0/readme

Loads the required native libraries for the Paravision SDK within the Android application's initialization code. This step is crucial for the Face Recognition SDK to function correctly, especially the OpenCV and Face Recognition specific libraries.

```kotlin
override fun onCreate() {
	super.onCreate()
	System.loadLibrary("opencv_java4")
	System.loadLibrary("fr")
}
```

--------------------------------

### Example Usage: Process Video Frame (Kotlin, Java)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.2.0/usage

Demonstrates how to call the asynchronous video frame processing function in both Kotlin and Java. This includes setting up display and detection options, and implementing the result listener to handle successful detections or errors.

```kotlin
sdkInstance.processFullVideoFrame(
    inputTrackingId = youTrackingId,
    proxy = yourImageProxyFromCameraX,
    paravisionGraphicOverlay = paravisionGraphicOverlay,
    displayOptions = arrayOf(SHOW_BOUNDING_BOX, SHOW_LANDMARKS),
    detectionOptions = arrayOf(BOUNDING_BOX, QUALITY, LANDMARK),
    findMostProminentFace = true,
    faceDetectionListener = object : ParavisionFaceSDK.ProcessResultListener<ParavisionFaceResult> {
        override fun onResult(result: ParavisionFaceResult) {
            // getting the detection result
            val trackingId = result.inputTrackingId
            val mostProminentFaceIdx =  result.mostProminentFaceIdx
            val faces = result.faces
            for (face:Face in faces){
                // ... Iterate each face in the result
            }
        }
        override fun onError(exception: ParavisionException) {
            // Handle exception
        }
    }
)
```

```java
DisplayOption[] displayOptions = {SHOW_BOUNDING_BOX, SHOW_LANDMARKS};
FaceDetectionOption[] detectionOptions = {BOUNDING_BOX, QUALITY, LANDMARK};
sdkInstance.processFullVideoFrame(
    yourTrackingId, 
    yourImageProxyFromCameraX, 
    paravisionGraphicOverlay, 
    displayOptions
    detectionOptions,
    true, //findMostProminentFace 
    new ParavisionFaceSDK.ProcessResultListener<ParavisionFaceResult> () {
        @override 
        void onResult(ParavisionFaceResult result) {
            // getting the detection result
            String trackingId = result.inputTrackingId
            Int mostProminentFaceIdx =  result.mostProminentFaceIdx
            List<Face> faces = result.faces
            for (Face face : faces){
                // ... Iterate each face in the result
            }
        }
        @override 
        void onError(ParavisionException exception) {
                // Handle exception
        }
    }
);
```

--------------------------------

### Android Gradle Dependencies for Paravision SDK

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.10.0/readme

Adds the Paravision Core and Face Recognition SDK .aar packages as project dependencies in Gradle. It also includes necessary TensorFlow Lite libraries for machine learning functionalities. Ensure the specified versions are compatible with your project.

```gradle
implementation "ai.paravision.sdk.corelibs:ParavisionCore@aar"
implementation "ai.paravision.sdk.fr:ParavisionFR@aar"

// additional packages
implementation 'org.tensorflow:tensorflow-lite:2.16.1'
implementation 'org.tensorflow:tensorflow-lite-gpu:2.16.1'
implementation 'org.tensorflow:tensorflow-lite-gpu-api:2.16.1'
implementation 'org.tensorflow:tensorflow-lite-support:0.4.4'
```

--------------------------------

### Initialize Paravision Face SDK Instance (Kotlin & Java)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-sdk-v2.3.0/usage

Demonstrates how to create an instance of the Paravision Face SDK. It's recommended to initialize the SDK in your Application class or a ViewModel to avoid issues with frequently called lifecycle functions.

```kotlin
faceSDKInstance = ParavisionFaceSDK.Builder(applicationContext)
            .build()
```

```java
faceSDKInstance = new ParavisionFaceSDK.Builder(applicationContext)
            .build();
```

--------------------------------

### BoundingBoxDetector Constructor

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/types/boundingboxdetector

Initializes a new instance of the BoundingBoxDetector class.

```APIDOC
## BoundingBoxDetector constructor

### Description
Default constructor for the BoundingBoxDetector.

### Method
CONSTRUCTOR

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **context** (Context) - Required - The Android context.
- **accelerationConfig** (AccelerationConfig?) - Optional - Configuration for acceleration.

### Request Example
```json
{
  "context": "Android Context object",
  "accelerationConfig": {
    "type": "SomeAccelerationType"
  }
}
```

### Response
#### Success Response (200)
Instance of BoundingBoxDetector.

#### Response Example
```json
{
  "message": "BoundingBoxDetector initialized successfully"
}
```
```

--------------------------------

### Initialize QualityEstimator with Context and AccelerationConfig

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/types/qualityestimator

Initializes the QualityEstimator with a Context and an optional AccelerationConfig. This is the default constructor for setting up the quality estimation service.

```kotlin
class QualityEstimator

constructor(context: Context, accelerationConfig: AccelerationConfig? = null)
```

--------------------------------

### Add Paravision and OpenCV SDK Dependencies to build.gradle

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v2.7.0/installation

This snippet shows how to declare the Paravision Face Validness SDK and OpenCV as API dependencies in your project's build.gradle file. It also includes necessary PyTorch and Facebook SoLoader dependencies for the SDK's functionality. Ensure these versions are compatible with your project.

```gradle
api "org.opencv:opencv@aar"
api "ai.paravision.sdk.fv:ParavisionFV@aar"

// additional packages
api "org.pytorch:pytorch_android_lite:1.10.0"
api "org.pytorch:pytorch_android_torchvision_lite:1.10.0"
api "org.pytorch:torchvision_ops:0.10.0"

api 'com.facebook.soloader:soloader:0.10.3'
```

--------------------------------

### Initialize QualityEstimator (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.10.0/types/qualityestimator

Initializes the QualityEstimator with the application context. This is the default constructor required before using other methods.

```kotlin
class QualityEstimator

QualityEstimator(context: Context)
```

--------------------------------

### Initialize LandmarkDetector (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.10.0/types/landmarkdetector

Initializes the LandmarkDetector with the provided Android Context. This is the entry point for using the landmark detection functionality.

```kotlin
val detector = LandmarkDetector(context)
```

--------------------------------

### LandmarkDetector Constructor

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.6.0/types/landmarkdetector

Initializes a new instance of the LandmarkDetector class.

```APIDOC
## LandmarkDetector Constructor

### Description
Default constructor for the LandmarkDetector.

### Method
CONSTRUCTOR

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{
  "constructor": "LandmarkDetector(context: Context)"
}
```

### Response
#### Success Response (200)
LandmarkDetector object initialized.

#### Response Example
```json
{
  "status": "success",
  "message": "LandmarkDetector initialized"
}
```
```

--------------------------------

### Get Match Score from Similarity (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v3.4.0/types/embeddingestimator

Calculates a match score based on a pre-computed similarity value. This can be useful when similarity is determined by other means.

```kotlin
val matchScore = estimator.getMatchScore(similarity, ScoringMode.ENHANCED)
```

--------------------------------

### Calculate Embedding Similarity (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.10.0/usage

Calculates the similarity score between two embeddings using the `embeddingEstimator`. The `ScoringMode.STANDARD` is used for the calculation.

```kotlin
embeddingEstimator.getSimilarity(embedding1, embedding2, ScoringMode.STANDARD)
```

--------------------------------

### Get Embedding Scoring Mode (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v3.5.0/types/embedding

Retrieves the `ScoringMode` associated with an `Embedding`. This mode indicates how the embedding should be used for scoring operations.

```kotlin
fun getType(): ScoringMode

```

--------------------------------

### Configure Gradle Packaging Options for Android

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v2.11.1/readme

This configuration snippet is added to the `build.gradle` file of an Android project to manage native libraries (.so files) when using .aar packages. It ensures that JNI libraries are correctly picked up and their symbols are not stripped, which is crucial for SDK functionality.

```gradle
packagingOptions {
  jniLibs {
    pickFirsts += ['**/*.so']
    doNotStrip += ['**/*.so']
  }
}
```

--------------------------------

### Calculate Embedding Match Score (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v2.10.0/usage

Calculates the match score between two embeddings using the `embeddingEstimator`. The `ScoringMode.STANDARD` is used for the calculation.

```kotlin
embeddingEstimator.getMatchScore(embedding1, embedding2, ScoringMode.STANDARD)
```

--------------------------------

### Analyze Image from Camera (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fv-sdk-v2.10.0/usage

This Kotlin code configures and binds camera use cases for image analysis. It sets up preview, image analysis with backpressure strategy, and image capture. The analysis involves converting the camera image proxy to a bitmap, rotating it, and processing it.

```kotlin
ProcessCameraProvider.getInstance(this).let { provider ->
    provider.addListener({
        val cameraProvider: ProcessCameraProvider = provider.get()
        val preview = Preview.Builder()
            .setTargetAspectRatio(AspectRatio.RATIO_4_3)
            .build()
            .also {
                it.setSurfaceProvider(binding.cameraPreview.surfaceProvider)
            }
        val imageAnalysis = ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .setTargetResolution(Size(3000, 4000))
            .build()
            .also {
                it.setAnalyzer(executor) { proxy ->
                    imageToBitmap(proxy.image!!)?.let {
                         val rotatedBitmap = rotateBitmap(bitmap, proxy.imageInfo.rotationDegrees)
                    	 processImage(Image(rotatedBitmap))
                    }
                    proxy.close()
                }
            }
        val useCaseGroup = UseCaseGroup.Builder()
            .addUseCase(preview)
            .addUseCase(imageAnalysis)
            .addUseCase(imageCapture)
            .build()

        try {
            cameraProvider.unbindAll()
            cameraProvider.bindToLifecycle(this, CameraSelector.DEFAULT_FRONT_CAMERA, useCaseGroup)
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }, ContextCompat.getMainExecutor(this))
}
```

--------------------------------

### Get Embedding Data as FloatArray (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v3.5.0/types/embedding

Returns the embedding vector as a `FloatArray`. This method provides direct access to the numerical representation of the embedding.

```kotlin
fun getData(): FloatArray

```

--------------------------------

### Get Match Score from Embeddings (Kotlin)

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fr-sdk-v3.4.0/types/embeddingestimator

Determines a match score between two facial embeddings. This method utilizes a specified scoring mode to evaluate the match.

```kotlin
val matchScore = estimator.getMatchScore(embedding1, embedding2, ScoringMode.ENHANCED)
```

--------------------------------

### Initialize LandmarkDetector in Kotlin

Source: https://docs.paravision.ai/paravision-android-sdks/VqJGwu4OqCYd5rNoRhkh/android-fd-sdk-v2.11.0/types/landmarkdetector

Initializes the LandmarkDetector with the provided Android Context and an optional AccelerationConfig. This is the entry point for using the landmark detection functionality.

```kotlin
LandmarkDetector(context: Context, accelerationConfig: AccelerationConfig? = null)
```