Ir a la consola

Escanea códigos de barras con el Kit de AA en Android

Puedes usar el Kit de AA para reconocer y decodificar códigos de barras.

Consulta la muestra de inicio rápido del Kit de AA en GitHub para ver un ejemplo de esta API en uso.

Antes de comenzar

  1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android.
  2. Agrega las dependencias para las bibliotecas de Android del Kit de AA al archivo Gradle, generalmente “app/build.gradle”, de tu módulo (nivel de aplicación):
    dependencies {
      // ...
    
      implementation 'com.google.firebase:firebase-ml-vision:19.0.3'
    }
    
  3. Opcional, pero recomendado: configura tu aplicación para descargar automáticamente el modelo de AA al dispositivo después de instalar la aplicación desde Play Store.

    Para ello, agrega la siguiente declaración al archivo AndroidManifest.xml de tu app:

    <application ...>
      ...
      <meta-data
          android:name="com.google.firebase.ml.vision.DEPENDENCIES"
          android:value="barcode" />
      <!-- To use multiple models: android:value="barcode,model2,model3" -->
    </application>
    
    Si no habilitas las descargas de modelos en el momento de la instalación, el modelo se descargará la primera vez que ejecutes el detector. Las solicitudes que realices antes de que se complete la descarga no generarán ningún resultado.

Lineamientos para imágenes de entrada

  • Para que el Kit de AA reconozca códigos de barras con exactitud, las imágenes de entrada deben contener códigos de barras representados con datos de píxeles suficientes. Por lo general, la unidad mínima de significado de un código de barras debe tener al menos 2 píxeles de ancho (y en códigos de 2 dimensiones, también 2 píxeles de altura).

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

    Los formatos más densos, como PDF417, requieren mayores dimensiones de píxeles para que el Kit de AA pueda leerlas de forma confiable. Por ejemplo, un código PDF417 puede tener hasta 34 “palabras” de 17 unidades de ancho en una sola fila, que idealmente tendrá un ancho de 1156 píxeles.

  • Un enfoque de imagen deficiente puede afectar la exactitud del escaneo. Si no obtienes resultados aceptables, intenta pedirle al usuario que vuelva a capturar la imagen.

  • Si escaneas códigos de barras en una aplicación en tiempo real, te recomendamos tener en cuenta las dimensiones generales de las imágenes de entrada. Las imágenes más pequeñas se pueden procesar más rápido. Así que, para reducir la latencia, captura las imágenes con resoluciones más bajas (teniendo en cuenta los requisitos de exactitud anteriores) y asegúrate de que el código de barras ocupe la mayor parte de la imagen que sea posible. Consulta también Sugerencias para mejorar el rendimiento en tiempo real.

1. Configura el detector de códigos de barras

Si sabes qué formatos de códigos de barras leerás, puedes configurar el detector de códigos de barras para que solo detecte esos formatos a fin de aumentar su velocidad.

Por ejemplo, para detectar solo código Aztec y códigos QR, crea un objeto FirebaseVisionBarcodeDetectorOptions como el del ejemplo siguiente:

Java
Android

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

Kotlin
Android

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

Se admiten los siguientes formatos:

  • Code 128 (FORMAT_CODE_128)
  • Code 39 (FORMAT_CODE_39)
  • Code 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)
  • Aztec (FORMAT_AZTEC)
  • Data Matrix (FORMAT_DATA_MATRIX)

