Integration guide for LUNA ID for Android

This guide provides a step-by-step overview of integrating LUNA ID into an Android application.

Prerequisites

Before you begin, make sure you have:

• Android Studio
• Android project with minimum SDK version 21 or higher
• Valid credentials for https://download.visionlabs.ru/

Step 1: Configure repository

Add the repository to your settings.gradle.kts:

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()

        ivy {
            url = java.net.URI.create("https://download.visionlabs.ru/")
            patternLayout {
                artifact("releases/lunaid-[artifact]-[revision].[ext]")
                setM2compatible(false)
            }
            credentials {
                username = getLocalProperty("vl.login") as String
                password = getLocalProperty("vl.pass") as String
            }
            metadataSources { artifact() }
        }
    }
}

fun getLocalProperty(key: String, file: String = "local.properties"): Any {
    val file = File(rootProject.projectDir, file)
    val properties = java.util.Properties()

    if (file.isFile) {
        InputStreamReader(FileInputStream(file), Charsets.UTF_8).use { 
            properties.load(it) 
        }
    } else if (System.getenv("CI") != null) {
        return "nothing"
    } else {
        error("File not found: '$file'")
    }

    return properties.getProperty(key) ?: error("Key '$key' not found")
}

Step 2: Set up credentials

Create or edit local.properties in your project root:

vl.login=YOUR_LOGIN
vl.pass=YOUR_PASSWORD

Important: Add local.properties to your .gitignore file to keep credentials secure.

Step 3: Add dependencies

In your app-level build.gradle.kts, add the required LUNA ID and CameraX dependencies:

dependencies {
    // LUNA ID (replace {VERSION} with actual version, e.g., 1.20.0)
    implementation("ai.visionlabs.lunaid:core:{VERSION}@aar")
    implementation("ai.visionlabs.lunaid:common-arm:{VERSION}@aar")
    implementation("ai.visionlabs.lunaid:cnn60-arm:{VERSION}@aar")

    // CameraX (required)
    implementation("androidx.camera:camera-core:1.3.0")
    implementation("androidx.camera:camera-camera2:1.3.0")
    implementation("androidx.camera:camera-lifecycle:1.3.0")
    implementation("androidx.camera:camera-video:1.3.0")
    implementation("androidx.camera:camera-view:1.3.0")
}

Step 4: Add permissions

Add the following permissions to your AndroidManifest.xml:

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

Step 5: Initialize LUNA ID

Initialize the SDK in your Application class:

import android.app.Application
import ru.visionlabs.sdk.lunacore.LunaConfig
import ru.visionlabs.sdk.lunacore.LunaID

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()

        // Initialize with default configuration
        LunaID.initEngine(
            context = applicationContext,
            lunaConfig = LunaConfig.create()
        )
    }
}

Make sure your AndroidManifest.xml references this class:

<application
    android:name=".MyApp"
    ... >

Step 6: Launch the camera

Before launching the camera, request permission in your Activity:

import android.Manifest
import android.content.pm.PackageManager
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {
    private val requestPermission = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (granted) {
            launchLunaCamera()
        }
    }

    private fun checkAndRequestCameraPermission() {
        if (ContextCompat.checkSelfPermission(
                this, 
                Manifest.permission.CAMERA
            ) == PackageManager.PERMISSION_GRANTED
        ) {
            launchLunaCamera()
        } else {
            requestPermission.launch(Manifest.permission.CAMERA)
        }
    }

    private fun launchLunaCamera() {
        // Implementation in Step 7
    }
}

In your Activity, launch the camera and handle results:

import androidx.lifecycle.lifecycleScope
import kotlinx.coroutines.flow.filter
import kotlinx.coroutines.flow.filterNotNull
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.launch
import ru.visionlabs.sdk.lunacore.LunaID

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Wait for SDK initialization
        lifecycleScope.launch {
            LunaID.engineInitStatus
                .filter { it is LunaID.EngineInitStatus.Success }
                .first()

            // Request camera permission before launching
            checkAndRequestCameraPermission()
        }

        // Handle captured best shots
        lifecycleScope.launch {
            LunaID.bestShotResult
                .filterNotNull()
                .collect { event ->
                    val bestShot = event.bestShot
                    // Process the captured face image
                    // e.g., display, save, or send to server
                }
        }
    }

    private fun launchLunaCamera() {
        LunaID.showCamera(this@MainActivity)
    }
}

LUNA ID is now integrated and ready to use. When you run your app, the camera will automatically open and start detecting faces.