Initial setup

This section provides step-by-step instructions for setting up and integrating LUNA ID POS into Android applications.

Step 1: Download LUNA ID POS

LUNA ID POS is distributed as a collection of modular archive files containing essential libraries and neural networks for mobile application integration.

1. Obtain the distribution kit from VisionLabs.
2. Move the archives to the desired directory.

Step 2: Configure repository

Add the following repository configuration to the settings.gradle.kts file:

Info

The settings.gradle.kts file is located in the root directory of your project and defines which projects and libraries you need to add to the classpath of your build script.

dependencyResolutionManagement {
    repositories {
        google()
        mavenCentral()

        // VisionLabs repository configuration
        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() }
        }
    }
}

Step 3: Provide user credentials

In the local.properties file, specify your credentials:

vl.login=YOUR_LOGIN
vl.pass=YOUR_PASSWORD

Implement the following utility function to access credentials programmatically:

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

    if (localProperties.isFile) {
        InputStreamReader(FileInputStream(localProperties), Charsets.UTF_8).use { reader ->
            properties.load(reader)
        }
    } else {
        error("File not found: '$file'")
    }

    if (!properties.containsKey(key)) {
        error("Key '$key' not found in file '$file'")
    }

    return properties.getProperty(key)
}

Warning

Add local.properties to your .gitignore file to prevent credential exposure through version control systems.

Step 4: Specify dependencies

Add the necessary .aar files as dependencies in your module's build.gradle.kts. This file defines various build parameters including dependencies, plugins, library versions, compilation options, and testing configurations.

Add the following dependencies to your build.gradle.kts:

dependencies {
    // CameraX dependencies (required for camera functionality)
    implementation(libs.camera.core)
    implementation(libs.camera.camera2)
    implementation(libs.camera.lifecycle)
    implementation(libs.camera.video)
    implementation(libs.camera.view)

    // VL-LUNA-ID-POS core modules
    implementation("ai.visionlabs.lunaid:core:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:common-arm:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:cnn60-arm:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:mask-arm:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:glasses-arm:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:oslm-arm:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:security:${DepVersions.sdkVersion}@aar")
    implementation("ai.visionlabs.lunaid:facePayCore:${DepVersions.sdkVersion}@aar")

}

Step 5: Initialize LUNA ID POS

Initialize the SDK once during application startup:

@HiltViewModel
class MainViewModel @Inject constructor(
    val application: Application,
    val dataStore: AppDataStore,
    private val userDao: UserDao
) : ViewModel() {

    init {
        // Initialize the SDK engine
        initEngine()

        // Optional: Monitor initialization status
        monitorEngineStatus()
    }

    private fun initEngine() = CoroutineScope(Dispatchers.Default).launch {
        // Configure recognition parameters
        val config = LunaConfig(livenessType = LivenessType.Offline)

        // Configure server connection for data processing
        val apiHumanConfig = ApiHumanConfig(
            baseUrl = "https://luna-api-aws.visionlabs.ru/6/",
            headers = mapOf(
                "Authorization" to "Bearer <YOUR_JWT_TOKEN>"
            )
        )

        // Load license file from application's internal storage
        val customLicense = File(application.filesDir, "license.conf")

        // Initialize VL-LUNA-ID-POS
        FacePay.initEngine(application, config, apiHumanConfig, customLicense)
    }

    private fun monitorEngineStatus() {
        LunaID.engineInitStatus
            .onEach { status -> Log.d("FacePay", "engineInitStatus=$status") }
            .launchIn(CoroutineScope(Dispatchers.IO))
    }
}

Component	Type	Description
MainViewModel	Class	Primary ViewModel hosting initialization logic.
init {…}	Initialization block	Executes when the MainViewModel instance is created. Calls initEngine() and sets up initialization status monitoring.
initEngine()	Function	Contains core LUNA ID POS initialization logic.
LunaID.engineInitStatus	Flow	Provides subscription to LUNA ID POS initialization state changes for process monitoring.
Log.d("FacePay", …)	Logging	Outputs current initialization status to system log for debugging.
LunaConfig	Class	Defines LUNA ID POS operational parameter configuration.
livenessType	Parameter	Sets OneShotLiveness estimation mode. LivenessType.Offline indicates local device processing without server communication.
ApiHumanConfig	Class	Configures interaction with LUNA PLATFORM 5 API.
baseUrl	Variable	Specifies LUNA PLATFORM 5 URL for request submission (for example, verification requests).
headers	Map	Defines headers appended to each request sent to LUNA PLATFORM 5.
customLicense	Variable	File object pointing to license file (license.conf) in application's private storage.
FacePay.initEngine(…)	Method	Primary LUNA ID POS initialization method. Accepts application context, configuration objects, and starts the recognition engine.

Step 6: Launch the camera

Initiate face capture by calling the FacePay.showCamera method:

@OptIn(ExperimentalCamera2Interop::class)
fun openCamera(context: Context) {
    val settings = dataStore.settings().first()

    val showCameraParams = settings.showCameraParams.copy(
        borderDistanceStrategy = BorderDistancesStrategy.WithCustomView(R.id.faceCaptureOverlay),
        checkSecurity = true // Virtual camera detection
    )

    FacePay.showCamera(
        context = context,
        params = showCameraParams,
        interactions = Interactions.Builder().build(),
        commands = Commands.Builder().build()
    )
}

Step 7: Get the best shot

Subscribe to the bestShot flow to capture best shots:

LunaID.bestShot
    .filterNotNull()
    .onEach { bestShot ->
        // Extract processed (warped) face image
        val faceBitmap = bestShot.bestShot.warp

        // Example: Send image to external system (Rosreestr in this case)
        sendToExternalSystem(faceBitmap)
    }
    .launchIn(viewModelScope)