Barcodes mit ML Kit auf Android scannen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Mit ML Kit können Sie Barcodes erkennen und decodieren.

Es gibt zwei Möglichkeiten, das Scannen von Barcodes zu integrieren: Bündeln des Modells als Teil Ihrer App oder Verwendung eines nicht gebündelten Modells, das von den Google Play-Diensten abhängt. Wenn Sie das nicht gebündelte Modell auswählen, ist Ihre App kleiner. Weitere Details finden Sie in der nachfolgenden Tabelle.

FunktionNicht gebündeltGebündelt
ImplementierungDas Modell wird über die Google Play-Dienste dynamisch heruntergeladen.Das Modell ist bei der Build-Erstellung statisch mit Ihrer App verknüpft.
App-GrößeDie Größe wurde um ca. 600 KB erhöht.Ca. 3,2 MB
InitialisierungszeitMüssen möglicherweise warten, bis das Modell heruntergeladen ist, bevor es verwendet werden kann.Das Modell ist sofort verfügbar.

Hinweis

  1. Achten Sie darauf, dass Sie in Ihrer build.gradle-Datei auf Projektebene das Maven-Repository von Google in die Abschnitte buildscript und allprojects aufnehmen.

  2. Fügen Sie die Abhängigkeiten für die ML Kit-Android-Bibliotheken der Gradle-Datei auf App-Ebene hinzu, die normalerweise app/build.gradle ist. Wählen Sie je nach Ihren Anforderungen eine der folgenden Abhängigkeiten aus:

    So bündeln Sie das Modell mit Ihrer App:

    dependencies {
      // ...
      // Use this dependency to bundle the model with your app
      implementation 'com.google.mlkit:barcode-scanning:17.0.2'
    }
    

    Für die Verwendung des Modells in den Google Play-Diensten:

    dependencies {
      // ...
      // Use this dependency to use the dynamically downloaded model in Google Play Services
      implementation 'com.google.android.gms:play-services-mlkit-barcode-scanning:18.1.0'
    }
    
  3. Wenn Sie das Modell in den Google Play-Diensten verwenden, können Sie die App so konfigurieren, dass das Modell automatisch auf das Gerät heruntergeladen wird, nachdem es aus dem Play Store installiert wurde. Fügen Sie dazu der Datei AndroidManifest.xml Ihrer App die folgende Deklaration hinzu:

    <application ...>
          ...
          <meta-data
              android:name="com.google.mlkit.vision.DEPENDENCIES"
              android:value="barcode" >
          <!-- To use multiple models: android:value="barcode,model2,model3" -->
    </application>
    

    Sie können die Modellverfügbarkeit auch explizit prüfen und einen Download über die ModuleInstallClient API der Google Play-Dienste anfordern.

    Wenn Sie die Installation des Modells während der Installation nicht aktivieren oder einen expliziten Download anfordern, wird das Modell heruntergeladen, wenn Sie den Scanner das erste Mal ausführen. Anfragen, die Sie vor Abschluss des Downloads senden, führen zu keinem Ergebnis.

