ZXing In Android Studio: A Beginner's Guide

Oct 30, 2025 by Jhon Lennon 44 views

Hey guys! Ever wondered how to integrate barcode scanning and QR code reading capabilities into your Android apps? Well, you're in luck! This guide will walk you through implementing the ZXing (Zebra Crossing) library in Android Studio. ZXing is a super popular, open-source library that makes it easy to add barcode scanning to your projects. We'll cover everything from setting up your project to actually scanning those barcodes and QR codes. So, grab your Android Studio and let's get started. This will be an awesome journey for you, I'm sure of it.

Setting Up Your Android Studio Project for ZXing

Alright, first things first, let's get our Android Studio project ready. If you're new to Android development, don't sweat it; I'll guide you through each step. First, open Android Studio and create a new project. Choose an empty activity template to keep things simple. Give your project a cool name, something like "BarcodeScannerApp." Make sure you select Kotlin or Java as your programming language, depending on your preference. Now, here comes the magic: we need to add the ZXing library as a dependency. You'll do this by modifying your build.gradle (Module: app) file. This file is your project's command center for dependencies.

Open your build.gradle file (Module: app) and find the dependencies block. It usually looks something like this:

dependencies {
    implementation 'androidx.appcompat:appcompat:1.6.1'
    implementation 'com.google.android.material:material:1.11.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
}

Now, add the ZXing library to the dependencies. You can find the latest version on Maven Central or through a quick Google search. As of this writing, the latest version of core is 3.5.1. Add this line inside the dependencies block:

 implementation 'com.journeyapps:zxing-android-embedded:4.3.0'

After adding the dependency, sync your project. Click the "Sync Now" button that appears in the top right corner of Android Studio. Android Studio will then download the ZXing library and its dependencies, making them available to your project. Next, we have to add the necessary permissions to the AndroidManifest.xml file. This tells the Android system that your app needs to use the camera. Open the AndroidManifest.xml file, which is usually located in the app/manifests directory. Add the following permission right before the <application> tag:

<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" android:required="false" />
<uses-feature android:name="android.hardware.camera.autofocus" android:required="false" />

The <uses-feature> tags tell Android that your app can work even if the device doesn't have a camera or autofocus. These are not required, but they help with compatibility. That's it for the setup! Your project is now ready to use the ZXing library for barcode and QR code scanning. You've officially taken the first step toward building a barcode scanner app. Great job, and let's move on!

Implementing the Barcode Scanner Activity

Now for the fun part: let's create the barcode scanner activity. This is where the magic happens, where your app will use the camera to scan barcodes and QR codes. First, you'll need to create a new activity. You can do this by right-clicking on your app/java/your.package.name directory, selecting "New," and then "Activity." Choose an "Empty Activity" and give it a name, such as "ScannerActivity." Now, open the ScannerActivity.kt (or .java if you're using Java) file. We'll need to add a few things to this activity to handle the barcode scanning.

First, add the necessary imports at the top of your file. These imports bring in the classes we'll need from the ZXing library:

import android.content.Intent
import android.os.Bundle
import android.widget.Button
import android.widget.TextView
import androidx.appcompat.app.AppCompatActivity
import com.journeyapps.barcodescanner.ScanContract
import com.journeyapps.barcodescanner.ScanOptions

Next, let's create the UI for our ScannerActivity. Open the activity_scanner.xml layout file (or whatever you named your layout file). You'll need at least a button to start the scanning process and a TextView to display the scanned barcode or QR code contents. Here's a basic example:

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".ScannerActivity">

    <Button
        android:id="@+id/scanButton"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Scan Barcode/QR Code"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        android:layout_marginTop="16dp" />

    <TextView
        android:id="@+id/resultTextView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Scan Result:"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/scanButton"
        android:layout_marginTop="16dp" />

</androidx.constraintlayout.widget.ConstraintLayout>

Back in ScannerActivity.kt, you'll need to initialize the button and the TextView, and set up an OnClickListener for the button to start the scanning process. Add the following code inside the onCreate() method:

    private lateinit var scanButton: Button
    private lateinit var resultTextView: TextView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_scanner)

        scanButton = findViewById(R.id.scanButton)
        resultTextView = findViewById(R.id.resultTextView)

        scanButton.setOnClickListener {
            initiateScan()
        }
    }

Next, create the initiateScan() function. This function uses the ScanContract to start the barcode scanner activity:

    private val barcodeLauncher = registerForActivityResult(
        ScanContract())
    {
        result ->
        if (result.contents == null) {
            // Handle the case where the user cancelled the scan
            resultTextView.text = "Scan cancelled"
        } else {
            // Handle successful scan
            resultTextView.text = "Scan Result: ${result.contents}"
        }
    }

    private fun initiateScan() {
        val options = ScanOptions()
        options.setPrompt("Scan a barcode or QR code")
        options.setBeepEnabled(true)
        options.setOrientationLocked(false)
        barcodeLauncher.launch(options)
    }

This setup provides a user-friendly interface to trigger the scanning process and display the scanned result. This is a crucial step towards your barcode scanning app.

Running and Testing Your Barcode Scanner

