ZXing Android Studio: Barcode & QR Code Scanning Guide

Oct 30, 2025 by Jhon Lennon 55 views

Hey guys! Are you looking to integrate barcode or QR code scanning functionality into your Android app using ZXing in Android Studio? You've landed in the right place! This comprehensive guide will walk you through everything you need to know, from setting up the ZXing library to implementing a fully functional scanner in your app. Let's dive in!

What is ZXing?

First off, let's clarify what ZXing actually is. ZXing, short for "Zebra Crossing," is an open-source, multi-format 1D/2D barcode image processing library. It's available for multiple platforms, including Java, Android, C++, and more. In our case, we're focusing on using it within Android Studio to empower our apps with barcode and QR code reading capabilities. ZXing handles the complex image processing required to decode these codes, so you don't have to reinvent the wheel. Using ZXing saves development time and ensures reliability, leveraging years of community-driven improvements and optimizations.

Why Use ZXing in Your Android App?

Adding barcode and QR code scanning to your Android app can open up a world of possibilities. Think about it: scanning product barcodes for instant information, reading QR codes for quick website links or promotional offers, or even implementing your own inventory management system. It streamlines processes, enhances user experience, and provides a modern, efficient way to interact with the physical world. Imagine users scanning a QR code on a poster to instantly access event details or scanning a product's barcode to read reviews before making a purchase. The applications are limitless, making ZXing a valuable asset for any Android developer.

Here are some compelling reasons to integrate ZXing into your Android projects:

Efficiency: Quick and accurate scanning of barcodes and QR codes.
User Experience: Streamlined access to information and functionality.
Versatility: Supports a wide range of barcode and QR code formats.
Open Source: Free to use and customize to your needs.
Community Support: Extensive documentation and community forums for assistance.

Setting Up ZXing in Android Studio

Okay, let's get our hands dirty! There are a couple of ways to set up ZXing in your Android Studio project. I'll cover two popular methods: using ZXing Android Embedded and using a direct dependency.

Method 1: Using ZXing Android Embedded

ZXing Android Embedded provides a simplified way to integrate scanning functionality with a pre-built Activity. It's great for quick setups and basic scanning needs. Here's how to do it:

Add the Dependency:

Open your build.gradle (Module: app) file and add the following dependency to the dependencies block:
```
dependencies {
    implementation 'com.journeyapps:zxing-android-embedded:4.3.0'
}
```
Make sure to sync your Gradle project after adding the dependency.

Initiate the Scan:

In your Activity or Fragment, add the following code to start the scanning process:

import com.journeyapps.barcodescanner.ScanContract;
import com.journeyapps.barcodescanner.ScanOptions;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.ActivityResultRegistry;
import androidx.activity.result.contract.ActivityResultContracts;

public class YourActivity extends AppCompatActivity {

    private ActivityResultLauncher<ScanOptions> barcodeLauncher;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_your);

        barcodeLauncher = registerForActivityResult(new ScanContract(),
                result -> {
                    if(result.getContents() == null) {
                        // Handle cancelled scan
                        Toast.makeText(this, "Cancelled", Toast.LENGTH_LONG).show();
                    } else {
                        // Handle successful scan
                        Toast.makeText(this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
                    }
                });

        // Start the scanning process
        ScanOptions options = new ScanOptions();
        options.setPrompt("Scan a barcode");
        options.setBeepEnabled(true);
        options.setOrientationLocked(false);
        barcodeLauncher.launch(options);
    }
}

This code snippet initializes the ScanOptions, sets configurations such as the prompt message and beep sound, and then launches the scanner using the barcodeLauncher. The result is handled in the registerForActivityResult callback, where you can process the scanned data or handle cancellations.

Permissions:

Ensure you have the necessary camera permissions in your AndroidManifest.xml:
```
<uses-permission android:name="android.permission.CAMERA"/>
```
Remember to request runtime permissions for Android 6.0 (API level 23) and higher.

Method 2: Using a Direct Dependency

For more control over the scanning UI and process, you can directly use the ZXing core library. This method requires a bit more setup but offers greater flexibility.

Add Core Dependency:

In your build.gradle (Module: app) file, add the core ZXing dependency:
```
dependencies {
    implementation 'com.google.zxing:core:3.5.2'
}
```
Sync your Gradle project.

Implement the Scanner View:

You'll need to create a custom SurfaceView to display the camera preview and handle the barcode decoding. This involves setting up the camera, processing frames, and using the ZXing MultiFormatReader to decode the barcode.

Here's a simplified example (note that this is a basic illustration and may require adjustments for your specific needs):

import android.content.Context;
import android.hardware.Camera;
import android.util.AttributeSet;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import com.google.zxing.BinaryBitmap;
import com.google.zxing.MultiFormatReader;
import com.google.zxing.NotFoundException;
import com.google.zxing.PlanarYUVLuminanceSource;
import com.google.zxing.Result;
import com.google.zxing.common.HybridBinarizer;

import java.io.IOException;

public class ScannerView extends SurfaceView implements SurfaceHolder.Callback, Camera.PreviewCallback {

    private SurfaceHolder mHolder;
    private Camera mCamera;
    private MultiFormatReader multiFormatReader;

    public ScannerView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mHolder = getHolder();
        mHolder.addCallback(this);