2. Ejecuta el detector códigos de barras

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

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

    • Crea un objeto FirebaseVisionImage a partir de un objeto Bitmap:

      Java
      Android

      FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);

      Kotlin
      Android

      val image = FirebaseVisionImage.fromBitmap(bitmap)
      La imagen que representa el objeto Bitmap debe estar en posición vertical, sin que sea necesario rotarla.
    • Para crear un objeto FirebaseVisionImage a partir de un objeto media.Image, como una imagen capturada con la cámara de un dispositivo, primero determina el ángulo en el que se debe rotar la imagen para compensar la rotación del dispositivo y la orientación del sensor de la cámara:

      Java
      Android

      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;
      }

      Kotlin
      Android

      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() de la siguiente manera:

      Java
      Android

      FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);

      Kotlin
      Android

      val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
    • Para crear un objeto FirebaseVisionImage a partir de ByteBuffer o una matriz de bytes, primero calcula la rotación de la imagen como se describe anteriormente.

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

      Java
      Android

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

      Kotlin
      Android

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

      Usa el búfer o la matriz, y el objeto de metadatos, para crear un objeto FirebaseVisionImage:

      Java
      Android

      FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);// Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);

      Kotlin
      Android

      val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)// Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
    • Para crear un objeto FirebaseVisionImage a partir de un archivo, pasa el contexto de la app y el URI del archivo a FirebaseVisionImage.fromFilePath():

      Java
      Android

      FirebaseVisionImage image;
      try {
          image = FirebaseVisionImage.fromFilePath(context, uri);
      } catch (IOException e) {
          e.printStackTrace();
      }

      Kotlin
      Android

      val image: FirebaseVisionImage
      try {
          image = FirebaseVisionImage.fromFilePath(context, uri)
      } catch (e: IOException) {
          e.printStackTrace()
      }

  2. Obtén una instancia de FirebaseVisionBarcodeDetector:

    Java
    Android

    FirebaseVisionBarcodeDetector detector = FirebaseVision.getInstance()
            .getVisionBarcodeDetector();
    // Or, to specify the formats to recognize:
    // FirebaseVisionBarcodeDetector detector = FirebaseVision.getInstance()
    //        .getVisionBarcodeDetector(options);

    Kotlin
    Android

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

    Java
    Android

    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
                    // ...
                }
                    });

    Kotlin
    Android

    val result = detector.detectInImage(image)
            .addOnSuccessListener { barcodes ->
                // Task completed successfully
                // ...
            }
            .addOnFailureListener {
                // Task failed with an exception
                // ...
            }

3. Obtén información de códigos de barras

Si la operación de reconocimiento del código de barras se ejecuta de forma correcta, se pasará una lista de objetos FirebaseVisionBarcode al objeto de escucha que detecta el resultado correcto. Cada objeto FirebaseVisionBarcode representa un código de barras que se detectó en la imagen. Para cada código de barras, puedes obtener las coordenadas de sus límites en la imagen de entrada, junto con los datos sin procesar codificados en el código de barras. Además, si el detector de códigos de barras pudo determinar el tipo de datos codificados en el código de barras, puedes obtener un objeto que contenga los datos analizados.

Por ejemplo:

Java
Android

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;
    }
}

Kotlin
Android

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
        }
    }
}

Sugerencias para mejorar el rendimiento en tiempo real

Si quieres escanear códigos de barras en una aplicación en tiempo real, sigue estos lineamientos para lograr la mejor velocidad de fotogramas por segundo:

  • Regula las llamadas al detector. Si hay un fotograma de video nuevo disponible mientras se ejecuta el detector de rostro, ignora ese fotograma.
  • Si estás usando la salida del detector de rostros para superponer gráficas en la imagen de entrada, primero obtén el resultado de la detección de rostro del Kit de AA y luego procesa la imagen y la superposición en un solo paso. De esta manera, procesas en la superficie de visualización solo una vez por cada fotograma de entrada. Consulta las clases CameraSourcePreview y GraphicOverlay en la aplicación de muestra de inicio rápido para ver un ejemplo.
  • Si usas la API de Camera2, capta imágenes en formato ImageFormat.YUV_420_888.

    Si usas la API de Camera más antigua, captura imágenes en formato ImageFormat.NV21.

  • Captura imágenes con una resolución más baja. Sin embargo, también ten en cuenta los requisitos de dimensiones de imágenes de esta API.