Cómo usar el escáner MLKit en Android paso a paso y sin errores

¿Te has planteado alguna vez cómo llevar el reconocimiento de códigos de barras o la detección de objetos a tu app Android sin perder la vida integrando librerías extrañas o arriesgándote con APIs de terceros? Pues hoy estás de suerte, porque vamos a destripar a fondo cómo usar el escáner de MLKit en Android, aprovechando la tecnología de Google para el aprendizaje automático directamente desde tu móvil o tableta. Lo mejor de todo es que no necesitas ser un crack en inteligencia artificial ni tener experiencia previa con modelos de ML, ya que MLKit se encarga de la trastienda y tú solo tienes que seguir unos pasos (y algunos consejos de los que casi nadie habla, que verás aquí).

En este artículo vamos a repasar a fondo absolutamente todo lo que debes saber sobre la integración y uso práctico del escáner de MLKit en Android: desde los requisitos mínimos, las diferencias entre los tipos de integración, cómo preparar las imágenes para obtener escaneos precisos, los detalles de configuración, ejemplos de código, optimización para apps en tiempo real y trucos para gestionar casos complejos. Recoge tu café y acomódate, que el viaje va a ser largo pero merece la pena: aquí tienes una guía actualizada, directa y sin rodeos.

¿Qué es MLKit y por qué merece la pena usarlo para escanear en Android?

Primero lo primero. MLKit es el Kit de Aprendizaje Automático desarrollado por Google para armarnos herramientas de visión artificial, procesamiento de lenguaje, detección de objetos y mucho más, directamente en nuestras aplicaciones móviles, tanto para Android como para iOS. En nuestro caso, nos centraremos en Android y, más concretamente, en la funcionalidad de escaneo de códigos de barras y detección de objetos.

Integrar el escáner de MLKit tiene ventajas realmente jugosas: no dependes de servicios externos ni necesitas conexión a Internet, porque el machine learning corre en el propio dispositivo; puedes procesar imágenes en tiempo real y obtener reconocimiento instantáneo de códigos o incluso de objetos; y además dispones de un SDK que se actualiza con frecuencia y está respaldado por Google.

¿Y qué se puede detectar? La lista es bastante completa: distintos formatos de códigos de barras, QR, PDF417, Aztec, Data Matrix, e incluso objetos y rostros (aunque estos dos últimos, para quien quiera rizar el rizo). Además, MLKit ofrece APIs tanto para detección como para seguimiento, ideal si tu app trabaja con streams de vídeo o usa la cámara de forma intensiva.

que es un OCR y cómo usarlo para escanear documentos

Primeros pasos: requisitos básicos y dependencias necesarias

Antes de ponerse manos a la obra, es fundamental tener claro qué necesitas para empezar sin tropezar en lo básico. MLKit exige como mínimo Android API 21 (Android 5.0) o superior. Eso implica que, en tu archivo build.gradle de nivel del módulo deberás asegurarte de tener minSdkVersion 21 o más.

Además, dependiendo del tipo de integración que elijas (luego hablaremos de esto), necesitarás añadir ciertas dependencias. MLKit se puede integrar de dos formas:

Biblioteca empaquetada (bundled): El modelo de machine learning va incluido dentro de tu app, lo que añade unos 2,4 MB extras al APK pero garantiza que el escaneo estará disponible instantáneamente, sin esperas ni descargas cuando se ejecuta la app.
Biblioteca sin empaquetar (unbundled): El modelo se descarga en tiempo real a través de Google Play Services, lo que apenas suma 200 KB al tamaño del APK, pero puede suponer que la primera vez que use el usuario el escáner tenga que esperar a que el modelo se descargue.

¿Qué dependencias tienes que añadir?

En el build.gradle del módulo (por ejemplo, app/build.gradle):

Para la versión empaquetada: implementation 'com.google.mlkit:barcode-scanning:17.3.0'
Para la versión sin empaquetar: implementation 'com.google.android.gms:play-services-mlkit-barcode-scanning:18.3.1'

