apiException.mustache

{{! MainActivity.kt }}
{{>licenseInfo}}
package {{invokerPackage}}

import android.app.Activity
import android.content.Intent
import android.graphics.Bitmap
import android.graphics.BitmapFactory
import android.net.Uri
import android.os.Bundle
import android.provider.MediaStore
import android.util.Size
import android.view.View
import android.view.animation.AnimationUtils
import android.widget.ArrayAdapter
import android.widget.EditText
import android.widget.ImageView
import android.widget.Spinner
import androidx.activity.result.PickVisualMediaRequest
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import androidx.core.os.BundleCompat
import androidx.core.view.ViewCompat
import androidx.core.view.WindowCompat
import androidx.core.view.WindowInsetsCompat
import com.aspose.barcode.cloud.ApiClient
import com.aspose.barcode.cloud.ApiException
import com.aspose.barcode.cloud.api.GenerateApi
import com.aspose.barcode.cloud.api.ScanApi
import com.aspose.barcode.cloud.model.BarcodeImageFormat
import com.aspose.barcode.cloud.model.EncodeBarcodeType
import com.aspose.barcode.cloud.requests.GenerateRequestWrapper
import com.aspose.barcode.cloud.requests.ScanMultipartRequestWrapper
import com.google.android.material.snackbar.Snackbar
import java.io.File
import java.io.FileOutputStream
import kotlin.math.floor
import androidx.core.graphics.scale

class MainActivity : AppCompatActivity() {
    companion object {
        private fun imageSize(width: Int, height: Int, maxSize: Int = 384): Size {
            val ratio = width.toFloat() / height
            if (ratio > 1) {
                if (width < maxSize) {
                    return Size(width, height)
                }

                val newHeight = floor(maxSize / ratio).toInt()
                return Size(maxSize, newHeight)
            }

            if (height < maxSize) {
                return Size(width, height)
            }
            val newWidth = floor(maxSize * ratio).toInt()
            return Size(newWidth, maxSize)
        }

        private fun reduceBitmapSize(image: Bitmap): Bitmap {
            val newSize = imageSize(image.width, image.height)
            return image.scale(newSize.width, newSize.height)
        }
    }

    private lateinit var barcodeTypeSpinner: Spinner
    private lateinit var barcodeTextEdit: EditText
    private lateinit var barcodeImgView: ImageView

    private lateinit var scanApi: ScanApi
    private lateinit var generateApi: GenerateApi
    private val encodeTypes = EncodeBarcodeType.entries.map { it.toString() }.sorted()

