Escanear códigos de barras con ML Kit en Android

Puede utilizar ML Kit para reconocer y decodificar códigos de barras.

Antes de que empieces

  1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android .
  2. Agregue las dependencias de las bibliotecas de Android ML Kit al archivo Gradle de su módulo (nivel de aplicación) (generalmente app/build.gradle ):
    apply plugin: 'com.android.application'
    apply plugin
    : 'com.google.gms.google-services'

    dependencies
    {
     
    // ...

      implementation
    'com.google.firebase:firebase-ml-vision:24.0.3'
      implementation
    'com.google.firebase:firebase-ml-vision-barcode-model:16.0.1'

    }

Pautas de imagen de entrada

  • Para que ML Kit lea códigos de barras con precisión, las imágenes de entrada deben contener códigos de barras representados por suficientes datos de píxeles.

    Los requisitos de datos de píxeles específicos dependen tanto del tipo de código de barras como de la cantidad de datos codificados en él (ya que la mayoría de los códigos de barras admiten una carga útil de longitud variable). En general, la unidad significativa más pequeña del código de barras debe tener al menos 2 píxeles de ancho (y para códigos bidimensionales, 2 píxeles de alto).

    Por ejemplo, los códigos de barras EAN-13 se componen de barras y espacios de 1, 2, 3 o 4 unidades de ancho, por lo que una imagen de código de barras EAN-13 idealmente tiene barras y espacios de al menos 2, 4, 6 y 4 unidades. 8 píxeles de ancho. Debido a que un código de barras EAN-13 tiene 95 unidades de ancho en total, el código de barras debe tener al menos 190 píxeles de ancho.

    Los formatos más densos, como PDF417, necesitan mayores dimensiones de píxeles para que ML Kit los lea de manera confiable. Por ejemplo, un código PDF417 puede tener hasta 34 "palabras" de 17 unidades de ancho en una sola fila, que idealmente tendría al menos 1156 píxeles de ancho.

  • Un enfoque deficiente de la imagen puede afectar la precisión del escaneo. Si no obtiene resultados aceptables, intente pedirle al usuario que vuelva a capturar la imagen.

  • Para aplicaciones típicas, se recomienda proporcionar una imagen de mayor resolución (como 1280x720 o 1920x1080), lo que hace que los códigos de barras sean detectables desde una distancia mayor de la cámara.

    Sin embargo, en aplicaciones donde la latencia es crítica, puede mejorar el rendimiento capturando imágenes con una resolución más baja, pero exigiendo que el código de barras constituya la mayor parte de la imagen de entrada. Consulte también Sugerencias para mejorar el rendimiento en tiempo real .

1. Configurar el detector de códigos de barras

Si sabe qué formatos de códigos de barras espera leer, puede mejorar la velocidad del detector de códigos de barras configurándolo para que solo detecte esos formatos.

Por ejemplo, para detectar solo códigos Aztec y códigos QR, cree un objeto FirebaseVisionBarcodeDetectorOptions como en el siguiente ejemplo:

FirebaseVisionBarcodeDetectorOptions options =
       
new FirebaseVisionBarcodeDetectorOptions.Builder()
       
.setBarcodeFormats(
               
FirebaseVisionBarcode.FORMAT_QR_CODE,
               
FirebaseVisionBarcode.FORMAT_AZTEC)
       
.build();
val options = FirebaseVisionBarcodeDetectorOptions.Builder()
       
.setBarcodeFormats(
               
FirebaseVisionBarcode.FORMAT_QR_CODE,
               
FirebaseVisionBarcode.FORMAT_AZTEC)
       
.build()

Se admiten los siguientes formatos:

  • Código 128 ( FORMAT_CODE_128 )
  • Código 39 ( FORMAT_CODE_39 )
  • Código 93 ( FORMAT_CODE_93 )
  • Codabar ( FORMAT_CODABAR )
  • EAN-13 ( FORMAT_EAN_13 )
  • EAN-8 ( FORMAT_EAN_8 )
  • ITF ( FORMAT_ITF )
  • UPC-A ( FORMAT_UPC_A )
  • UPC-E ( FORMAT_UPC_E )
  • Código QR ( FORMAT_QR_CODE )
  • PDF417 ( FORMAT_PDF417 )
  • Azteca ( FORMAT_AZTEC )
  • Matriz de datos ( FORMAT_DATA_MATRIX )

2. Ejecute el detector de códigos de barras

