ZXing Android Studio: Barcode & QR Code Scanning Guide

Oct 30, 2025 by Jhon Lennon 55 views

Hey guys! Want to integrate barcode or QR code scanning into your Android app using ZXing in Android Studio? You've come to the right place. This comprehensive guide will walk you through everything you need to know, from setting up your project to decoding those complex codes. Get ready to dive in and supercharge your app with barcode and QR code reading capabilities!

What is ZXing?

First things first, let's get acquainted with ZXing. ZXing, short for "Zebra Crossing", is an open-source, multi-format 1D/2D barcode image processing library. Think of it as your trusty sidekick for all things barcode and QR code related. It's versatile, supporting a wide range of barcode formats like QR Code, Data Matrix, UPC, EAN, Code 128, and many more. This makes it an ideal choice for Android developers looking to add scanning functionality to their apps.

Why should you care about ZXing? Well, integrating barcode and QR code scanning can open up a world of possibilities for your app. Imagine users being able to scan a QR code to quickly access a website, retrieve product information, or even make payments. The possibilities are virtually endless. Plus, ZXing is free to use, which is always a bonus!

ZXing's architecture is designed to be modular and extensible. It consists of several key components, including barcode readers, image processing algorithms, and encoding/decoding logic. This modularity allows developers to easily customize and extend the library to meet their specific needs. For example, you can create custom barcode formats or integrate ZXing with other image processing libraries.

Another cool thing about ZXing is its cross-platform compatibility. While we're focusing on Android here, ZXing is also available for other platforms like Java, iOS, and C++. This means you can reuse your knowledge and skills across different projects, saving you time and effort. Whether you're building an Android app, a web application, or a desktop application, ZXing has you covered.

Setting Up Your Android Studio Project

Alright, let's get our hands dirty and set up an Android Studio project for ZXing integration. This part is crucial, so pay close attention!

Create a New Project: Open Android Studio and create a new project. Choose the "Empty Activity" template to start with a clean slate. Give your project a cool name like "BarcodeScannerApp" and select your preferred language (Java or Kotlin). I recommend Kotlin, but it's up to you!
Add Dependencies: Next, we need to add the ZXing Android integration library to our project. Open your build.gradle file (Module: app) and add the following dependency to the dependencies block:
```
dependencies {
    implementation 'com.journeyapps:zxing-android-embedded:4.3.0'
}
```
Make sure to sync your project after adding the dependency. This will download the necessary ZXing libraries and make them available to your project. Without this step, you won't be able to use any of the ZXing classes or methods.
Add Permissions: To access the device's camera, you'll need to add the CAMERA permission to your AndroidManifest.xml file. Open the manifest file and add the following line before the application tag:
```
<uses-permission android:name="android.permission.CAMERA" />
```
Don't forget this step! If you don't add the camera permission, your app won't be able to access the camera, and the barcode scanner won't work. Android requires explicit permission from the user to access sensitive hardware like the camera, so you need to declare this permission in your manifest file.
Configure ProGuard (Optional): If you're using ProGuard to shrink and obfuscate your code, you may need to add some rules to prevent ProGuard from stripping out ZXing-related classes. Create a new file named proguard-rules.pro in your app module and add the following lines:
```
-keep class com.google.zxing.** { *; }
-keep class com.journeyapps.barcodescanner.** { *; }
```
These rules tell ProGuard to keep all classes in the com.google.zxing and com.journeyapps.barcodescanner packages. This is important because ProGuard might otherwise remove these classes, causing your barcode scanner to fail at runtime. ProGuard is a powerful tool for optimizing your code, but it can sometimes be a bit too aggressive, so it's important to configure it carefully.

Implementing the Barcode Scanner

Now for the fun part: implementing the barcode scanner in your app! We'll use the ZXingScannerView class from the zxing-android-embedded library to simplify the process. This class provides a pre-built view that handles camera preview, barcode detection, and decoding.