En ambos casos, recuerda incluir el repositorio Maven de Google en la sección de buildscript y allprojects de tu build.gradle de proyecto.

Configurando el escáner: formatos, auto-zoom y optimización

El siguiente paso es decidir qué tipos de códigos de barras u objetos vas a escanear y configurar el escáner para que sea lo más eficiente posible. MLKit te permite especificar exactamente qué formatos debe buscar, lo que puede incrementar la velocidad del detector considerablemente. Por ejemplo, si solo te interesa escanear códigos QR y Aztec, lo puedes limitar explícitamente.

Esto se logra creando un objeto BarcodeScannerOptions e indicando los formatos deseados. La lista completa de soportados incluye, entre otros: Code 128, Code 39, Code 93, Codabar, EAN-13, EAN-8, ITF, UPC-A, UPC-E, QR, PDF417, Aztec y Data Matrix.

La clave para un rendimiento de diez no solo está en limitar los formatos, sino también en aprovechar las capacidades de la API como:

enableAllPotentialBarcodes(): Muestra todos los códigos detectados, incluso los que no se han podido decodificar, lo que ayuda a obtener mejores resultados si el usuario acerca la cámara.
Auto-zoom: A partir de ciertas versiones del modelo/biblioteca, MLKit puede sugerir aplicar zoom automáticamente cuando detecta que los códigos están demasiado lejos para ser leídos. Así, mejora la precisión de escaneo y se reduce el número de intentos fallidos.

Esta función de auto-zoom requiere gestionar el callback ZoomCallback, que deberías implementar para ajustar el ratio de zoom de la cámara según lo que sugiere la librería. Así, podrás adaptarte al hardware de cada dispositivo y potenciar la legibilidad de los códigos en cada toma.

Procesando la imagen de entrada: fuentes soportadas y consideraciones clave

Para que el detector haga magia, necesitas transformar la imagen a un formato que MLKit entienda. Aquí es donde entra InputImage, la clase universal compatible con la API. Puedes crearla a partir de distintas fuentes, según cómo estés obteniendo la imagen:

media.Image: Por ejemplo, capturada directamente desde la cámara.
Bitmap: Si manejas imágenes en ese formato dentro de la app.
ByteBuffer o ByteArray: Si trabajas con streams o buffers en crudo.
URI de archivo: Si el usuario elige una imagen directa desde la galería.

Truco relevante: Si usas CameraX, las clases OnImageCapturedListener y ImageAnalysis.Analyzer ya calculan automáticamente la rotación de la imagen; solo tienes que pasársela a InputImage.fromMediaImage(). Si no, deberás calcular la rotación manualmente según la orientación del sensor y el estado del dispositivo (para que no te salga la imagen invertida).

Una vez tienes el InputImage preparado, solo queda enviarlo al escáner a través del método process(image) y gestionar el resultado a través de listeners de éxito o error.

Requisitos y consejos para imágenes de entrada precisas

Para que el escaneo sea un éxito y no un mar de frustraciones, hay algunos detalles sobre las imágenes que debes tener en cuenta:

Resolución suficiente: MLKit requiere que cada unidad mínima del código de barras tenga al menos 2 píxeles de ancho (y altura en códigos bidimensionales). Por ejemplo, un EAN-13 debería ocupar como mínimo 190 píxeles de ancho, y un PDF417 puede necesitar más de 1000 píxeles.
Enfoque: Una imagen borrosa arruina cualquier intento de escaneo. Si el resultado es mediocre, pide al usuario que repita la captura.
Resolución óptima: Para la mayoría de aplicaciones, es recomendable usar imágenes HD (por ejemplo, 1280×720 o 1920×1080) para permitir el escaneo a cierta distancia. Si la app exige baja latencia, puedes bajar la resolución siempre que el código ocupe la mayor parte de la imagen.

Recuerda que formatos muy densos (como PDF417) requieren todavía más resolución. Además, en el caso de Data Matrix, el código debe cruzar el centro de la imagen para que se detecte y solo se reconoce uno por imagen.