        multiFormatReader = new MultiFormatReader();
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        try {
            mCamera = Camera.open();
            mCamera.setDisplayOrientation(90); // Adjust orientation if needed
            mCamera.setPreviewDisplay(holder);
            mCamera.setPreviewCallback(this);
        } catch (IOException | RuntimeException e) {
            e.printStackTrace();
            // Handle camera initialization errors
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        if (mHolder.getSurface() == null){
            return;
        }

        try {
            mCamera.stopPreview();
        } catch (Exception e){
            // Ignore errors when preview doesn't exist
        }

        try {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();
        } catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        if (mCamera != null) {
            mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
        }
    }

    @Override
    public void onPreviewFrame(byte[] data, Camera camera) {
        Camera.Size size = camera.getParameters().getPreviewSize();
        int width = size.width;
        int height = size.height;

        PlanarYUVLuminanceSource source = new PlanarYUVLuminanceSource(
                data, width, height, 0, 0, width, height, false);
        BinaryBitmap bitmap = new BinaryBitmap(new HybridBinarizer(source));

        try {
            Result result = multiFormatReader.decode(bitmap);
            // Handle the decoded result
            if (result != null) {
                String barcodeText = result.getText();
                // Process the barcode text
            }
        } catch (NotFoundException e) {
            // Barcode not found in this frame
        }
    }
}

This ScannerView class handles the camera preview, frame processing, and barcode decoding. It uses the ZXing MultiFormatReader to attempt to decode barcodes from each frame captured by the camera. The onPreviewFrame method is where the barcode decoding logic resides, converting the camera data into a format that ZXing can understand.

Add to Layout:

Include the ScannerView in your Activity's layout:

<com.example.yourapp.ScannerView
    android:id="@+id/scanner_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

Permissions:

As with the previous method, ensure you have camera permissions in AndroidManifest.xml and handle runtime permissions.

Handling Scan Results

Once you've successfully scanned a barcode or QR code, you'll need to handle the result. The way you do this depends on which method you used.

With ZXing Android Embedded

The scanned data is available in the onActivityResult method. You can retrieve the data like this:

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
    if (result != null) {
        if (result.getContents() == null) {
            // Handle cancelled scan
            Toast.makeText(this, "Cancelled", Toast.LENGTH_LONG).show();
        } else {
            // Handle successful scan
            String scannedData = result.getContents();
            Toast.makeText(this, "Scanned: " + scannedData, Toast.LENGTH_LONG).show();
            // Do something with the scanned data
        }
    } else {
        super.onActivityResult(requestCode, resultCode, data);
    }
}

With Direct Dependency

In the ScannerView class (or wherever you're handling the onPreviewFrame callback), you'll have the decoded Result object. You can extract the barcode text using result.getText():

@Override
public void onPreviewFrame(byte[] data, Camera camera) {
    // ... (previous code) ...

    try {
        Result result = multiFormatReader.decode(bitmap);
        if (result != null) {
            String barcodeText = result.getText();
            // Process the barcode text
            // For example, display it in a TextView
            runOnUiThread(() -> {
                // Make sure to update UI elements on the main thread
                TextView resultTextView = findViewById(R.id.result_text_view);
                resultTextView.setText(barcodeText);
            });
        }
    } catch (NotFoundException e) {
        // Barcode not found in this frame
    }
}

Remember to update UI elements on the main thread using runOnUiThread to avoid NetworkOnMainThreadException.

Customizing the Scanner

ZXing offers several options for customizing the scanner to fit your app's design and functionality. Here are a few examples:

Setting Supported Formats:

You can specify which barcode formats the scanner should look for. This can improve performance and accuracy. For example, to only scan QR codes, you can configure the IntentIntegrator like this:
```
IntentIntegrator integrator = new IntentIntegrator(this);
integrator.setDesiredBarcodeFormats(IntentIntegrator.QR_CODE);
integrator.initiateScan();
```
Customizing the UI:

With the direct dependency method, you have full control over the scanner UI. You can add overlays, change the scanning area, and implement custom animations.

Beep Control:

You can enable or disable the beep sound that plays when a barcode is successfully scanned:

IntentIntegrator integrator = new IntentIntegrator(this);
integrator.setBeepEnabled(false); // Disable beep
integrator.initiateScan();

Troubleshooting Common Issues

Sometimes, things don't go as planned. Here are some common issues you might encounter and how to solve them:

Camera Permission Denied:

Make sure you have declared the camera permission in your AndroidManifest.xml and are requesting runtime permissions if you're targeting Android 6.0 or higher. Always handle the case where the user denies the permission.
Scanner Not Working on Some Devices:

This can be due to camera hardware differences or ZXing not supporting a particular barcode format. Try different devices and ensure you're supporting the necessary formats.
Decoding Issues:

If the scanner struggles to decode barcodes, try adjusting the camera focus, lighting conditions, and barcode distance. Also, ensure that the barcode is not damaged or obscured.

Conclusion

And there you have it! You've now learned how to integrate ZXing into your Android app using Android Studio. Whether you choose the simplicity of ZXing Android Embedded or the flexibility of the direct dependency, you're well-equipped to add powerful barcode and QR code scanning capabilities to your projects. Remember to test thoroughly on different devices and handle potential issues gracefully. Happy scanning!