Add ZXingScannerView to Your Layout: Open your activity's layout file (e.g., activity_main.xml) and add a ZXingScannerView to the layout. You can either add it directly in the XML or programmatically in your activity's code. Here's an example of adding it in the XML:
```
<com.journeyapps.barcodescanner.ZXingScannerView
    android:id="@+id/zxing_scanner"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />
```
Make sure to give the ZXingScannerView an ID so you can reference it in your activity's code. The layout_width and layout_height attributes determine the size of the scanner view. In this example, we're making it fill the entire screen, but you can adjust these values to fit your specific layout requirements.

Implement the Result Handler: In your activity, implement the ZXingScannerView.ResultHandler interface. This interface has a single method, handleResult, which is called when a barcode is successfully decoded. This is where you'll process the scanned barcode data.

public class MainActivity extends AppCompatActivity implements ZXingScannerView.ResultHandler {
    private ZXingScannerView mScannerView;

    @Override
    public void onCreate(Bundle state) {
        super.onCreate(state);
        mScannerView = new ZXingScannerView(this);
        setContentView(mScannerView);
    }

    @Override
    public void onResume() {
        super.onResume();
        mScannerView.setResultHandler(this);
        mScannerView.startCamera();
    }

    @Override
    public void onPause() {
        super.onPause();
        mScannerView.stopCamera();
    }

    @Override
    public void handleResult(Result rawResult) {
        // Do something with the result here
        Log.v("TAG", rawResult.getText()); // Prints scan results
        Log.v("TAG", rawResult.getBarcodeFormat().toString()); // Prints the scan format (qrcode, pdf417 etc.)

        // If you would like to resume scanning, call this method below:
        mScannerView.resumeCameraPreview(this);
    }
}

In this example, we're creating a ZXingScannerView programmatically and setting it as the content view of the activity. We're also setting the ResultHandler to the activity itself, so the handleResult method will be called when a barcode is scanned. The onResume and onPause methods are used to start and stop the camera, respectively. This ensures that the camera is only active when the activity is in the foreground.

Start and Stop the Camera: In the onResume method of your activity, start the camera by calling mScannerView.startCamera(). In the onPause method, stop the camera by calling mScannerView.stopCamera(). This is important to release the camera resources when the activity is not visible.
Handle the Result: In the handleResult method, you can access the scanned barcode data using the rawResult.getText() method. You can also get the barcode format using the rawResult.getBarcodeFormat() method. Do whatever you want with the data – display it in a TextView, send it to a server, or use it to perform some other action.

Customizing the Scanner View

The ZXingScannerView class offers several options for customizing the appearance and behavior of the scanner view. You can change the laser color, the mask color, the aspect ratio, and more.

Setting the Laser Color: To change the laser color, use the setLaserColor method. For example, to set the laser color to red, you can use the following code:
```
mScannerView.setLaserColor(Color.RED);
```
Setting the Mask Color: To change the mask color, use the setMaskColor method. For example, to set the mask color to black with 50% transparency, you can use the following code:
```
mScannerView.setMaskColor(Color.argb(128, 0, 0, 0));
```
Setting the Aspect Ratio: To set the aspect ratio of the scanner view, use the setAspectTolerance method. This method takes a float value between 0.0 and 1.0, where 0.0 means no tolerance and 1.0 means maximum tolerance. For example, to set the aspect ratio tolerance to 0.5, you can use the following code:
```
mScannerView.setAspectTolerance(0.5f);
```
Other Customization Options: The ZXingScannerView class also provides other customization options, such as setting the auto-focus interval, enabling or disabling flash, and setting the barcode formats to scan for. Refer to the ZXing Android Embedded documentation for more details.

Alternative: Using Intent Integrator

For a simpler approach, you can use the IntentIntegrator class from the zxing-android-embedded library. This class provides a convenient way to launch the barcode scanner as a separate activity and retrieve the result. It's like calling another app to do the scanning for you.