Alright, guys, you've done the hard work, now it's time to see if your barcode scanner works! First, build and run your app on an Android emulator or a physical Android device. Make sure your device or emulator has a camera. If you are using an emulator, you might need to enable the camera in the emulator settings. Once the app is running, navigate to the ScannerActivity. You should see the button you created. Tap the "Scan Barcode/QR Code" button. This should open the barcode scanner activity, displaying a live view from your device's camera. Point your camera at a barcode or QR code. The scanner should automatically detect and read the code. If everything goes as planned, the scanned content will be displayed in the TextView below the button.

If you encounter any issues, here's a quick checklist:

Permissions: Double-check that you've added the CAMERA permission in your AndroidManifest.xml file. Also, ensure you have requested the permission at runtime (especially for Android 6.0 and higher). Remember that, starting from Android 6.0 (Marshmallow), you need to request runtime permissions. This means you need to ask the user for the camera permission when the app starts. You can use the ActivityCompat.requestPermissions() method for this. But for this tutorial, we will not cover it.
Dependencies: Make sure you've added the ZXing library dependency correctly in your build.gradle file (Module: app) and synced your project.
Layout: Verify that you've correctly set up the UI elements (button and TextView) in your layout file (activity_scanner.xml).
Camera Access: Ensure your device or emulator has a working camera, and that camera access is enabled in the emulator settings.
Error Messages: Pay close attention to any error messages in the Android Studio's logcat. They can often provide valuable clues about what went wrong.

If you're still having trouble, don't worry! Go back through the steps and double-check everything. Android development can be tricky, but with persistence, you'll get it working. After successfully testing your scanner, you can now integrate it into your other activities. Make the activity for the main screen, and include a button that points to the scanner activity. Now you can scan barcodes in the app.

Customizing Your Barcode Scanner

Alright, let's explore some ways to customize your barcode scanner. The ZXing library offers several options to tailor the scanner's behavior and appearance to fit your app's needs. First, you can customize the scan options. In the initiateScan() function, you can modify the ScanOptions object to change the scanner's behavior. Here are a few examples:

Prompt Text: You can change the prompt text that appears on the scanner screen. This is a helpful way to guide the user. Use options.setPrompt("Custom prompt text"). For example, you can set options.setPrompt("Please scan the product barcode") to give the user better instructions.
Beep Sound: You can enable or disable the beep sound that plays when a barcode is successfully scanned. Set options.setBeepEnabled(true) or options.setBeepEnabled(false).
Orientation Lock: You can lock the scanner's orientation to prevent it from rotating. Use options.setOrientationLocked(true) or options.setOrientationLocked(false). This setting can be useful if you want to keep the scanner's orientation consistent. It's usually a good practice to set it to false so the user can use the device in any orientation.
Barcode Formats: You can specify the barcode formats the scanner should look for. This can speed up the scanning process. Use options.setDesiredBarcodeFormats(ScanOptions.ALL_CODE_TYPES) to scan all types, or use a list, such as options.setDesiredBarcodeFormats(listOf(BarcodeFormat.QR_CODE, BarcodeFormat.CODE_128)). For example, this will only scan QR codes and CODE_128 barcodes.

Beyond the basic options, you can also customize the scanner's appearance. While the embedded scanner has a default UI, you can also create a custom scanner using the BarcodeView class from ZXing. This gives you more control over the look and feel of your scanner. The advanced customization options are a little bit complex, and are outside of the scope of this tutorial. By tweaking these settings, you can tailor the scanner to your app's specific requirements, creating a seamless and user-friendly scanning experience. Take some time to play around with these options. It's all about making the scanner fit your app like a glove.

Advanced Features and Next Steps

Wow, you've made it this far, awesome! Let's explore some advanced features and next steps. You've got the basics down, now you can take your barcode scanning app to the next level. First, consider how you will handle the scanned data. Once you have the barcode content, you'll probably want to do something with it, such as look up a product in a database, update inventory, or process a payment. You can implement different functions with the scan result. You can pass the scanned content to another part of your app, save it to a database, or even send it to a server. Also, you can handle different barcode types. The ZXing library supports a wide variety of barcode formats, including QR codes, UPC-A, UPC-E, EAN-8, EAN-13, Code 39, Code 128, and many more. Ensure your app handles the different types of barcodes it might encounter. Also, you can add error handling. Implement robust error handling to deal with potential issues during scanning. For instance, the camera may not be available, or the barcode might be unreadable. Provide informative error messages to the user to help them troubleshoot the issue. Furthermore, you can implement batch scanning. If your app needs to scan multiple barcodes in a row, consider implementing batch scanning. This can significantly improve the user experience. You can use a loop or other techniques to scan multiple barcodes and process them as needed. Then, you can also implement data validation. Before processing the scanned data, validate it to ensure it is in the correct format and meets your app's requirements. This can help prevent errors and data integrity issues. Finally, remember to consider the security implications of scanning barcodes. If your app handles sensitive data, be sure to implement appropriate security measures to protect the user's information. Now that you've got the basics down, you can start building a truly powerful and versatile barcode scanning app. Keep experimenting, and you'll be amazed at what you can create!

That's it, guys! You now have a working barcode scanner in your Android app using the ZXing library. You've learned how to set up the project, implement the scanner activity, and customize the scanner's behavior. I hope this guide helps you. Go out there and start scanning! Happy coding, and don't hesitate to ask if you have any questions. Cheers!