Memindai kode batang dengan ML Kit di Android

Anda dapat menggunakan ML Kit untuk mengenali dan mendekode kode batang.

FiturTidak DipaketkanPaket
PenerapanModel didownload secara dinamis melalui Layanan Google Play.Model ditautkan secara statis ke aplikasi Anda pada waktu build.
Ukuran aplikasiUkuran bertambah sekitar 200 KB.Peningkatan ukuran sekitar 2,4 MB.
Waktu inisialisasiMungkin harus menunggu model didownload sebelum penggunaan pertama.Model akan segera tersedia.

Cobalah

Sebelum memulai

  1. Dalam file build.gradle level project, pastikan Anda menyertakan repositori Maven Google di bagian buildscript dan allprojects.

  2. Tambahkan dependensi untuk library Android ML Kit ke file gradle level aplikasi modul Anda, biasanya app/build.gradle. Pilih salah satu dependensi berikut berdasarkan kebutuhan Anda:

    Untuk memaketkan model dengan aplikasi Anda:

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

    Untuk menggunakan model di Layanan 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.3.0'
    }
    
  3. Jika memilih untuk menggunakan model ini di Layanan Google Play, Anda dapat mengonfigurasi aplikasi agar otomatis mendownload model ke perangkat setelah aplikasi diinstal dari Play Store. Untuk melakukannya, tambahkan deklarasi berikut ke file AndroidManifest.xml aplikasi Anda:

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

    Anda juga dapat secara eksplisit memeriksa ketersediaan model dan meminta download melalui ModuleInstallClient API layanan Google Play.

    Jika Anda tidak mengaktifkan download model waktu-instal atau meminta download eksplisit, model akan didownload saat pertama kali Anda menjalankan pemindai. Permintaan yang Anda buat sebelum download selesai tidak memberikan hasil apa pun.

Panduan gambar input

  • Agar ML Kit dapat secara akurat membaca kode batang, gambar input harus berisi kode batang yang diwakili oleh data piksel yang memadai.

    Persyaratan data piksel spesifik bergantung pada jenis kode batang dan jumlah data yang dienkode di dalamnya, karena banyak kode batang mendukung payload ukuran variabel. Secara umum, unit terkecil yang bermakna dari kode batang harus berukuran lebar minimal 2 piksel, dan untuk kode 2 dimensi, tingginya minimal 2 piksel.

    Sebagai contoh, kode batang EAN-13 terdiri dari batang dan spasi dengan lebar 1, 2, 3, atau 4 unit, sehingga gambar kode batang EAN-13 idealnya memiliki batang dan spasi dengan lebar minimal 2, 4, 6, dan 8 piksel. Karena total lebar kode batang EAN-13 adalah 95 unit, kode batang harus berukuran lebar setidaknya 190 piksel.

    Format yang lebih padat, seperti PDF417, memerlukan dimensi piksel yang lebih besar agar ML Kit dapat membacanya dengan andal. Misalnya, kode PDF417 dapat memiliki hingga 34 "kata" dengan lebar unit 17 dalam satu baris, yang idealnya berukuran lebar minimal 1156 piksel.

  • Fokus gambar yang buruk dapat memengaruhi akurasi pemindaian. Jika aplikasi tidak memperoleh hasil yang dapat diterima, minta pengguna untuk mengambil ulang gambar.

  • Untuk aplikasi standar, sebaiknya berikan gambar dengan resolusi lebih tinggi, seperti 1280x720 atau 1920x1080, agar kode batang dapat dipindai dari jarak yang lebih jauh dari kamera.

    Namun, dalam aplikasi yang sangat mementingkan latensi, Anda dapat meningkatkan performa dengan mengambil gambar pada resolusi yang lebih rendah, tetapi kode batang harus menjadi bagian terbesar dari gambar input. Lihat juga Tips untuk meningkatkan performa real-time.

1. Mengonfigurasi pemindai kode batang

Jika Anda mengetahui format kode batang yang ingin dibaca, Anda dapat meningkatkan kecepatan detektor kode batang dengan mengonfigurasinya untuk mendeteksi format tersebut.

Misalnya untuk hanya mendeteksi kode Aztec dan QR, buat objek BarcodeScannerOptions seperti pada contoh berikut:

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

Format berikut ini didukung:

  • Kode 128 (FORMAT_CODE_128)
  • Kode 39 (FORMAT_CODE_39)
  • Kode 93 (FORMAT_CODE_93)
  • Kodabar (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)
  • Kode QR (FORMAT_QR_CODE)
  • PDF417 (FORMAT_PDF417)
  • Aztec (FORMAT_AZTEC)
  • Matriks Data (FORMAT_DATA_MATRIX)