Para reconocer códigos de barras en una imagen, cree un objeto FirebaseVisionImage a partir de un Bitmap , media.Image , ByteBuffer , una matriz de bytes o un archivo en el dispositivo. Luego, pase el objeto FirebaseVisionImage al método detectInImage de FirebaseVisionBarcodeDetector .

  1. Crea un objeto FirebaseVisionImage a partir de tu imagen.

    • Para crear un objeto FirebaseVisionImage a partir de un objeto media.Image , como al capturar una imagen desde la cámara de un dispositivo, pase el objeto media.Image y la rotación de la imagen a FirebaseVisionImage.fromMediaImage() .

      Si usa la biblioteca CameraX , las clases OnImageCapturedListener e ImageAnalysis.Analyzer calculan el valor de rotación por usted, por lo que solo necesita convertir la rotación a una de las constantes ROTATION_ del kit ML antes de llamar FirebaseVisionImage.fromMediaImage() :

      private class YourAnalyzer implements ImageAnalysis.Analyzer {

         
      private int degreesToFirebaseRotation(int degrees) {
             
      switch (degrees) {
                 
      case 0:
                     
      return FirebaseVisionImageMetadata.ROTATION_0;
                 
      case 90:
                     
      return FirebaseVisionImageMetadata.ROTATION_90;
                 
      case 180:
                     
      return FirebaseVisionImageMetadata.ROTATION_180;
                 
      case 270:
                     
      return FirebaseVisionImageMetadata.ROTATION_270;
                 
      default:
                     
      throw new IllegalArgumentException(
                             
      "Rotation must be 0, 90, 180, or 270.");
             
      }
         
      }

         
      @Override
         
      public void analyze(ImageProxy imageProxy, int degrees) {
             
      if (imageProxy == null || imageProxy.getImage() == null) {
                 
      return;
             
      }
             
      Image mediaImage = imageProxy.getImage();
             
      int rotation = degreesToFirebaseRotation(degrees);
             
      FirebaseVisionImage image =
                     
      FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
             
      // Pass image to an ML Kit Vision API
             
      // ...
         
      }
      }
      private class YourImageAnalyzer : ImageAnalysis.Analyzer {
         
      private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) {
             
      0 -> FirebaseVisionImageMetadata.ROTATION_0
             
      90 -> FirebaseVisionImageMetadata.ROTATION_90
             
      180 -> FirebaseVisionImageMetadata.ROTATION_180
             
      270 -> FirebaseVisionImageMetadata.ROTATION_270
             
      else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
         
      }

         
      override fun analyze(imageProxy: ImageProxy?, degrees: Int) {
             
      val mediaImage = imageProxy?.image
             
      val imageRotation = degreesToFirebaseRotation(degrees)
             
      if (mediaImage != null) {
                 
      val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
                 
      // Pass image to an ML Kit Vision API
                 
      // ...
             
      }
         
      }
      }

      Si no utiliza una biblioteca de cámaras que le proporcione la rotación de la imagen, puede calcularla a partir de la rotación del dispositivo y la orientación del sensor de la cámara en el dispositivo:

      private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
      static {
          ORIENTATIONS
      .append(Surface.ROTATION_0, 90);
          ORIENTATIONS
      .append(Surface.ROTATION_90, 0);
          ORIENTATIONS
      .append(Surface.ROTATION_180, 270);
          ORIENTATIONS
      .append(Surface.ROTATION_270, 180);
      }

      /**
       * Get the angle by which an image must be rotated given the device's current
       * orientation.
       */

      @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
      private int getRotationCompensation(String cameraId, Activity activity, Context context)
             
      throws CameraAccessException {
         
      // Get the device's current rotation relative to its "native" orientation.
         
      // Then, from the ORIENTATIONS table, look up the angle the image must be
         
      // rotated to compensate for the device's rotation.
         
      int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
         
      int rotationCompensation = ORIENTATIONS.get(deviceRotation);

         
      // On most devices, the sensor orientation is 90 degrees, but for some
         
      // devices it is 270 degrees. For devices with a sensor orientation of
         
      // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
         
      CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
         
      int sensorOrientation = cameraManager
                 
      .getCameraCharacteristics(cameraId)
                 
      .get(CameraCharacteristics.SENSOR_ORIENTATION);
          rotationCompensation
      = (rotationCompensation + sensorOrientation + 270) % 360;

         
      // Return the corresponding FirebaseVisionImageMetadata rotation value.
         
      int result;
         
      switch (rotationCompensation) {
             
      case 0:
                  result
      = FirebaseVisionImageMetadata.ROTATION_0;
                 
      break;
             
      case 90:
                  result
      = FirebaseVisionImageMetadata.ROTATION_90;
                 
      break;
             
      case 180:
                  result
      = FirebaseVisionImageMetadata.ROTATION_180;
                 
      break;
             
      case 270:
                  result
      = FirebaseVisionImageMetadata.ROTATION_270;
                 
      break;
             
      default:
                  result
      = FirebaseVisionImageMetadata.ROTATION_0;
                 
      Log.e(TAG, "Bad rotation value: " + rotationCompensation);
         
      }
         
      return result;
      }
      private val ORIENTATIONS = SparseIntArray()

      init {
          ORIENTATIONS
      .append(Surface.ROTATION_0, 90)
          ORIENTATIONS
      .append(Surface.ROTATION_90, 0)
          ORIENTATIONS
      .append(Surface.ROTATION_180, 270)
          ORIENTATIONS
      .append(Surface.ROTATION_270, 180)
      }
      /**
       * Get the angle by which an image must be rotated given the device's current
       * orientation.
       */

      @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
      @Throws(CameraAccessException::class)
      private fun getRotationCompensation(cameraId: String, activity: Activity, context: Context): Int {
         
      // Get the device's current rotation relative to its "native" orientation.
         
      // Then, from the ORIENTATIONS table, look up the angle the image must be
         
      // rotated to compensate for the device's rotation.
         
      val deviceRotation = activity.windowManager.defaultDisplay.rotation
         
      var rotationCompensation = ORIENTATIONS.get(deviceRotation)

         
      // On most devices, the sensor orientation is 90 degrees, but for some
         
      // devices it is 270 degrees. For devices with a sensor orientation of
         
      // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
         
      val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
         
      val sensorOrientation = cameraManager
                 
      .getCameraCharacteristics(cameraId)
                 
      .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
          rotationCompensation
      = (rotationCompensation + sensorOrientation + 270) % 360

         
      // Return the corresponding FirebaseVisionImageMetadata rotation value.
         
      val result: Int
         
      when (rotationCompensation) {
             
      0 -> result = FirebaseVisionImageMetadata.ROTATION_0
             
      90 -> result = FirebaseVisionImageMetadata.ROTATION_90
             
      180 -> result = FirebaseVisionImageMetadata.ROTATION_180
             
      270 -> result = FirebaseVisionImageMetadata.ROTATION_270
             
      else -> {
                  result
      = FirebaseVisionImageMetadata.ROTATION_0
                 
      Log.e(TAG, "Bad rotation value: $rotationCompensation")
             
      }
         
      }
         
      return result
      }

      Luego, pasa el objeto media.Image y el valor de rotación a FirebaseVisionImage.fromMediaImage() :

      FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
      val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
    • Para crear un objeto FirebaseVisionImage a partir de un URI de archivo, pase el contexto de la aplicación y el URI del archivo a FirebaseVisionImage.fromFilePath() . Esto es útil cuando usas un intent ACTION_GET_CONTENT para pedirle al usuario que seleccione una imagen de su aplicación de galería.
      FirebaseVisionImage image;
      try {
          image
      = FirebaseVisionImage.fromFilePath(context, uri);
      } catch (IOException e) {
          e
      .printStackTrace();
      }
      val image: FirebaseVisionImage
      try {
          image
      = FirebaseVisionImage.fromFilePath(context, uri)
      } catch (e: IOException) {
          e
      .printStackTrace()
      }
    • Para crear un objeto FirebaseVisionImage a partir de un ByteBuffer o una matriz de bytes, primero calcule la rotación de la imagen como se describe anteriormente para la entrada media.Image .

      Luego, crea un objeto FirebaseVisionImageMetadata que contenga la altura, el ancho, el formato de codificación de color y la rotación de la imagen:

      FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
             
      .setWidth(480)   // 480x360 is typically sufficient for
             
      .setHeight(360)  // image recognition
             
      .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
             
      .setRotation(rotation)
             
      .build();
      val metadata = FirebaseVisionImageMetadata.Builder()
             
      .setWidth(480) // 480x360 is typically sufficient for
             
      .setHeight(360) // image recognition
             
      .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
             
      .setRotation(rotation)
             
      .build()

      Utilice el búfer o matriz y el objeto de metadatos para crear un objeto FirebaseVisionImage :

      FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);
      // Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);
      val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
      // Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
    • Para crear un objeto FirebaseVisionImage a partir de un objeto Bitmap :
      FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
      val image = FirebaseVisionImage.fromBitmap(bitmap)
      La imagen representada por el objeto Bitmap debe estar en posición vertical, sin necesidad de rotación adicional.

  2. Obtenga una instancia de FirebaseVisionBarcodeDetector :

    FirebaseVisionBarcodeDetector detector = FirebaseVision.getInstance()
           
    .getVisionBarcodeDetector();
    // Or, to specify the formats to recognize:
    // FirebaseVisionBarcodeDetector detector = FirebaseVision.getInstance()
    //        .getVisionBarcodeDetector(options);
    val detector = FirebaseVision.getInstance()
           
    .visionBarcodeDetector
    // Or, to specify the formats to recognize:
    // val detector = FirebaseVision.getInstance()
    //        .getVisionBarcodeDetector(options)
  3. Finalmente, pasa la imagen al método detectInImage :

    Task<List<FirebaseVisionBarcode>> result = detector.detectInImage(image)
           
    .addOnSuccessListener(new OnSuccessListener<List<FirebaseVisionBarcode>>() {
               
    @Override
               
    public void onSuccess(List<FirebaseVisionBarcode> barcodes) {
                   
    // Task completed successfully
                   
    // ...
               
    }
           
    })
           
    .addOnFailureListener(new OnFailureListener() {
               
    @Override
               
    public void onFailure(@NonNull Exception e) {
                   
    // Task failed with an exception
                   
    // ...
               
    }
                   
    });
    val result = detector.detectInImage(image)
           
    .addOnSuccessListener { barcodes ->
               
    // Task completed successfully
               
    // ...
           
    }
           
    .addOnFailureListener {
               
    // Task failed with an exception
               
    // ...
           
    }

