Skip to main content

Scanning a medical certificate from an image | Android Document Scanner

The Scanbot SDK Medical Certificate Scanner is capable of detecting MC / AU-Bescheinigung forms in live camera streams, as well as extracting content from still images imported from the gallery or any other source.

Integration​

To see the complete integration and the Medical Certificate scanner in action, Example Apps are available:

Feature Dependency​

The GenericDocumentRecognizer feature is available with SDK Package 4. The following dependencies need to be added:

implementation("io.scanbot:sdk-package-4:$latestSdkVersion")
implementation("io.scanbot:sdk-mc-assets:$latestSdkVersion")

For Medical Certificates that contain additional information in the barcode, the following dependency should also be added:

implementation("io.scanbot:sdk-barcode-assets:$latestSdkVersion")

SDK Initialization​

Before use, the Scanbot SDK needs to be initialized. The following code snippet should be added to your Application class:

import io.scanbot.sdk.ScanbotSDKInitializer

class ExampleApplication : Application() {

    override fun onCreate() {
        super.onCreate()

        // The Scanbot Scanner SDK initialization:
         ScanbotSDKInitializer()
         .prepareOCRLanguagesBlobs(true)
           ...
         .initialize(this)
    }
}

Image Processing​

To select an image from the photo library and run detection on it, a class for an image import contract is created using the modern Android result API.

class ImportImageContract(private val context: Context) : ActivityResultContract<Unit, Bitmap?>() {
    override fun createIntent(context: Context, input: Unit): Intent {
        // An image is selected from the photo library and document detection is run on it:
        val imageIntent = Intent()
        imageIntent.type = "image/*"
        imageIntent.action = Intent.ACTION_GET_CONTENT
        imageIntent.putExtra(Intent.EXTRA_LOCAL_ONLY, false)
        imageIntent.putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false)

       return Intent.createChooser(imageIntent, "Select a picture")
    }

    private fun processGalleryResult(data: Intent): Bitmap? {
        val imageUri = data.data
        return MediaStore.Images.Media.getBitmap(context.contentResolver, imageUri)
    }

    override fun parseResult(resultCode: Int, intent: Intent?): Bitmap? {
       return if (resultCode == Activity.RESULT_OK && intent != null) {
           return processGalleryResult(intent)
        } else {
            null
        }
    }
}

To run the gallery call and get a Bitmap using ImportImageContract, the following code is used:

 val galleryImageLauncher =
            registerForActivityResult(ImportImageContract(this)) { resultEntity ->
                lifecycleScope.launch(Dispatchers.Default) {
                    val activity = this@MainActivity
                    val sdk = ScanbotSDK(activity)
                    if (!sdk.licenseInfo.isValid) {
                        withContext(Dispatchers.Main) {
                            Toast.makeText(
                                activity,
                                "License has expired!",
                                Toast.LENGTH_LONG
                            ).show()
                        }
                    } else {
                        resultEntity?.let { bitmap ->
                           // Image processing is carried out
                           // processImage()
                        }
                    }
                }
            }
        findViewById<View>(R.id.import_image).setOnClickListener {
            galleryImageLauncher.launch(Unit)
        }

Scanner Creation​

  val scanbotSDK = ScanbotSDK(this)
  val medicalCertificateRecognizer = scanbotSDK.createMedicalCertificateRecognizer()
caution

Each call to createMedicalCertificateRecognizer() will create a new MedicalCertificateRecognizer and initialize memory for it. If more than one import operation is expected, do not create new scanners for each operation.

Detection​

The Scanbot SDK is used to detect the desired element on the imported bitmap.

    private fun processImage(
        medicalCertificateRecognizer: MedicalCertificateRecognizer,
        bitmap: Bitmap
    ) {
        val result = medicalCertificateRecognizer.recognizeMcBitmap(bitmap,
                                 0,
                                 shouldCropDocument = true,
                                 returnCroppedDocument = true,
                                 recognizePatientInfo = true,
                                 recognizeBarcode = true)
         if (result != null && result.recognitionSuccessful) {
             // Document recognition results are processed
             // processResult(result)
         }
    }

Want to scan longer than one minute?

Generate a free trial license to test the Scanbot SDK thoroughly.

Get your free Trial License

What do you think of this documentation?

On this page

Scroll to top