Ready in ~10 minutes (after AAR download): Drop facerecognitionsdk.aar into libfacesdk/ → Run on a phone Jump: Get the AAR · Run the demo · Setup (your own app) · About SDK · Demo kit

Explore FacePlugin Face Recognition SDK — enroll faces, identify in 1:N, capture with a live coach, and read attributes (liveness, quality, pose, age, gender, and more).

This is an on-premise FacePlugin SDK. All processing stays on the device — no biometric data is sent to FacePlugin cloud.

This repository is the Android demo app — a standalone customer repo. Runtime is libfacesdk/facerecognitionsdk.aar (download from Google Drive). No other FacePlugin repository is required.

You get:

1. A working demo (Enroll, Identify, Capture, Attribute, Settings, About).
2. app/.../kit/ — copy-paste Kotlin helpers (FaceRecognitionClient) so you can call every SDK function without rewriting threading, CameraX, or VideoWorker plumbing. See Demo kit.

You can run the sample app as-is. Enroll / Identify / Capture / Attribute unlock when the status bar disappears.

facerecognitionsdk.aar includes native libs for arm64-v8a and armeabi-v7a. The sample app filters to those two ABIs.

libfacesdk/facerecognitionsdk.aar is empty on GitHub because the binary is too large.

FaceRecognitionSDK-Android-App runtime (Google Drive)

1. Clone this repo (if you have not already):

git clone https://github.com/Faceplugin-ltd/FaceRecognition-Android.git
cd FaceRecognition-Android

2. Download facerecognitionsdk.aar from the Drive folder.
3. Put it here (not in a nested folder):

FaceRecognition-Android/
└── libfacesdk/
    ├── build.gradle
    └── facerecognitionsdk.aar

1. Open this folder in Android Studio.
2. Run on a device. The demo already has a valid LICENSE_KEY for com.faceplugin.facerecognitionsdk.

The warning bar on the home screen is the SDK status (Loading native SDK…). Enroll / Identify / Capture / Attribute stay disabled until it disappears.

Licenses are offline and bound to your app identifier.

The sample app already includes a valid key for com.faceplugin.facerecognitionsdk. You only need a new key if you use a different applicationId.

The code below shows how to use the license:

Please contact us to get the license.

You need libfacesdk/ (the AAR) and com.faceplugin.facerecognitionsdk.FaceRecognitionSDK. You do not need this demo’s Activities.

Optional: also copy app/src/main/java/com/faceplugin/facerecognitionsdk/kit/ — that is the fastest way to use every function. See Demo kit.

1. Copy the libfacesdk folder into your project root.
2. Put facerecognitionsdk.aar inside it (from Drive).
3. Wire Gradle:

settings.gradle:

include ':app'
include ':libfacesdk'

app/build.gradle:

android {
    defaultConfig {
        minSdk 24
        ndk {
            abiFilters 'arm64-v8a', 'armeabi-v7a'
        }
    }
    packaging {
        jniLibs {
            useLegacyPackaging = true
        }
    }
}
dependencies {
    implementation project(':libfacesdk')
    // only if you copy kit/ CameraPreview + CameraFrameUtils:
    def camerax = '1.4.2'
    implementation "androidx.camera:camera-core:$camerax"
    implementation "androidx.camera:camera-camera2:$camerax"
    implementation "androidx.camera:camera-lifecycle:$camerax"
    implementation "androidx.camera:camera-view:$camerax"
}

4. Add permissions in your AndroidManifest.xml:

<uses-feature android:name="android.hardware.camera" android:required="true" />
<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.READ_MEDIA_IMAGES" />
<uses-permission
    android:name="android.permission.READ_EXTERNAL_STORAGE"
    android:maxSdkVersion="32" />

The license is bound to your applicationId. Request a key for that id, not the demo’s.

Then follow About SDK. Call init and all process methods off the UI thread. First init unpacks the on-device models (a few seconds).

Public class: com.faceplugin.facerecognitionsdk.FaceRecognitionSDK (Java; call it from Kotlin the same way).

All work stays on the device. 0 = SDK_SUCCESS.

Do not copy MainActivity / CameraActivity unless you want the demo UI. The AAR is the product.

• Run init and every process call off the UI thread. First init unpacks models.
• The engine is not concurrent. Serialize calls (one thread, or copy Demo kit which already does this).
• Call init once per process. Calling it again tears the engine down and you wait for a full re-init.
• The SDK downscales bitmaps to long side 1280. For live frames, ~640 is enough and faster.
• Close ImageProxy as soon as you have copied pixels. Do not sync a native detect on the CameraX analysis thread.

import android.graphics.Bitmap
import com.faceplugin.facerecognitionsdk.FaceBox
import com.faceplugin.facerecognitionsdk.FaceDetectionParam
import com.faceplugin.facerecognitionsdk.FaceRecognitionSDK

