Android QR Code Generator and Scanner with Kotlin and Jetpack Compose — Step-by-Step Guide

Legacy Approach with XML (for historical reference)

In this section we will see how to implement a QR reader using the classic approach based on XML and Activities. Although it is no longer the recommended method for new projects, it is useful for understanding the evolution of Android development or maintaining apps with legacy code.

Developing a QR reader with Play Services library

Google makes a large number of APIs available to developers through its Play Services libraries. For common tasks such as reading a QR code, it is not necessary to resort to third-party libraries: Google's own library does all the heavy lifting for us.

Update note: The library com.google.android.gms:play-services-vision has been deprecated. For new implementations, Google recommends using ML Kit Barcode Scanning (com.google.mlkit:barcode-scanning or com.google.android.gms:play-services-mlkit-barcode-scanning) in combination with CameraX for camera integration.

Creating a custom QR reader in Android Studio is quite simple: we only need to include the external library corresponding to Google Play services and configure a few components.

QR Scanner: how to decode a QR code?

With the help of a mobile phone we can retrieve the information stored in a QR simply by pointing the camera at it. That is exactly the idea behind what we will implement in this section.

Developing our own QR code reader in Android

First we must add the necessary dependency in our build.gradle file.

Adding the dependency in the build.gradle file

We open the module-level build.gradle file and add the following dependency:

implementation 'com.google.android.gms:play-services:15.0.2'

Update note: The play-services dependency is too broad and includes APIs you probably don't need. It is better to use only the required modules. Furthermore, play-services-vision is deprecated. The recommended modern option is ML Kit Barcode Scanning with CameraX.

If we are only interested in the vision API to read QRs, we can use the more specific dependency in our build.gradle:

implementation 'com.google.android.gms:play-services-vision:15.0.2'

Versions are updated frequently. You can always check the latest available version in the official documentation:

Set Up Google Play Services

Update note: Using version ranges like 15.+ is not a recommended practice in production, as it can introduce unexpected incompatibilities. Always specify an exact version.

If you wanted the dependency to update automatically to sub-versions of 15.x: implementation 'com.google.android.gms:play-services-vision:15.+'

Configuring the rest of the application for the QR reader

The manifest file to handle permissions

In our AndroidManifest.xml we declare camera usage:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="net.desarrollolibre.qr.qr">
    <uses-permission android:name="android.permission.CAMERA" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

The view of our QR code reader

With the dependency configured, we can go to our Activity or Fragment to create the necessary objects and configurations. But first, let's define the layout with the camera view:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:orientation="vertical"
        android:layout_gravity="center_horizontal"
        android:padding="8dp">
        <SurfaceView
            android:id="@+id/camera_view"
            android:layout_width="640px"
            android:layout_height="480px"
            android:layout_alignParentLeft="true"
            android:layout_centerVertical="true" />
    </LinearLayout>
</LinearLayout>

Configuring the detector and camera in our Activity

In our Activity or Fragment we create an object of type BarcodeDetector. This class allows recognizing barcodes and QRs through the camera, returning a SparseArray with the decoded data. Next we also create the CameraSource:

        // I create the QR detector
        barcodeDetector =
                new BarcodeDetector.Builder(getContext())
                        .setBarcodeFormats(Barcode.QR_CODE)
                        .build();
        // I create the camera source
        cameraSource = new CameraSource
                .Builder(getContext(), barcodeDetector)
                .setRequestedPreviewSize(640, 480)
                .build();

The CameraSource object to obtain frames from the camera

We reference the SurfaceView from our layout; this component reflects on screen what the device's camera is capturing:

cameraView = (SurfaceView) v.findViewById(R.id.camera_view);

Next, we register the lifecycle listener of the SurfaceHolder to start and stop the camera at the right time:

        // Camera lifecycle listener
        cameraView.getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder holder) {
                if (ContextCompat.checkSelfPermission(getContext(), android.Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
                    try {
                        cameraSource.start(cameraView.getHolder());
                    } catch (IOException ie) {
                        Log.e("CAMERA SOURCE", ie.getMessage());
                    }
                } else {
                    Toast.makeText(getContext(), getResources().getString(R.string.error_camara), Toast.LENGTH_SHORT).show();
                }
            }
            @Override
            public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            }
            @Override
            public void surfaceDestroyed(SurfaceHolder holder) {
                cameraSource.stop();
            }
        });

A key point: the camera must be started with cameraSource.start(cameraView.getHolder()) inside the surfaceCreated callback, that is, once the surface has already been drawn. Trying to start it earlier will cause an error.

Finally, we prepare the event that will return the result of the detected QR. When barcodes.size() is greater than zero, it means that at least one code has been read:

        // I prepare the QR detector
        barcodeDetector.setProcessor(new Detector.Processor<Barcode>() {
            @Override
            public void release() {
            }
            @Override
            public void receiveDetections(Detector.Detections<Barcode> detections) {
                final SparseArray<Barcode> barcodes = detections.getDetectedItems();
                if (barcodes.size() != 0) {
                    barcodes.valueAt(0).displayValue.toString();
                    // do something with the obtained value
                }
                barcodeDetector.release();
            }
        });