Mulai dari model paket 17.1.0 dan model 18.2.0 yang tidak dipaketkan, Anda juga dapat memanggil enableAllPotentialBarcodes() untuk menampilkan semua potensi kode batang meskipun kode tersebut tidak dapat didekode. Hal ini dapat digunakan untuk memfasilitasi deteksi lebih lanjut, misalnya dengan memperbesar kamera untuk mendapatkan gambar kode batang yang lebih jelas di kotak pembatas yang ditampilkan.

Kotlin

val options = BarcodeScannerOptions.Builder()
        .setBarcodeFormats(...)
        .enableAllPotentialBarcodes() // Optional
        .build()

Java

BarcodeScannerOptions options =
        new BarcodeScannerOptions.Builder()
        .setBarcodeFormats(...)
        .enableAllPotentialBarcodes() // Optional
        .build();

Further on, starting from bundled library 17.2.0 and unbundled library 18.3.0, a new feature called auto-zoom has been introduced to further enhance the barcode scanning experience. With this feature enabled, the app is notified when all barcodes within the view are too distant for decoding. As a result, the app can effortlessly adjust the camera's zoom ratio to the recommended setting provided by the library, ensuring optimal focus and readability. This feature will significantly enhance the accuracy and success rate of barcode scanning, making it easier for apps to capture information precisely.

To enable auto-zooming and customize the experience, you can utilize the setZoomSuggestionOptions() method along with your own ZoomCallback handler and desired maximum zoom ratio, as demonstrated in the code below.

Kotlin

val options = BarcodeScannerOptions.Builder()
        .setBarcodeFormats(...)
        .setZoomSuggestionOptions(
            new ZoomSuggestionOptions.Builder(zoomCallback)
                .setMaxSupportedZoomRatio(maxSupportedZoomRatio)
                .build()) // Optional
        .build()

Java

BarcodeScannerOptions options =
        new BarcodeScannerOptions.Builder()
        .setBarcodeFormats(...)
        .setZoomSuggestionOptions(
            new ZoomSuggestionOptions.Builder(zoomCallback)
                .setMaxSupportedZoomRatio(maxSupportedZoomRatio)
                .build()) // Optional
        .build();

zoomCallback is required to be provided to handle whenever the library suggests a zoom should be performed and this callback will always be called on the main thread.

The following code snippet shows an example of defining a simple callback.

Kotlin

fun setZoom(ZoomRatio: Float): Boolean {
    if (camera.isClosed()) return false
    camera.getCameraControl().setZoomRatio(zoomRatio)
    return true
}

Java

boolean setZoom(float zoomRatio) {
    if (camera.isClosed()) {
        return false;
    }
    camera.getCameraControl().setZoomRatio(zoomRatio);
    return true;
}

maxSupportedZoomRatio is related to the camera hardware, and different camera libraries have different ways to fetch it (see the javadoc of the setter method). In case this is not provided, an unbounded zoom ratio might be produced by the library which might not be supported. Refer to the setMaxSupportedZoomRatio() method introduction to see how to get the max supported zoom ratio with different Camera libraries.

When auto-zooming is enabled and no barcodes are successfully decoded within the view, BarcodeScanner triggers your zoomCallback with the requested zoomRatio. If the callback correctly adjusts the camera to this zoomRatio, it is highly probable that the most centered potential barcode will be decoded and returned.

A barcode may remain undecodable even after a successful zoom-in. In such cases, BarcodeScanner may either invoke the callback for another round of zoom-in until the maxSupportedZoomRatio is reached, or provide an empty list (or a list containing potential barcodes that were not decoded, if enableAllPotentialBarcodes() was called) to the OnSuccessListener (which will be defined in step 4. Process the image).

2. Prepare the input image

To recognize barcodes in an image, create an InputImage object from either a Bitmap, media.Image, ByteBuffer, byte array, or a file on the device. Then, pass the InputImage object to the BarcodeScanner's process method.

You can create an InputImage object from different sources, each is explained below.

Using a media.Image

To create an InputImage object from a media.Image object, such as when you capture an image from a device's camera, pass the media.Image object and the image's rotation to InputImage.fromMediaImage().

If you use the CameraX library, the OnImageCapturedListener and ImageAnalysis.Analyzer classes calculate the rotation value for you.

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

Jika Anda tidak menggunakan library kamera yang memberi derajat rotasi gambar, Anda dapat menghitungnya dari derajat rotasi perangkat dan orientasi sensor kamera pada perangkat:

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