Richtlinien für Eingabebilder

  • Damit das ML Kit Barcodes richtig lesen kann, müssen Eingabebilder Barcodes enthalten, die durch genügend Pixeldaten dargestellt werden.

    Die spezifischen Pixeldatenanforderungen hängen sowohl vom Barcodetyp als auch von der Datenmenge ab, die in ihm codiert ist, da viele Barcodes eine Nutzlast mit variabler Größe unterstützen. Im Allgemeinen sollte die kleinste aussagekräftige Einheit des Barcodes mindestens 2 Pixel breit und für zweidimensionale Codes 2 Pixel hoch sein.

    EAN-13-Barcodes bestehen beispielsweise aus Balken und Leerzeichen, die 1, 2, 3 oder 4 Einheiten breit sind. Ein EAN-13-Barcodebild hat also idealerweise Balken und Leerzeichen, die mindestens 2, 4, 6 und 8 Pixel breit sind. Da ein EAN-13-Barcode insgesamt 95 Einheiten hat, sollte er mindestens 190 Pixel breit sein.

    Dichtere Formate wie PDF417 benötigen größere Pixelabmessungen, damit das ML Kit sie zuverlässig lesen kann. Ein PDF417-Code kann beispielsweise bis zu 34 breite 17-Einheiten-Wörter in einer einzigen Zeile enthalten, die idealerweise mindestens 1.156 Pixel breit sind.

  • Ein schlechter Bildfokus kann die Genauigkeit des Scans beeinträchtigen. Wenn deine App keine akzeptablen Ergebnisse liefert, bitte den Nutzer, das Bild neu aufzunehmen.

  • Für typische Anwendungen wird empfohlen, ein Bild mit höherer Auflösung bereitzustellen, z. B. 1280 × 720 oder 1920 × 1080. Dadurch können Barcodes aus größerer Entfernung von der Kamera gescannt werden.

    In Anwendungen, in denen die Latenz von kritischer Bedeutung ist, können Sie die Leistung jedoch verbessern, indem Sie Bilder mit einer geringeren Auflösung aufnehmen. Dabei muss der Barcode jedoch den Großteil des Eingabebilds ausmachen. Weitere Informationen finden Sie unter Tipps zur Verbesserung der Echtzeitleistung.

1. Barcode-Scanner konfigurieren

Wenn Sie wissen, welche Barcodeformate Sie lesen möchten, können Sie die Geschwindigkeit des Barcodedetektors verbessern, indem Sie ihn so konfigurieren, dass nur diese Formate erkannt werden.

Wenn Sie beispielsweise nur aztekische Codes und QR-Codes erkennen möchten, erstellen Sie ein BarcodeScannerOptions-Objekt wie im folgenden Beispiel:

Kotlin

val options = BarcodeScannerOptions.Builder()
        .setBarcodeFormats(
                Barcode.FORMAT_QR_CODE,
                Barcode.FORMAT_AZTEC)
        .build()

Java

BarcodeScannerOptions options =
        new BarcodeScannerOptions.Builder()
        .setBarcodeFormats(
                Barcode.FORMAT_QR_CODE,
                Barcode.FORMAT_AZTEC)
        .build();

Die folgenden Formate werden unterstützt:

  • 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)
  • QR-Code (FORMAT_QR_CODE)
  • PDF417 (FORMAT_PDF417)
  • Azteken (FORMAT_AZTEC)
  • Data Matrix (FORMAT_DATA_MATRIX)

2. Eingabebild vorbereiten

Erstellen Sie ein InputImage-Objekt aus einem Bitmap-, media.Image-, ByteBuffer-, Byte-Array oder einer Datei auf dem Gerät, um Barcodes in einem Bild zu erkennen. Übergeben Sie dann das Objekt InputImage an die Methode process von BarcodeScanner.

Sie können ein InputImage-Objekt aus verschiedenen Quellen erstellen. Dies wird unten erläutert.

Mit einem media.Image

Wenn Sie ein InputImage-Objekt aus einem media.Image-Objekt erstellen möchten, z. B. wenn Sie ein Bild von der Kamera eines Geräts aufnehmen, übergeben Sie das Objekt media.Image und die Bilddrehung an InputImage.fromMediaImage().

Wenn Sie die KameraX-Bibliothek verwenden, berechnen die Klassen OnImageCapturedListener und ImageAnalysis.Analyzer den Rotationswert für Sie.

Kotlin

private class YourImageAnalyzer : ImageAnalysis.Analyzer {

    override fun analyze(imageProxy: ImageProxy) {
        val mediaImage = imageProxy.image
        if (mediaImage != null) {
            val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees)
            // Pass image to an ML Kit Vision API
            // ...
        }
    }
}

Java