With barcodes.valueAt(0).displayValue.toString() we get the data returned by the QR: it can be plain text, a number, or a URL, depending on how the code was generated.

Permissions in Android 6 and higher

Update note: The ActivityCompat and AppCompatActivity classes from the original code belong to legacy support libraries (android.support.*). In modern projects, they have been replaced by AndroidX (androidx.core.app.ActivityCompat and androidx.appcompat.app.AppCompatActivity). Permission handling follows a similar pattern, but it is always advisable to consult the latest AndroidX documentation.

Starting with Android 6 (API 23), Google introduced a new runtime permissions scheme: sensitive permissions—such as camera access—must be explicitly requested from the user, not just declared in the AndroidManifest.

Therefore, in addition to the manifest declaration, we must request the permission from our Activity's code. We add this logic when constructing the SurfaceHolder:

// Camera lifecycle listener
cameraView.getHolder().addCallback(new SurfaceHolder.Callback() {
   @Override
   public void surfaceCreated(SurfaceHolder holder) {
       if (ActivityCompat.checkSelfPermission(QRActiviy.this, Manifest.permission.CAMERA)
               != PackageManager.PERMISSION_GRANTED) {
           if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
               if (shouldShowRequestPermissionRationale(
                       Manifest.permission.CAMERA)) ;
               requestPermissions(new String[]{Manifest.permission.CAMERA},
                       MY_PERMISSIONS_REQUEST_CAMERA);
           }
           return;
       } else {
           try {
               cameraSource.start(cameraView.getHolder());
           } catch (IOException ie) {
               Log.e("CAMERA SOURCE", ie.getMessage());
           }
       }
   }
   @Override
   public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
   }
   @Override
   public void surfaceDestroyed(SurfaceHolder holder) {
       cameraSource.stop();
   }
});

We check if the permission has already been granted using checkSelfPermission, and if not, we display the native dialog with shouldShowRequestPermissionRationale followed by requestPermissions.

The complete Activity code would look like this:

import android.Manifest;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Build;
import android.support.v4.app.ActivityCompat; // Use androidx.core.app.ActivityCompat
import android.support.v7.app.AppCompatActivity; // Use androidx.appcompat.app.AppCompatActivity
import android.os.Bundle;
import android.util.Log;
import android.util.SparseArray;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.webkit.URLUtil;
import com.google.android.gms.vision.CameraSource; // Deprecated, use ML Kit Barcode Scanning
import com.google.android.gms.vision.Detector; // Deprecated, use ML Kit Barcode Scanning
import com.google.android.gms.vision.barcode.Barcode; // Deprecated, use ML Kit Barcode Scanning
import com.google.android.gms.vision.barcode.BarcodeDetector; // Deprecated, use ML Kit Barcode Scanning
import java.io.IOException;
public class MainActivity extends AppCompatActivity {
    private CameraSource cameraSource;
    private SurfaceView cameraView;
    private final int MY_PERMISSIONS_REQUEST_CAMERA = 1;
    private String token = "";
    private String tokenanterior = "";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        cameraView = (SurfaceView) findViewById(R.id.camera_view);
        initQR();
    }
    public void initQR() {
        BarcodeDetector barcodeDetector =
                new BarcodeDetector.Builder(this)
                        .setBarcodeFormats(Barcode.ALL_FORMATS)
                        .build();
        cameraSource = new CameraSource
                .Builder(this, barcodeDetector)
                .setRequestedPreviewSize(1600, 1024)
                .setAutoFocusEnabled(true) // Recommended for more accurate scanning
                .build();
        cameraView.getHolder().addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder holder) {
                if (ActivityCompat.checkSelfPermission(MainActivity.this, Manifest.permission.CAMERA)
                        != PackageManager.PERMISSION_GRANTED) {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        if (shouldShowRequestPermissionRationale(
                                Manifest.permission.CAMERA)) ;
                        requestPermissions(new String[]{Manifest.permission.CAMERA},
                                MY_PERMISSIONS_REQUEST_CAMERA);
                    }
                    return;
                } else {
                    try {
                        cameraSource.start(cameraView.getHolder());
                    } catch (IOException ie) {
                        Log.e("CAMERA SOURCE", ie.getMessage());
                    }
                }
            }
            @Override
            public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
            }
            @Override
            public void surfaceDestroyed(SurfaceHolder holder) {
                cameraSource.stop();
            }
        });
        barcodeDetector.setProcessor(new Detector.Processor<Barcode>() {
            @Override
            public void release() {
            }
            @Override
            public void receiveDetections(Detector.Detections<Barcode> detections) {
                final SparseArray<Barcode> barcodes = detections.getDetectedItems();
                if (barcodes.size() > 0) {
                    token = barcodes.valueAt(0).displayValue.toString();
                    if (!token.equals(tokenanterior)) {
                        tokenanterior = token;
                        Log.i("token", token);
                        if (URLUtil.isValidUrl(token)) {
                            Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(token));
                            startActivity(browserIntent);
                        } else {
                            Intent shareIntent = new Intent();
                            shareIntent.setAction(Intent.ACTION_SEND);
                            shareIntent.putExtra(Intent.EXTRA_TEXT, token);
                            shareIntent.setType("text/plain");
                            startActivity(shareIntent);
                        }
                        new Thread(new Runnable() {
                            public void run() {
                                try {
                                    synchronized (this) {
                                        wait(5000);
                                        tokenanterior = "";
                                    }
                                } catch (InterruptedException e) {
                                    Log.e("Error", "Waiting didn't work!!");
                                    e.printStackTrace();
                                }
                            }
                        }).start();
                    }
                }
            }
        });
    }
}