3. Obtener información de códigos de barras

Si la operación de reconocimiento de código de barras tiene éxito, se pasará una lista de objetos FirebaseVisionBarcode al oyente exitoso. Cada objeto FirebaseVisionBarcode representa un código de barras que se detectó en la imagen. Para cada código de barras, puede obtener sus coordenadas delimitadoras en la imagen de entrada, así como los datos sin procesar codificados por el código de barras. Además, si el detector de códigos de barras pudo determinar el tipo de datos codificados por el código de barras, puede obtener un objeto que contenga datos analizados.

Por ejemplo:

for (FirebaseVisionBarcode barcode: barcodes) {
   
Rect bounds = barcode.getBoundingBox();
   
Point[] corners = barcode.getCornerPoints();

   
String rawValue = barcode.getRawValue();

   
int valueType = barcode.getValueType();
   
// See API reference for complete list of supported types
   
switch (valueType) {
       
case FirebaseVisionBarcode.TYPE_WIFI:
           
String ssid = barcode.getWifi().getSsid();
           
String password = barcode.getWifi().getPassword();
           
int type = barcode.getWifi().getEncryptionType();
           
break;
       
case FirebaseVisionBarcode.TYPE_URL:
           
String title = barcode.getUrl().getTitle();
           
String url = barcode.getUrl().getUrl();
           
break;
   
}
}
for (barcode in barcodes) {
   
val bounds = barcode.boundingBox
   
val corners = barcode.cornerPoints

   
val rawValue = barcode.rawValue

   
val valueType = barcode.valueType
   
// See API reference for complete list of supported types
   
when (valueType) {
       
FirebaseVisionBarcode.TYPE_WIFI -> {
           
val ssid = barcode.wifi!!.ssid
           
val password = barcode.wifi!!.password
           
val type = barcode.wifi!!.encryptionType
       
}
       
FirebaseVisionBarcode.TYPE_URL -> {
           
val title = barcode.url!!.title
           
val url = barcode.url!!.url
       
}
   
}
}