private class YourAnalyzer implements ImageAnalysis.Analyzer {

    @Override
    public void analyze(ImageProxy imageProxy) {
        Image mediaImage = imageProxy.getImage();
        if (mediaImage != null) {
          InputImage image =
                InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees());
          // Pass image to an ML Kit Vision API
          // ...
        }
    }
}

Wenn du keine Kamerabibliothek verwendest, die dir den Grad der Drehung des Bildes liefert, kannst du ihn aus dem Rotationsgrad des Geräts und der Ausrichtung des Kamerasensors im Gerät berechnen:

Kotlin

private val ORIENTATIONS = SparseIntArray()

init {
    ORIENTATIONS.append(Surface.ROTATION_0, 0)
    ORIENTATIONS.append(Surface.ROTATION_90, 90)
    ORIENTATIONS.append(Surface.ROTATION_180, 180)
    ORIENTATIONS.append(Surface.ROTATION_270, 270)
}

/**
 * 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, isFrontFacing: Boolean): 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)

    // Get the device's sensor orientation.
    val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager
    val sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION)!!

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360
    }
    return rotationCompensation
}

Java

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

/**
 * 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, boolean isFrontFacing)
        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);

    // Get the device's sensor orientation.
    CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE);
    int sensorOrientation = cameraManager
            .getCameraCharacteristics(cameraId)
            .get(CameraCharacteristics.SENSOR_ORIENTATION);

    if (isFrontFacing) {
        rotationCompensation = (sensorOrientation + rotationCompensation) % 360;
    } else { // back-facing
        rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360;
    }
    return rotationCompensation;
}

Übergib dann das media.Image-Objekt und den Rotationsgradwert an InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

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

Datei-URI verwenden

Übergeben Sie den Anwendungskontext und den Datei-URI an InputImage.fromFilePath(), um ein InputImage-Objekt aus einem Datei-URI zu erstellen. Dies ist nützlich, wenn Sie den Intent ACTION_GET_CONTENT verwenden, um den Nutzer aufzufordern, ein Bild aus seiner Galerie-App auszuwählen.

Kotlin

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

Java

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

Mit ByteBuffer oder ByteArray

Um ein InputImage-Objekt aus einem ByteBuffer oder einem ByteArray zu erstellen, musst du zuerst den Grad der Bilddrehung berechnen, wie zuvor für die media.Image-Eingabe beschrieben. Erstellen Sie dann das InputImage-Objekt mit dem Zwischenspeicher oder Array sowie Höhe, Breite, Farbcodierungsformat und Rotationsgrad des Bildes:

Kotlin

val image = InputImage.fromByteBuffer(
        byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);

Mit einem Bitmap

So erstellen Sie ein InputImage-Objekt aus einem Bitmap-Objekt:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);

Das Bild wird durch ein Bitmap-Objekt mit Rotationsgrad dargestellt.

3. Instanz von BarcodeScanner abrufen

Kotlin

val scanner = BarcodeScanning.getClient()
// Or, to specify the formats to recognize:
// val scanner = BarcodeScanning.getClient(options)

Java

BarcodeScanner scanner = BarcodeScanning.getClient();
// Or, to specify the formats to recognize:
// BarcodeScanner scanner = BarcodeScanning.getClient(options);

4. Bild verarbeiten

Übergeben Sie das Bild an die Methode process:

Kotlin

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

Java

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

5. Informationen von Barcodes abrufen

Wenn der Barcodeerkennungsvorgang erfolgreich ist, wird eine Liste von Barcode-Objekten an den Erfolgs-Listener übergeben. Jedes Barcode-Objekt stellt einen Barcode dar, der im Bild erkannt wurde. Für jeden Barcode können Sie dessen Begrenzungskoordinaten im Eingabebild sowie die durch den Barcode codierten Rohdaten abrufen. Wenn der Barcode-Scanner den vom Barcode codierten Datentyp ermitteln konnte, können Sie ein Objekt abrufen, das geparste Daten enthält.

Beispiel:

Kotlin

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) {
        Barcode.TYPE_WIFI -> {
            val ssid = barcode.wifi!!.ssid
            val password = barcode.wifi!!.password
            val type = barcode.wifi!!.encryptionType
        }
        Barcode.TYPE_URL -> {
            val title = barcode.url!!.title
            val url = barcode.url!!.url
        }
    }
}

Java

for (Barcode 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 Barcode.TYPE_WIFI:
            String ssid = barcode.getWifi().getSsid();
            String password = barcode.getWifi().getPassword();
            int type = barcode.getWifi().getEncryptionType();
            break;
        case Barcode.TYPE_URL:
            String title = barcode.getUrl().getTitle();
            String url = barcode.getUrl().getUrl();
            break;
    }
}

Tipps zur Verbesserung der Echtzeitleistung

Wenn Sie Barcodes in einer Echtzeitanwendung scannen möchten, beachten Sie die folgenden Richtlinien, um die besten Framerates zu erzielen:

  • Nehmen Sie den Eingang mit der nativen Auflösung der Kamera nicht auf. Auf einigen Geräten liefert die Aufnahme der Eingabe mit nativer Auflösung extrem große Bilder (über 10 Megapixel). Das führt zu einer sehr schlechten Latenz, ohne dass die Genauigkeit beeinträchtigt wird. Fordern Sie stattdessen nur die für die Barcodeerkennung erforderliche Größe von der Kamera an, die normalerweise nicht mehr als 2 Megapixel beträgt.

    Wenn die Scangeschwindigkeit wichtig ist, können Sie die Auflösung der Bildaufnahme weiter verringern. Beachten Sie jedoch die oben genannten Mindestanforderungen an die Barcodegröße.

    Wenn Sie versuchen, Barcodes aus einer Sequenz von Streaming-Videoframes zu erkennen, kann die Erkennung unterschiedliche Ergebnisse von Frame zu Frame liefern. Sie sollten warten, bis Sie eine aufeinanderfolgende Serie desselben Werts erhalten, um sicher zu sein, dass Sie ein gutes Ergebnis zurückgeben.

    Die Prüfziffer wird für ITF und CODE-39 nicht unterstützt.

  • Wenn Sie die API Camera oder camera2 verwenden, drosseln Sie Aufrufe an den Detektor. Wenn während der Ausführung des Detektors ein neuer Videoframe verfügbar wird, lassen Sie den Frame los. Ein Beispiel findest du in der Kurzanleitungs-Beispielanwendung in der Klasse VisionProcessorBase.
  • Wenn Sie die CameraX API verwenden, achten Sie darauf, dass die Gegendruckstrategie auf den Standardwert ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST festgelegt ist. So wird sichergestellt, dass jeweils nur ein Bild zur Analyse übermittelt wird. Wenn bei der Ausarbeitung des Analysetools mehr Bilder erstellt werden, werden diese automatisch gelöscht und nicht in die Warteschlange gestellt. Sobald das analysierte Bild durch Aufrufen von ImageProxy.close() geschlossen wird, wird das nächste neueste Bild bereitgestellt.
  • Wenn Sie die Ausgabe des Detektors verwenden, um Grafiken auf dem Eingabebild einzublenden, rufen Sie zuerst das Ergebnis aus ML Kit ab und rendern Sie dann das Bild und das Overlay in einem einzigen Schritt. Dies wird für jeden Eingabeframe nur einmal auf der Anzeigeoberfläche gerendert. Ein Beispiel finden Sie in den Beispielkursen CameraSourcePreview und GraphicOverlay.
  • Wenn Sie die Camera2 API verwenden, nehmen Sie Bilder im Format ImageFormat.YUV_420_888 auf. Wenn du die ältere Camera API verwendest, solltest du Bilder im Format ImageFormat.NV21 aufnehmen.