Camera inference on Android

This tutorial runs an Edge Impulse computer vision model on a live Android camera feed. CameraX captures each frame, the app converts it to the format your model expects, and JNI passes it to the Edge Impulse C++ classifier. The app draws the results over the camera preview. The same code handles image classification, object detection, and visual anomaly detection. To switch between them, deploy a different model.

Android app preview with bounding boxes around detected objects in a live camera feed — Object detection running on Android

If you’re new to the Android examples, start with Static buffer inference. It covers the JNI bridge and inference loop without a camera pipeline.

Prerequisites

A trained vision model in Edge Impulse: image classification, object detection, or visual anomaly detection
Android Studio with NDK 27.0.12077973 and CMake 3.22.1 installed
An Android device with a camera running API 24 or later

1. Clone the repository

git clone https://github.com/edgeimpulse/example-android-inferencing.git
cd example-android-inferencing/example_camera_inference

2. Download TensorFlow Lite libraries

cd app/src/main/cpp/tensorflow-lite

# macOS/Linux
sh download_tflite_libs.sh

# Windows
download_tflite_libs.bat

3. Export your model

In Edge Impulse Studio, go to Deployment.
Select Android (C++ library).
Enable EON Compiler to reduce memory use and inference time.
Click Build and download the .zip file.

4. Integrate the model

Extract the downloaded .zip file and copy its contents, except CMakeLists.txt, into app/src/main/cpp/. The folder then looks like this:

app/src/main/cpp/
├── edge-impulse-sdk/
├── model-parameters/
├── tflite-model/
├── tensorflow-lite/
├── native-lib.cpp
└── CMakeLists.txt   # keep the existing file

5. Build and run

Open the project in Android Studio.
Select Build -> Make Project.
Connect your Android device.
Run the app and grant the camera permission when prompted.

Point the camera at an object. The inference results appear over the preview.

How it works

CameraX sends frames to an ImageAnalysis use case, which converts them to RGB and passes them to the C++ classifier. A custom overlay view draws the results.

Camera setup

CameraX binds a preview stream and a frame analysis pipeline to the activity lifecycle. The STRATEGY_KEEP_ONLY_LATEST backpressure strategy drops frames that arrive while the classifier is busy, so the preview stays smooth:

// MainActivity.kt
private fun startCamera() {
    val cameraProviderFuture = ProcessCameraProvider.getInstance(this)

    cameraProviderFuture.addListener({
        val cameraProvider = cameraProviderFuture.get()

        val preview = Preview.Builder().build()
        val imageAnalysis = ImageAnalysis.Builder()
            .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
            .build()

        imageAnalysis.setAnalyzer(cameraExecutor) { imageProxy ->
            processImage(imageProxy)
        }

        cameraProvider.bindToLifecycle(this, cameraSelector, preview, imageAnalysis)
    }, ContextCompat.getMainExecutor(this))
}

Image processing

The app converts each frame to an RGB byte array and runs inference on a background coroutine. It closes the ImageProxy straight after reading it to free the camera buffer:

private fun processImage(imageProxy: ImageProxy) {
    val bitmap = imageProxy.toBitmap()
    val rgbBytes = bitmapToRGB(bitmap)

    lifecycleScope.launch(Dispatchers.Default) {
        val result = runInference(rgbBytes)
        displayResults(result)
    }

    imageProxy.close()
}

Native inference

The image crosses the JNI boundary as a byte array, and the native code passes it to the classifier as a signal:

// native-lib.cpp
extern "C" JNIEXPORT jobject JNICALL
Java_com_example_test_camera_MainActivity_runInference(
    JNIEnv* env, jobject, jbyteArray imageData) {

    signal_t signal;
    signal.total_length = EI_CLASSIFIER_INPUT_WIDTH * EI_CLASSIFIER_INPUT_HEIGHT;
    signal.get_data = &ei_camera_get_data;

    ei_impulse_result_t result = {0};
    run_classifier(&signal, &result, false);

    return createResultObject(env, result);
}

