Skanuj kody kreskowe za pomocą aplikacji ML Kit na Androida

Zadbaj o dobrą organizację dzięki kolekcji Zapisuj i kategoryzuj treści zgodnie ze swoimi preferencjami.

Kody ML Kit pozwalają rozpoznawać i dekodować kody kreskowe.

Skanowanie kodów paskowych można zintegrować na 2 sposoby: łącząc model w ramach aplikacji lub tworząc niezawarty model zależny od Usług Google Play. Jeśli wybierzesz pakiet bez pakietu, aplikacja będzie mniejsza. Szczegółowe informacje znajdziesz w tabeli poniżej.

CechaNiegrupowanePołączona
WdrażanieModel jest pobierany dynamicznie przez Usługi Google Play.Statyczny model jest połączony z aplikacją w czasie kompilowania.
Rozmiar aplikacjiPowiększenie o około 600 KB.Zwiększył się o około 3,2 MB.
Czas inicjowaniaZanim zaczniesz korzystać z modelu, może minąć trochę czasu.Model jest dostępny od razu.

Zanim zaczniesz

  1. W pliku build.gradle na poziomie projektu umieść repozytorium Google Maven w sekcjach buildscript i allprojects.

  2. Dodaj zależności do bibliotek ML Kit na Androida do pliku Gradle na poziomie aplikacji, który zwykle wynosi app/build.gradle. W zależności od potrzeb wybierz jedną z tych zależności:

    Aby połączyć model z aplikacją:

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

    Aby korzystać z modelu w Usługach Google Play:

    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. Jeśli zdecydujesz się używać modelu w Usługach Google Play, możesz skonfigurować aplikację tak, aby po zainstalowaniu aplikacji ze Sklepu Play była ona automatycznie pobierana na urządzenie. Aby to zrobić, dodaj tę deklarację do pliku AndroidManifest.xml aplikacji:

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

    Możesz też bezpośrednio sprawdzić dostępność modelu i poprosić o jego pobranie przy użyciu interfejsu ModuleInstallClient API w usługach Google Play.

    Jeśli nie włączysz pobierania modeli w czasie instalacji lub nie zezwolisz na pobieranie danych bez wyraźnego pobierania, model zostanie pobrany przy pierwszym uruchomieniu skanera. Prośby przesłane przed zakończeniem pobierania nie zwracają żadnych wyników.

Wytyczne dotyczące obrazu wejściowego

  • Aby pakiet ML Kit mógł dokładnie odczytywać kody kreskowe, obrazy wejściowe muszą zawierać kody reprezentatywne dla wystarczającej ilości danych pikselowych.

    Konkretne wymagania dotyczące danych piksela zależą od typu kodu kreskowego i ilości danych zakodowanych w nim, bo wiele kodów obsługuje ładunki o zmiennej wielkości. Minimalna najmniejsza istotna jednostka kodu kreskowego powinna mieć co najmniej 2 piksele szerokości, a w przypadku kodów 2-wymiarowych – 2 piksele wysokości.

    Na przykład kody EAN-13 składają się z pasków i pokoi o szerokości 1, 2, 3 lub 4 jednostek, więc obraz paskowy EAN-13 ma idealny rozmiar co najmniej 2, 4, 6 i 8 pikseli. Kod kreskowy EAN-13 ma łącznie 95 jednostek szerokości, dlatego powinien mieć co najmniej 190 pikseli szerokości.

    Formaty dengi, takie jak PDF417, potrzebują większego rozmiaru piksela, by ML Kit mógł je prawidłowo odczytać. Na przykład kod PDF417 może mieć do 34 szerokości 17 jednostek (w jednym wierszu), który powinien mieć co najmniej 1156 pikseli.

  • Niska ostrość obrazu może mieć wpływ na dokładność skanowania. Jeśli aplikacja nie uzyskuje oczekiwanych wyników, poproś użytkownika, aby zrobił to ponownie.

  • W przypadku typowych aplikacji zalecamy korzystanie z obrazów o wyższej rozdzielczości, takich jak 1280 x 720 lub 1920 x 1080, które pozwalają na skanowanie kodów kreskowych z dalszej odległości od aparatu.

    W aplikacjach, w których czas oczekiwania ma kluczowe znaczenie, możesz poprawić wydajność, przechwytując obrazy w niższej rozdzielczości, ale wymagając, aby kod kreskowy stanowił większość obrazu wejściowego. Zapoznaj się też ze wskazówkami dotyczącymi zwiększania wydajności w czasie rzeczywistym.

1. Konfigurowanie skanera kodów paskowych

Jeśli wiesz, które formaty kodów kreskowych chcesz odczytać, możesz zwiększyć szybkość wykrywania kodu kreskowego, konfigurując go tylko do wykrywania.

Aby na przykład wykrywać tylko kod Aztec i kody QR, utwórz obiekt BarcodeScannerOptions jak w tym przykładzie:

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();

Obsługiwane są te formaty:

  • Kod 128 (FORMAT_CODE_128)
  • Kod 39 (FORMAT_CODE_39)
  • Kod 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)
  • Kod QR (FORMAT_QR_CODE)
  • PDF417 (FORMAT_PDF417)
  • Aztek (FORMAT_AZTEC)
  • Tablica danych (FORMAT_DATA_MATRIX)

2. Przygotowanie obrazu wejściowego

Aby rozpoznawać kody kreskowe na obrazie, utwórz obiekt InputImage z tablicy Bitmap, media.Image, ByteBuffer, tablicy bajtów lub pliku na urządzeniu. Następnie przekaż obiekt InputImage do metody process i BarcodeScanner.