Consejos para mejorar el rendimiento en tiempo real

Si desea escanear códigos de barras en una aplicación en tiempo real, siga estas pautas para lograr las mejores velocidades de fotogramas:

  • No capture entradas con la resolución nativa de la cámara. En algunos dispositivos, capturar la entrada con la resolución nativa produce imágenes extremadamente grandes (más de 10 megapíxeles), lo que resulta en una latencia muy pobre sin ningún beneficio para la precisión. En su lugar, solicite a la cámara únicamente el tamaño necesario para la detección de códigos de barras: normalmente no más de 2 megapíxeles.

    Si la velocidad de escaneo es importante, puede reducir aún más la resolución de captura de imágenes. Sin embargo, tenga en cuenta los requisitos de tamaño mínimo de código de barras descritos anteriormente.

  • Llamadas del acelerador al detector. Si hay un nuevo cuadro de video disponible mientras el detector está en ejecución, suelte el cuadro.
  • Si está utilizando la salida del detector para superponer gráficos en la imagen de entrada, primero obtenga el resultado del ML Kit, luego renderice la imagen y superpóngala en un solo paso. Al hacerlo, renderiza en la superficie de visualización solo una vez por cada cuadro de entrada.
  • Si utiliza la API Camera2, capture imágenes en formato ImageFormat.YUV_420_888 .

    Si utiliza la API de cámara anterior, capture imágenes en formato ImageFormat.NV21 .