Ejemplo detallado de integración: paso a paso real

Visto lo básico, es hora de meterse en harina con una integración típica. Aquí tienes los pasos que debes seguir para poner en marcha un escáner de códigos de barras usando MLKit en Android:

Configura las dependencias en build.gradle (como te expliqué antes, elige empaquetado o sin empaquetar según lo que prefieras para tu app).
Prepara el InputImage (desde Bitmap, media.Image, ByteArray… según tu flujo).
Configura BarcodeScannerOptions para limitar los formatos y ganar en velocidad.
Obtén una instancia del escáner: BarcodeScanning.getClient(options)
Procesa la imagen con el método ‘process’ y gestiona los resultados en el listener de éxito, donde tendrás una lista de objetos Barcode (uno por cada código detectado).
Extrae la información: Cada objeto Barcode te dice el contenido crudo del código, su tipo de dato, e incluso te da las coordenadas del bounding box para destacar el código en la imagen.

Todo esto ocurre en tiempo real y en el propio dispositivo, sin enviar datos fuera ni depender de la velocidad de red.

Detección de objetos y seguimiento: ¿hasta dónde llega MLKit?

El kit de Google no solo vale para códigos de barras. El componente de detección de objetos (Object Detection and Tracking, ODT) te permite encontrar hasta cinco objetos en una imagen y hacerles seguimiento entre frames de vídeo. Es ideal para apps que quieren señalar productos, personas u objetos en tiempo real.

Al configurar el detector, puedes decidir si quieres:

Detectar y seguir varios objetos simultáneamente o solo el más relevante.
Habilitar la clasificación automática (por ejemplo, identificar si se trata de comida, una prenda, planta, etc.)
Elegir el modo ‘stream’ (análisis en tiempo real para vídeo) o ‘single image’ (para fotos estáticas).

Si usas stream, se asignan IDs de tracking a cada objeto para seguirlos entre frames. Puedes obtener coordenadas, etiquetas, índices y nivel de confianza de cada detección. Eso sí, para apps en tiempo real, se recomienda no activar la clasificación ni la detección múltiple si tu objetivo es la máxima velocidad, ya que aumentan la carga de procesamiento.

Cómo conectar MLKit y CameraX: integración moderna y sencilla

Hoy en día, lo normal es usar CameraX en nuevas apps Android. MLKit se integra perfectamente con CameraX a través de la interfaz ImageAnalysis.Analyzer. Usando la clase MlKitAnalyzer, puedes recibir los frames, pasarlos a los detectores de MLKit y obtener los resultados ya transformados al sistema de coordenadas del PreviewView (perfecto para superponer cajas y gráficos).

Para ponerlo en marcha:

Crea una lista de detectores de MLKit (por ejemplo, BarcodeScanner, ObjectDetector…)
Configura el sistema de coordenadas destino según tu vista (suele ser COORDINATE_SYSTEM_VIEW_REFERENCED)
Pasa un Executor adecuado y un Consumer que recibirá los resultados y pintará overlays, destacando los códigos detectados u objetos en pantalla.

CameraX y MLKit se entienden de maravilla y te permiten hacer visualizaciones en tiempo real con apenas unas líneas extra. Además, CameraX gestiona la rotación y el formato de imagen de forma robusta, así que te evitas muchos dolores de cabeza.

Optimización para apps en tiempo real: máxima velocidad y mínimo lag

El gran reto cuando queremos escanear o detectar objetos en tiempo real es mantener una tasa de frames fluida y latencia baja. Para eso:

No captures imágenes a resolución nativa máxima: limita la cámara a 2 megapíxeles como máximo, o incluso menos, siempre que el código se vea bien (así reduces la latencia de procesamiento).
En apps que usan Camera o Camera2, no proceses todos los frames; ignora los que llegan mientras el detector sigue trabajando, así evitas colas innecesarias.
Si usas CameraX, asegúrate de que la estrategia de backpressure esté en ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST, para procesar solo la imagen más reciente y descartar el resto automáticamente.
Si pintas overlays o gráficos, espera a que MLKit devuelva el resultado antes de refrescar la vista, para ganar eficiencia.
Usa formatos óptimos: YUV_420_888 con Camera2, NV21 con APIs antiguas.