Obiekt InputImage możesz utworzyć z różnych źródeł, a każde z nich opisano poniżej.

Używanie modułu media.Image

Aby utworzyć obiekt InputImage z obiektu media.Image, na przykład podczas robienia obrazu z aparatu urządzenia, przekaż obiekt media.Image, a obraz zostanie obrócony do InputImage.fromMediaImage().

Jeśli używasz biblioteki KameraX, klasy OnImageCapturedListener i ImageAnalysis.Analyzer obliczają wartość rotacji.

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

Jeśli nie używasz biblioteki zdjęć, która zapewnia kąt obrotu obrazu, możesz go obliczyć na podstawie stopni obrotu urządzenia i orientacji czujnika aparatu w tym urządzeniu:

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

Następnie prześlij obiekt media.Image i wartość stopni obrotu do InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

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

Używanie identyfikatora URI pliku

Aby utworzyć obiekt InputImage z identyfikatora URI pliku, przekaż kontekst aplikacji i identyfikator pliku do InputImage.fromFilePath(). Ta opcja jest przydatna, gdy używasz intencji ACTION_GET_CONTENT zachęcającej użytkownika do wybrania zdjęcia z galerii.

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

Korzystanie z narzędzia ByteBuffer lub ByteArray

Aby utworzyć obiekt InputImage z ByteBuffer lub ByteArray, najpierw oblicz stopień obrotu obrazu, jak opisano wcześniej w przypadku danych wejściowych media.Image. Następnie utwórz obiekt InputImage z buforem lub tablicą wraz z wysokością, szerokością, formatem kodowania kolorów i stopniem obrotu:

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

Używanie modułu Bitmap

Aby utworzyć obiekt InputImage z obiektu Bitmap, złóż tę deklarację:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

Obraz jest reprezentowany przez obiekt Bitmap wraz z stopniami obrotu.

3. Pobranie instancji BarcodeScanner

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. Przetwórz obraz

Przekaż obraz do metody 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. Uzyskaj informacje z kodów kreskowych

Jeśli operacja rozpoznawania kodu kreskowego się powiedzie, lista obiektów Barcode zostanie przekazana do detektora powodzenia. Każdy obiekt Barcode reprezentuje kod kreskowy wykryty na obrazie. W przypadku każdego kodu kreskowego możesz uzyskać współrzędne jego obszaru na obrazie wejściowych, a także nieprzetworzone dane zakodowane w kodzie kreskowym. Jeśli skaner kodów paskowych wykryje typ danych zakodowanych w kodzie kreskowym, możesz otrzymać obiekt zawierający przeanalizowane dane.

Przykład:

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

Wskazówki, jak poprawić skuteczność w czasie rzeczywistym

Jeśli chcesz skanować kody kreskowe w aplikacji w czasie rzeczywistym, postępuj zgodnie z tymi wskazówkami, aby uzyskać najlepszą liczbę klatek na sekundę:

  • Nie przechwytuj danych wejściowych w natywnej rozdzielczości kamery. Na niektórych urządzeniach robienie zdjęć w natywnej rozdzielczości jest bardzo duże (co najmniej 10 megapikseli), co skutkuje bardzo krótkim czasem oczekiwania bez utraty dokładności. Wystarczy, że poprosisz o rozmiar z kamery, który będzie wymagany do wykrywania kodu kreskowego (zazwyczaj nie więcej niż 2 megapiksele).

    Jeśli szybkość skanowania jest ważna, możesz jeszcze bardziej zmniejszyć rozdzielczość przechwytywania obrazów. Pamiętaj jednak o minimalnych wymaganiach dotyczących kodu kreskowego opisanych powyżej.

    Jeśli próbujesz rozpoznać kody kreskowe z sekwencji ramek do strumieniowej transmisji wideo, mechanizm rozpoznawania może generować różne wyniki z poszczególnych klatek. Zaczekaj, aż otrzymasz kolejną serię danych o tej samej wartości, aby mieć pewność, że zwracasz dobry wynik.

    Suma kontrolna nie jest obsługiwana w przypadku kodów ITF i CODE-39.

  • Jeśli używasz interfejsu Camera lub camera2 API, ograniczaj wywołania wzorca do wykrywania treści. Jeśli podczas działania wzorca do wykrywania treści dostępna jest nowa ramka wideo, upuść ją. Przykład znajdziesz w klasie VisionProcessorBase w przykładowej aplikacji.
  • Jeśli korzystasz z interfejsu API CameraX, upewnij się, że strategia ciśnienia wstecznego jest ustawiona na wartość domyślną ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Zapewnia to tylko jeden obraz naraz. Jeśli w analizatorze będzie dużo więcej obrazów, to będą one automatycznie usuwane i nie będą umieszczane w kolejce. Po zamknięciu analizujemy obraz, wywołując polecenie ImageProxy.close(). Następny obraz jest wyświetlany.
  • Jeśli używasz danych wyjściowych wzorca do nakładania grafiki na obraz wejściowy, najpierw uzyskaj wynik z ML Kit, a następnie wyrenderuj obraz i nakładkę w jednym kroku. W przypadku każdej klatki wejściowej jest ona renderowana tylko raz na ekranie. Przykład znajdziesz w klasach CameraSourcePreview i GraphicOverlay w przykładowej aplikacji.
  • Jeśli używasz interfejsu Camera2 API, zrób zdjęcia w formacie ImageFormat.YUV_420_888. Jeśli używasz starszego interfejsu API aparatu, zrób zdjęcia w formacie ImageFormat.NV21.