Thread {
    FaceRecognitionSDK.getMachineCode(context) // optional
    var ret = FaceRecognitionSDK.setActivation(context, "FP1.…")
    if (ret == FaceRecognitionSDK.SDK_SUCCESS) {
        ret = FaceRecognitionSDK.init(context)
    }
    // ret == 0 → enable camera / gallery
}.start()

Or copy the kit and call FaceRecognitionClient.get(context).activate(key) { code -> … } (already off the UI thread, skips a second init).

Default FaceDetectionParam() = box + pose + 14 landmarks.

val faces: List<FaceBox> = FaceRecognitionSDK.faceDetection(bitmap, FaceDetectionParam())
if (faces.size != 1) return // 0 = none, 2+ = ask for a single-face photo
val face = faces[0]

Everything on one still (liveness, quality, age, gender, emotion, mask, eyes, glasses):

val param = FaceDetectionParam.allAttributes()
param.check_liveness_level = 0 // 0 = High Accuracy, 1 = Light
val faces = FaceRecognitionSDK.faceDetection(bitmap, param)

Turn individual checks on FaceDetectionParam:

Or JSON: FaceRecognitionSDK.detect(bitmap, false, FaceRecognitionSDK.DETECT_ALL).

After faceDetection, there is no second call — read the box.

if (face.liveness < 0.7f) {
    // spoof — do not identify / enroll
}

FaceRecognitionSDK.setLandmarkMode(FaceRecognitionSDK.LANDMARK_MODE_14) // or _68 / _468
val faces = FaceRecognitionSDK.faceDetection(bitmap, FaceDetectionParam())
val n = faces[0].landmarkCount
// xy at landmarks_68[i * 2], landmarks_68[i * 2 + 1]

The SDK does not store people. You keep templates (file, Room, backend). The kit’s FaceDatabase is a local JSON file if you want that.

val face = FaceRecognitionSDK.faceDetection(bitmap, FaceDetectionParam()).first()
val template: ByteArray? = FaceRecognitionSDK.templateExtraction(bitmap, face)
val thumbnail: Bitmap? = FaceRecognitionSDK.cropFace(bitmap, face)
// save personId + template (+ thumbnail)

val a = FaceRecognitionSDK.templateExtraction(bitmapA, faceA)
val b = FaceRecognitionSDK.templateExtraction(bitmapB, faceB)
val score = FaceRecognitionSDK.similarityCalculation(a, b)
val samePerson = score >= 0.8f // demo identify threshold

Two-image JSON helper: FaceRecognitionSDK.match(bitmapA, bitmapB, false).

val probe = FaceRecognitionSDK.templateExtraction(bitmap, face) ?: return
var bestName: String? = null
var best = 0.8f
for ((name, enrolled) in yourEnrolledTemplates) {
    val score = FaceRecognitionSDK.similarityCalculation(probe, enrolled)
    if (score > best) {
        best = score
        bestName = name
    }
}

// 7 = front (270°), 6 = back (90°)
val bitmap = FaceRecognitionSDK.yuv2Bitmap(nv21, width, height, if (backCamera) 6 else 7)

Then the same faceDetection / templateExtraction / addVideoWorkerFrame as stills. Kit: CameraFrameUtils.fromImageProxy(imageProxy, backCamera) (NV21 + rotate + long side ≤ 640). Close imageProxy in finally before native work.

This is live boxes + 1:N. Feed upright bitmaps (already rotated).

FaceRecognitionSDK.setVideoWorkerEventHandler { json ->
    // "event": "tracking" → faces[], match.matched / person_index / score
    // "event": "match"    → matched, person_index, score
}

val config = FaceRecognitionSDK.VideoWorkerConfig.withMatchThreshold(0.8f)
config.activeLiveness.enabled = false // tracking only; see §11 for challenges
val started = FaceRecognitionSDK.startVideoWorker(config)           // 0 = OK
val synced = FaceRecognitionSDK.syncVideoWorkerDatabase(templates, 0.8f)

// each preview frame (do not block CameraX — copy bitmap, queue native add):
FaceRecognitionSDK.addVideoWorkerFrame(frame)

// onPause / onDestroy:
FaceRecognitionSDK.setVideoWorkerEventHandler(null)
FaceRecognitionSDK.stopVideoWorker()

person_index is the index in the list you passed to syncVideoWorkerDatabase (if a lookup misses, try index - 1).

2D liveness on live Identify is a still detect next to VideoWorker (that is what the demo does):

val live = FaceDetectionParam()
live.check_liveness = true
live.check_liveness_level = 0
live.check_pose = false
live.check_landmarks = false
val boxes = FaceRecognitionSDK.faceDetection(frameCopy, live)