    private val cameraLauncher =
        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
            if (result.resultCode == Activity.RESULT_OK) {
                val bmpImage = result.data?.extras?.let {
                    BundleCompat.getParcelable(it, "data", Bitmap::class.java)
                }
                if (bmpImage == null) {
                    showErrorMessage("No photo captured")
                    return@registerForActivityResult
                }
                recognizeBarcode(bmpImage)
            }
        }

    private val photoPickerLauncher =
        registerForActivityResult(ActivityResultContracts.PickVisualMedia()) { uri ->
            if (uri == null) {
                return@registerForActivityResult
            }

            recognizeSelectedImage(uri)
        }

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

        val client = ApiClient(
            "Client Id from https://dashboard.aspose.cloud/applications",
            "Client Secret from https://dashboard.aspose.cloud/applications"
        )

        client.readTimeout = 60_000

        generateApi = GenerateApi(client)
        scanApi = ScanApi(client)

        barcodeTypeSpinner = findViewById(R.id.typeSpinner)
        populateBarcodeTypesSpinner()

        barcodeTextEdit = findViewById(R.id.editText)
        barcodeImgView = findViewById(R.id.imageView)
    }

    private fun configureEdgeToEdge() {
        WindowCompat.setDecorFitsSystemWindows(window, false)

        val rootLayout = findViewById<View>(R.id.rootLayout)
        ViewCompat.setOnApplyWindowInsetsListener(rootLayout) { view, windowInsets ->
            val insets = windowInsets.getInsets(WindowInsetsCompat.Type.systemBars())
            view.setPadding(insets.left, insets.top, insets.right, insets.bottom)
            windowInsets
        }
        ViewCompat.requestApplyInsets(rootLayout)
    }

    private fun showErrorMessage(error: String) {
        Snackbar.make(findViewById(android.R.id.content), error, Snackbar.LENGTH_LONG).show()
    }

    private fun populateBarcodeTypesSpinner() {
        val adapter = ArrayAdapter(this, android.R.layout.simple_spinner_item, encodeTypes)
        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
        barcodeTypeSpinner.adapter = adapter
        barcodeTypeSpinner.setSelection(encodeTypes.indexOf("QR"))
    }

    private fun recognizeSelectedImage(uri: Uri) {
        try {
            val bytes = contentResolver.openInputStream(uri)?.use { it.readBytes() }
            if (bytes == null) {
                showErrorMessage("Unable to read selected image")
                return
            }

            val bmpImage = BitmapFactory.decodeByteArray(bytes, 0, bytes.size)
            if (bmpImage == null) {
                showErrorMessage("Unable to decode selected image")
                return
            }

            recognizeBarcode(bmpImage)
        } catch (_: Exception) {
            showErrorMessage("Unable to read selected image")
        }
    }

    private fun recognizeBarcode(image: Bitmap) {
        try {
            val smallerBmp = reduceBitmapSize(image)

            barcodeImgView.setImageBitmap(smallerBmp)
            startRecognizeAnimation()

            val tmpFile = File.createTempFile("barcode", null)

            FileOutputStream(tmpFile).use { output ->
                smallerBmp.compress(Bitmap.CompressFormat.PNG, 100, output)
            }

            val apiRequest = ScanMultipartRequestWrapper(tmpFile)

            Thread {
                try {
                    val recognized = scanApi.scanMultipart(apiRequest)

                    runOnUiThread {
                        stopRecognizeAnimation()
                        if (recognized.barcodes.isEmpty()) {
                            barcodeTextEdit.setText("")
                            showErrorMessage("No barcode detected")
                            return@runOnUiThread
                        }
                        val firstBarcode = recognized.barcodes.first()
                        barcodeTextEdit.setText(firstBarcode.barcodeValue)
                        val index = encodeTypes.indexOf(firstBarcode.type)
                        barcodeTypeSpinner.setSelection(index, true)
                    }
                } catch (e: ApiException) {
                    runOnUiThread {
                        stopRecognizeAnimation()

                        var message = e.message + ": " + e.details
                        if (e.httpCode == 0) {
                            message = "Check ClientId and ClientSecret in ApiClient $message"
                        }
                        showErrorMessage(message)
                    }
                } catch (e: Exception) {
                    runOnUiThread {
                        stopRecognizeAnimation()
                        showErrorMessage("Exception: " + e.message)
                    }
                }
            }.start()
        } catch (e: Exception) {
            showErrorMessage(e.message ?: "Unknown error")
        }
    }

    private fun startRecognizeAnimation() {
        val rotation = AnimationUtils.loadAnimation(this, R.anim.rotate)
        rotation.fillAfter = true
        barcodeImgView.startAnimation(rotation)
    }

    private fun stopRecognizeAnimation() {
        barcodeImgView.clearAnimation()
    }

    fun onBtnGenerateClick(@Suppress("UNUSED_PARAMETER") view: View) {
        val type = EncodeBarcodeType.fromValue(barcodeTypeSpinner.selectedItem.toString())

        val genRequest = GenerateRequestWrapper(type, barcodeTextEdit.text.toString())
        genRequest.imageFormat = BarcodeImageFormat.PNG
        genRequest.imageHeight = barcodeImgView.measuredHeight.toFloat()
        genRequest.imageWidth = barcodeImgView.measuredWidth.toFloat()

        Thread {
            try {
                val generated = generateApi.generate(genRequest)
                runOnUiThread {
                    val bitmap = BitmapFactory.decodeFile(generated!!.absolutePath)
                    barcodeImgView.setImageBitmap(bitmap)
                }
            } catch (e: ApiException) {
                runOnUiThread {
                    var message = e.message + ": " + e.details
                    if (e.httpCode == 0) {
                        message = "Check ClientId and ClientSecret in ApiClient $message"
                    }
                    showErrorMessage(message)
                }
            } catch (e: Exception) {
                runOnUiThread {
                    showErrorMessage("Exception: " + e.message)
                }
            }
        }.start()
    }

    fun onBtnTakePhotoClick(@Suppress("UNUSED_PARAMETER") view: View) {
        val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        if (takePictureIntent.resolveActivity(packageManager) != null) {
            cameraLauncher.launch(takePictureIntent)
        }
    }

    fun onBtnSelectImageClick(@Suppress("UNUSED_PARAMETER") view: View) {
        photoPickerLauncher.launch(
            PickVisualMediaRequest(ActivityResultContracts.PickVisualMedia.ImageOnly)
        )
    }
}