Launch the Scanner: To launch the scanner using IntentIntegrator, create an instance of the class and call the initiateScan() method. You can also customize the scanner's behavior by calling methods like setDesiredBarcodeFormats(), setPrompt(), and setCameraId().
```
IntentIntegrator integrator = new IntentIntegrator(this);
integrator.setDesiredBarcodeFormats(IntentIntegrator.QR_CODE);
integrator.setPrompt("Scan a QR code");
integrator.setCameraId(0);  // Use a specific camera of the device
integrator.setBeepEnabled(false); // Disable beep
integrator.setBarcodeImageEnabled(true);
integrator.initiateScan();
```
This code launches the barcode scanner with the following settings: only scan for QR codes, display the prompt "Scan a QR code", use the default camera, disable the beep sound, and enable the barcode image. The initiateScan() method starts the scanning process.

Handle the Result: To handle the result of the scan, override the onActivityResult method in your activity. Check if the request code is IntentIntegrator.REQUEST_CODE and process the result accordingly.

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    IntentResult result = IntentIntegrator.parseActivityResult(requestCode, resultCode, data);
    if(result != null) {
        if(result.getContents() == null) {
            Log.d("MainActivity", "Cancelled scan");
            Toast.makeText(this, "Cancelled", Toast.LENGTH_LONG).show();
        } else {
            Log.d("MainActivity", "Scanned: " + result.getContents());
            Toast.makeText(this, "Scanned: " + result.getContents(), Toast.LENGTH_LONG).show();
        }
    } else {
        super.onActivityResult(requestCode, resultCode, data);
    }
}

This code parses the result of the scan using the IntentIntegrator.parseActivityResult() method. If the result is not null, it checks if the scan was cancelled or if a barcode was successfully scanned. If a barcode was scanned, it displays the scanned data in a Toast message.

Troubleshooting Common Issues

Even with the best guides, things can sometimes go wrong. Here are some common issues you might encounter when integrating ZXing into your Android app, and how to fix them:

Camera Permission Denied: If your app doesn't have the CAMERA permission, the barcode scanner won't work. Make sure you've added the <uses-permission android:name="android.permission.CAMERA" /> line to your AndroidManifest.xml file. Also, on Android 6.0 (API level 23) and higher, you need to request the permission at runtime using the ActivityCompat.requestPermissions() method.
Barcode Not Detected: If the barcode scanner is not detecting barcodes, make sure the camera is focused and the barcode is well-lit. Also, try adjusting the setAspectTolerance() method to improve the scanner's ability to detect barcodes with different aspect ratios. Sometimes, the barcode might be damaged or poorly printed, making it difficult to scan.
ClassNotFoundException: If you're getting a ClassNotFoundException for ZXing-related classes, make sure you've added the ZXing Android Embedded dependency to your build.gradle file and synced your project. Also, if you're using ProGuard, make sure you've added the necessary rules to prevent ProGuard from stripping out ZXing classes.
Camera Preview Not Displaying: If the camera preview is not displaying, make sure you're starting and stopping the camera in the onResume and onPause methods of your activity, respectively. Also, check if there are any other apps using the camera at the same time. Only one app can use the camera at a time, so if another app is using it, your app won't be able to access it.

Conclusion

And there you have it! You've successfully integrated ZXing into your Android app and can now scan barcodes and QR codes like a pro. Whether you choose to use the ZXingScannerView class or the IntentIntegrator class, ZXing provides a powerful and flexible solution for adding scanning functionality to your app. So go ahead, experiment with different customization options, and create an awesome barcode scanning experience for your users!

Remember, practice makes perfect. The more you work with ZXing, the more comfortable you'll become with its features and capabilities. So don't be afraid to experiment and try new things. And if you ever get stuck, there's a wealth of information available online, including the official ZXing documentation, Stack Overflow, and various Android development forums. Happy scanning!