Kemudian, teruskan objek media.Image dan nilai derajat rotasi ke InputImage.fromMediaImage():

Kotlin

val image = InputImage.fromMediaImage(mediaImage, rotation)

Java

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

Menggunakan URI file

Untuk membuat objek InputImage dari URI file, teruskan konteks aplikasi dan URI file ke InputImage.fromFilePath(). Hal ini berguna saat Anda menggunakan intent ACTION_GET_CONTENT untuk meminta pengguna memilih gambar dari aplikasi galeri mereka.

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

Menggunakan ByteBuffer atau ByteArray

Untuk membuat objek InputImage dari ByteBuffer atau ByteArray, pertama-tama hitung derajat rotasi gambar seperti yang dijelaskan sebelumnya untuk input media.Image. Kemudian, buat objek InputImage dengan buffer atau array, beserta tinggi, lebar, format encoding warna, dan derajat rotasi gambar:

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

Menggunakan Bitmap

Untuk membuat objek InputImage dari objek Bitmap, buat deklarasi berikut:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)

Java

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

Gambar direpresentasikan oleh objek Bitmap bersama dengan derajat rotasi.

3. Mendapatkan instance 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. Memproses gambar

Teruskan gambar ke metode 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. Mendapatkan informasi dari kode batang

Jika operasi pengenalan kode batang berhasil, daftar objek Barcode akan diteruskan ke pemroses peristiwa sukses. Setiap objek Barcode mewakili kode batang yang terdeteksi dalam gambar. Untuk setiap kode batang, Anda bisa mendapatkan koordinat pembatasnya di gambar input, serta data mentah yang dienkode oleh kode batang. Selain itu, jika pemindai kode batang dapat menentukan jenis data yang dienkode oleh kode batang, Anda bisa mendapatkan objek yang berisi data yang telah terurai.

Contoh:

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

Tips untuk meningkatkan performa real-time

Jika ingin memindai kode batang dalam aplikasi real-time, ikuti pedoman ini untuk mencapai kecepatan frame terbaik:

  • Jangan ambil input dalam resolusi native kamera. Pada beberapa perangkat, pengambilan input pada resolusi native akan menghasilkan gambar yang sangat besar (10+ megapiksel), yang menghasilkan latensi yang sangat rendah tanpa meningkatkan akurasi. Sebagai gantinya, hanya minta ukuran dari kamera yang diperlukan untuk deteksi kode batang, yang biasanya tidak lebih dari 2 megapiksel.

    Jika kecepatan pemindaian penting, Anda dapat menurunkan resolusi pengambilan gambar lebih lanjut. Namun, perhatikan persyaratan ukuran kode batang minimum yang diuraikan di atas.

    Jika Anda mencoba mengenali kode batang dari urutan frame video streaming, pengenal mungkin memberikan hasil yang berbeda dari satu frame ke frame lainnya. Anda harus menunggu sampai mendapatkan serangkaian nilai yang sama berturut-turut untuk yakin bahwa Anda menampilkan hasil yang baik.

    Digit Checksum tidak didukung untuk ITF dan CODE-39.

  • Jika Anda menggunakan Camera atau camera2 API, throttle panggilan ke detektor. Jika frame video baru tersedia saat detektor sedang berjalan, hapus frame tersebut. Lihat class VisionProcessorBase di aplikasi contoh panduan memulai untuk mengetahui contohnya.
  • Jika Anda menggunakan CameraX API, pastikan strategi backpressure disetel ke nilai defaultnya ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. Hal ini menjamin hanya satu gambar yang akan dikirimkan untuk analisis dalam satu waktu. Jika lebih banyak gambar dihasilkan saat analyzer sibuk, gambar tersebut akan otomatis dihapus dan tidak dimasukkan dalam antrean untuk dikirim. Setelah gambar yang dianalisis ditutup dengan memanggil ImageProxy.close(), gambar terbaru berikutnya akan dikirimkan.
  • Jika Anda menggunakan output detektor untuk menempatkan grafis pada gambar input, pertama-tama dapatkan hasilnya dari ML Kit, lalu render gambar dan tempatkan grafis dalam satu langkah. Tindakan ini hanya dirender ke permukaan tampilan sekali untuk setiap frame input. Lihat class CameraSourcePreview dan GraphicOverlay dalam aplikasi contoh panduan memulai untuk mengetahui contohnya.
  • Jika Anda menggunakan Camera2 API, ambil gambar dalam format ImageFormat.YUV_420_888. Jika Anda menggunakan Camera API versi lama, ambil gambar dalam format ImageFormat.NV21.