Bounding box overlay

For object detection, a custom View subclass draws bounding boxes and labels directly over the camera preview:

class BoundingBoxOverlay : View {
    var boundingBoxes: List<BoundingBox> = emptyList()

    override fun onDraw(canvas: Canvas) {
        boundingBoxes.forEach { box ->
            val rect = Rect(box.x, box.y, box.x + box.width, box.y + box.height)
            canvas.drawRect(rect, paint)
            canvas.drawText("${box.label} ${box.confidence}", box.x.toFloat(), (box.y - 10).toFloat(), textPaint)
        }
    }
}

Customization

Adjust the confidence threshold

companion object {
    const val CONFIDENCE_THRESHOLD = 0.6f
}

private fun filterDetections(detections: List<BoundingBox>): List<BoundingBox> {
    return detections.filter { it.confidence >= CONFIDENCE_THRESHOLD }
}

Limit inference frequency

If the classifier is slower than the camera frame rate, run inference at a fixed interval:

private var lastInferenceTime = 0L
private val inferenceInterval = 200L  // ms

private fun processImage(imageProxy: ImageProxy) {
    val now = System.currentTimeMillis()
    if (now - lastInferenceTime >= inferenceInterval) {
        runInference(imageProxy)
        lastInferenceTime = now
    }
    imageProxy.close()
}

Bounding box alignment

If bounding boxes are offset from the objects they mark, scale them from the model’s input size to the view size:

private fun scaleBoundingBox(
    box: BoundingBox,
    modelWidth: Int, modelHeight: Int,
    viewWidth: Int, viewHeight: Int
): BoundingBox {
    val scaleX = viewWidth.toFloat() / modelWidth
    val scaleY = viewHeight.toFloat() / modelHeight
    return box.copy(
        x = (box.x * scaleX).toInt(),
        y = (box.y * scaleY).toInt(),
        width = (box.width * scaleX).toInt(),
        height = (box.height * scaleY).toInt()
    )
}

Troubleshooting

Low frame rate or laggy preview

Run inference every 200 to 300 ms instead of on every frame.
Lower the camera resolution with setTargetResolution().
Check that XNNPACK is enabled in CMakeLists.txt.
Try a smaller model architecture.

Objects not detected reliably

If confidence is consistently low, lower the threshold slightly.
Check that the lighting matches your training data.
Check that the camera resolution is close to the model’s input resolution. A large mismatch reduces accuracy.

App crashes on startup

Check that the TFLite libraries are in app/src/main/cpp/tensorflow-lite/.
Check that edge-impulse-sdk/, model-parameters/, and tflite-model/ are all in app/src/main/cpp/.
Check that your NDK and CMake versions match the prerequisites.

OVERVIEW

END-TO-END

TOPICS

TOOLS

INTEGRATIONS

Prerequisites

1. Clone the repository

2. Download TensorFlow Lite libraries

3. Export your model

4. Integrate the model

5. Build and run

How it works

Camera setup

Image processing

Native inference

Bounding box overlay

Customization

Adjust the confidence threshold

Limit inference frequency

Bounding box alignment

Troubleshooting

Next steps

Resources

​Prerequisites

​1. Clone the repository

​2. Download TensorFlow Lite libraries

​3. Export your model

​4. Integrate the model

​5. Build and run

​How it works

​Camera setup

​Image processing

​Native inference

​Bounding box overlay

​Customization

​Adjust the confidence threshold

​Limit inference frequency

​Bounding box alignment

​Troubleshooting

​Next steps

​Resources

Prerequisites

1. Clone the repository

2. Download TensorFlow Lite libraries

3. Export your model

4. Integrate the model

5. Build and run

How it works

Camera setup

Image processing

Native inference

Bounding box overlay

Customization

Adjust the confidence threshold

Limit inference frequency

Bounding box alignment

Troubleshooting

Next steps

Resources