QR Code Reader in Kotlin (legacy version)

The same implementation, but in Kotlin. Note the idiomatic changes: the use of val and var, the object : syntax for anonymous implementations, the safe call with !! on nullables, and the absence of semicolons:

    private var cameraSource: CameraSource? = null
    private var cameraView: SurfaceView? = null
    private val MY_PERMISSIONS_REQUEST_CAMERA = 1
    private var token = ""
    private var tokenanterior = ""
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        cameraView = findViewById<View>(R.id.camera_view)
        initQR()
    }
    fun initQR() {
        val barcodeDetector = BarcodeDetector.Builder(this)
                .setBarcodeFormats(Barcode.ALL_FORMATS)
                .build()
        cameraSource = CameraSource.Builder(this, barcodeDetector)
                .setRequestedPreviewSize(1600, 1024)
                .setAutoFocusEnabled(true)
                .build()
        cameraView!!.holder.addCallback(object : SurfaceHolder.Callback {
            override fun surfaceCreated(holder: SurfaceHolder) {
                if (ActivityCompat.checkSelfPermission(this@MainActivity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA))
                        ;
                        requestPermissions(arrayOf(Manifest.permission.CAMERA), MY_PERMISSIONS_REQUEST_CAMERA)
                    }
                    return
                } else {
                    try {
                        cameraSource!!.start(cameraView!!.holder)
                    } catch (ie: IOException) {
                        Log.e("CAMERA SOURCE", ie.message)
                    }
                }
            }
            override fun surfaceChanged(holder: SurfaceHolder, format: Int, width: Int, height: Int) {}
            override fun surfaceDestroyed(holder: SurfaceHolder) {
                cameraSource!!.stop()
            }
        })
        barcodeDetector.setProcessor(object : Detector.Processor<Barcode> {
            override fun release() {}
            override fun receiveDetections(detections: Detector.Detections<Barcode>) {
                val barcodes = detections.getDetectedItems()
                if (barcodes.size() > 0) {
                    token = barcodes.valueAt(0).displayValue.toString()
                    if (token != tokenanterior) {
                        tokenanterior = token
                        Log.i("token", token)
                        if (URLUtil.isValidUrl(token)) {
                            val browserIntent = Intent(Intent.ACTION_VIEW, Uri.parse(token))
                            startActivity(browserIntent)
                        } else {
                            val shareIntent = Intent()
                            shareIntent.action = Intent.ACTION_SEND
                            shareIntent.putExtra(Intent.EXTRA_TEXT, token)
                            shareIntent.type = "text/plain"
                            startActivity(shareIntent)
                        }
                        Thread(object : Runnable {
                            override fun run() {
                                try {
                                    synchronized(this) {
                                        wait(5000)
                                        tokenanterior = ""
                                    }
                                } catch (e: InterruptedException) {
                                    Log.e("Error", "Waiting didn't work!!")
                                    e.printStackTrace()
                                }
                            }
                        }).start()
                    }
                }
            }
        })
    }

In the previous code, you can see the complete detection flow: we retrieve the QR value with barcodes.valueAt(0).displayValue.toString(), validate it to avoid processing the same code consecutively (thanks to the tokenanterior mechanism and the Thread with wait(5000)), and finally, with URLUtil.isValidUrl(token), we determine whether the content is a URL—in which case we open the browser—or plain text, which we share with other apps using an Intent.ACTION_SEND.

Upon running the application, we will get a screen like the following:

Remember that once you obtain the code, you can do whatever you need with it: send it to your backend for validation, display it in a dialog, or open the browser. If you are interested in generating QR codes from the server side, you can check out the article on how to create QR codes in CodeIgniter.

You can use the following QR code to test your scanner; point the camera and it should return the URL of this blog:

An important detail: this exact same code works to read barcodes in addition to QR codes. The core of the reader is identical; by simply adjusting the parameter in setBarcodeFormats(), you can support EAN-13, UPC-A, Code 128, and many other formats. With that, you can build a fairly powerful app that functions as a universal code scanner.

Next step: learn how to use Room Database (SQLite) in Android Studio with Kotlin.