Kit: LiveDetect.livenessOnly(level) and LiveDetect.mergeLiveness(trackBoxes, pbBoxes).

Same VideoWorker for boxes + pose. Eyes: DETECT_EYES still detect (LiveDetect.eyesOnly() in the kit). After a still capture, run allAttributes() off the UI thread for the result panel.

Set on VideoWorkerConfig before startVideoWorker:

val config = FaceRecognitionSDK.VideoWorkerConfig.withMatchThreshold(0.8f)
val al = FaceRecognitionSDK.ActiveLivenessConfig.defaults()
al.enabled = true
al.checks = intArrayOf(
    FaceRecognitionSDK.AL_CHECK_SMILE,
    FaceRecognitionSDK.AL_CHECK_BLINK,
    FaceRecognitionSDK.AL_CHECK_TURN_LEFT,
)
config.activeLiveness = al

Tracking events include activeLiveness (verdict, checkType, progress). Kit: client.makeIdentityConfig(...) / IdentityLiveness.instruction(...).

val qualityJson = FaceRecognitionSDK.quality(bitmap, false)
val featureJson = FaceRecognitionSDK.extractFeature(crop) // crop first
val statusJson = FaceRecognitionSDK.estimatorStatusJSON()

templateExtraction already crops + parses the feature to byte[].

FaceRecognitionSDK.stopVideoWorker()
FaceRecognitionSDK.deinit()

app/src/main/java/com/faceplugin/facerecognitionsdk/kit/ is not inside the AAR. Copy that folder (Kotlin) if you want the demo’s wiring instead of calling FaceRecognitionSDK yourself.

Use FaceRecognitionClient.get(context) as the only entry. Do not mix raw FaceRecognitionSDK.* on other threads while the client is running.

val client = FaceRecognitionClient.get(this)
client.activate("FP1.…") { code ->
    runOnUiThread {
        if (code == FaceRecognitionSDK.SDK_SUCCESS) {
            client.loadDatabase()
            // enable Enroll / Identify / Capture / Attribute
        }
    }
}

client.async {
    val prepared = CameraFrameUtils.enginePreparedImage(bitmap)
    val faces = client.faceDetection(prepared, FaceDetectionParam.allAttributes())
    val face = faces.first()
    val template = client.templateExtraction(prepared, face) ?: return@async
    val thumb = FaceRecognitionSDK.cropFace(prepared, face)
    client.enroll("Person12345", template, thumb)

    val hit = client.bestMatch(template, 0.8f) // or enroll then identify another photo
}

Gallery enroll in the demo requires exactly one face.

client.setVideoWorkerEventHandler { json ->
    val event = FaceJson.parseVideoWorkerEvent(json)
    // Tracking → boxes; Match → personIndex + score
}
client.async {
    val config = client.makeTrackingConfig(0.8f) // or makeIdentityConfig(...) for challenges
    client.startVideoWorker(config)
    client.syncDatabase(0.8f)
}

// CameraX analyzer (close ImageProxy first):
val frame = CameraFrameUtils.fromImageProxy(imageProxy, backCamera)
client.addFrame(frame) // non-blocking copy + native add

// live 2D liveness (Identify) or eyes (Capture), also on the SDK thread:
client.async {
    client.faceDetection(copy, LiveDetect.livenessOnly(0))
}

// onPause:
client.stopVideoWorker()

Bind camera: CameraPreview.bind(this, cameraProvider, previewView, lensFacing, executor, analyzer).

personAtVideoWorkerIndex(index) maps a VideoWorker hit to FaceDatabase.

AAR-only is enough if you already have a camera pipeline and a person DB. Then call FaceRecognitionSDK on one background thread and follow the tables above.

• Face Recognition with Liveness Detection-Android (Java, Kotlin)
• Face Recognition with Liveness Detection-iOS (Objective C, Swift)
• Face Recognition with Liveness Detection-Windows
• Face Recognition with Liveness Detection-React Native
• Face Recognition with Liveness Detection-Flutter
• Face Recognition with Liveness Detection-Ionic Cordova
• Face Recognition with Liveness Detection-.Net MAUI
• Face Recognition with Liveness Detection-.Net WPF
• Face Recognition with Liveness Detection-Javascript
• Face Recognition with LivenessDetection-React
• Face Recognition with LivenessDetection-Vue
• Face Liveness Detection-Android (Java, Kotlin)
• Face Liveness Detection-iOS (Objective C, Swift)
• Face Liveness Detection-Windows
• Face Liveness Detection-Linux
• Face Liveness Detection-Docker
• Open Source Face Recognition SDK
• Face Recognition SDK
• Liveness Detection SDK
• Palm Recognition SDK
• ID Document Recognition-Android (Java, Kotlin)
• ID Document Recognition-Windows
• ID Document Recognition
• ID Document Liveness Detection