Otro consejo habitual es comprobar que la API que uses cierre correctamente los proxies de imagen (ImageProxy.close()) cuando termines con cada frame, evitando así fugas de memoria y retrasos acumulados.

Ejemplo de código para integrar escaneo en una app real

Para que te hagas una idea más clara, aquí tienes una estructura típica (simplificada) de cómo podrías implementar el escaneo con MLKit en una app Android (en Kotlin):


// Configuración de opciones del escáner
val options = BarcodeScannerOptions.Builder()
    .setBarcodeFormats(
        Barcode.FORMAT_QR_CODE,
        Barcode.FORMAT_EAN_13
    )
    .build()

// Instanciar el escáner
val scanner = BarcodeScanning.getClient(options)

// Crear el InputImage desde Bitmap, media.Image, etc.
val image = InputImage.fromBitmap(bitmap, rotationDegrees)

// Procesar la imagen
scanner.process(image)
    .addOnSuccessListener { barcodes ->
        for (barcode in barcodes) {
            val value = barcode.rawValue
            // Aquí haces lo que quieras con el valor
        }
    }
    .addOnFailureListener {
        // Gestiona errores
    }

Cada vez que se detecta un código, puedes leer su valor, su formato y los datos analizados. Si quieres mostrar la caja en pantalla, usa las coordenadas del bounding box.

Más allá de los códigos de barras: reconocimiento de texto y puntos de referencia

MLKit va más lejos que el escaneo de códigos. Puedes añadir reconocimiento de texto (OCR) para capturar textos en imágenes o fotos, o incluso implementar detección de puntos de referencia famosos (ideal para apps de turismo o información).

El flujo es muy similar: añades las dependencias pertinentes (com.google.mlkit:face-detection para caras, com.google.android.gms:play-services-mlkit-text-recognition para OCR, etc.), preparas el InputImage y procesas con el detector correspondiente. El API de resultados te permite acceder a los datos reconocidos (por ejemplo, los textos encontrados, su posición, etc.), y superponerlos en pantalla.

Consejos prácticos y errores habituales

Integrar el escáner de MLKit es sencillo si sigues las recomendaciones, pero aquí van algunos trucos para evitar los fallos clásicos:

No olvides comprobar los permisos de cámara y almacenamiento si tu app los requiere.
Si la primera vez que lanzas el escáner con el modelo sin empaquetar no devuelve resultados, espera a que termine la descarga del modelo.
Cuando trabajes con imágenes rotadas, revisa siempre que InputImage reciba la rotación correcta. Si no, los códigos aparecerán cortados o no se leerán.
Mide la resolución de la imagen de entrada y asegúrate de que los códigos ocupan suficiente espacio: pequeños en imágenes de mucha resolución pueden no ser reconocidos.
Si la app va a escanear en tiempo real, prueba en diferentes dispositivos y ajusta la resolución hasta lograr el mejor equilibrio entre velocidad y precisión.
Para superponer gráficos (overlay), utiliza clases como CameraSourcePreview y GraphicOverlay, disponibles en los ejemplos de Google para MLKit.

El mundo real está lleno de situaciones inesperadas, así que añade logs, gestiona los errores en los listeners y ofrece feedback amigable al usuario cuando el escaneo no salga bien.

Como has visto a lo largo de esta guía, MLKit es una de las herramientas más versátiles y robustas para integrar escaneo avanzado en Android, tanto para proyectos profesionales como para apps más experimentales. Con una preparación correcta, podrás identificar y procesar códigos de barras, objetos, textos y mucho más en tiempo real y sin complicaciones, aprovechando el potencial del machine learning de Google directamente en el bolsillo del usuario. Si dedicas unos minutos a seguir las buenas prácticas y pulir los detalles, tus usuarios lo agradecerán y tu app estará lista para destacar entre la competencia.