fixed vin-scanner example

4BooM04 · 4BooM04 · commit 127ffdcf6072 · 2025-10-24T12:14:45.000+02:00
fix image-ref usage logic

fix imageRef usage logic

update dependencies fix compiling

remove dev deps
diff --git a/classic-components-example/camera-view-aspect-ratio-finder/src/main/java/io/scanbot/example/MainActivity.kt b/classic-components-example/camera-view-aspect-ratio-finder/src/main/java/io/scanbot/example/MainActivity.kt
@@ -26,10 +26,12 @@ import io.scanbot.sdk.documentscanner.DocumentScanner
 import io.scanbot.sdk.documentscanner.DocumentScannerParameters
 import io.scanbot.sdk.geometry.AspectRatio
 import io.scanbot.sdk.image.ImageRef
+import io.scanbot.sdk.imageprocessing.ScanbotSdkImageProcessor
 import io.scanbot.sdk.process.ImageProcessor
 import io.scanbot.sdk.ui.camera.AdaptiveFinderOverlayView
 import io.scanbot.sdk.ui.camera.ScanbotCameraXView
 import io.scanbot.sdk.ui.camera.ShutterButton
+import io.scanbot.sdk.util.PolygonHelper
 
 class MainActivity : AppCompatActivity(), DocumentScannerFrameHandler.ResultHandler {
     private lateinit var cameraView: ScanbotCameraXView
@@ -186,11 +188,18 @@ class MainActivity : AppCompatActivity(), DocumentScannerFrameHandler.ResultHand
                 this.ignoreOrientationMismatch = true
             }
         })
-        val polygon = scanner.run(image).getOrNull()?.pointsNormalized ?: throw Exception("Document detection failed")
+        val polygon = scanner.run(image).getOrNull()?.pointsNormalized
+            ?: throw Exception("Document detection failed")
+
+        val polygonCrop =
+            polygon.takeIf { it.isNotEmpty() && it.size == 4 } ?: PolygonHelper.getFullPolygon()
+        var documentImage = ScanbotSdkImageProcessor.create()
+            .crop(image, polygonCrop)
+            .getOrThrow()
+        documentImage = ScanbotSdkImageProcessor.create().resize(documentImage, 200).getOrThrow()
 
-        val documentImage = ImageProcessor(image).crop(polygon).processedBitmap().getOrNull()
         resultView.post {
-            resultView.setImageBitmap(documentImage)
+            resultView.setImageBitmap(documentImage.toBitmap().getOrNull())
             cameraView.continuousFocus()
             cameraView.startPreview()
         }
diff --git a/classic-components-example/camera-view/src/main/java/io/scanbot/example/MainActivity.kt b/classic-components-example/camera-view/src/main/java/io/scanbot/example/MainActivity.kt
@@ -33,10 +33,12 @@ import io.scanbot.sdk.document.DocumentScannerFrameHandler
 import io.scanbot.sdk.documentscanner.DocumentDetectionStatus
 import io.scanbot.sdk.documentscanner.DocumentScanner
 import io.scanbot.sdk.image.ImageRef
+import io.scanbot.sdk.imageprocessing.ScanbotSdkImageProcessor
 import io.scanbot.sdk.process.ImageProcessor
 import io.scanbot.sdk.ui.PolygonView
 import io.scanbot.sdk.ui.camera.ScanbotCameraXView
 import io.scanbot.sdk.ui.camera.ShutterButton
+import io.scanbot.sdk.util.PolygonHelper
 
 class MainActivity : AppCompatActivity(), DocumentScannerFrameHandler.ResultHandler {
     private lateinit var cameraView: ScanbotCameraXView
@@ -223,16 +225,14 @@ class MainActivity : AppCompatActivity(), DocumentScannerFrameHandler.ResultHand
             documentScanner.run(image).getOrNull()?.pointsNormalized ?: throw IllegalStateException(
                 "No document detected"
             )
+        val polygonCrop = polygon.takeIf { it.isNotEmpty() && it.size == 4 } ?: PolygonHelper.getFullPolygon()
+        var documentImage = ScanbotSdkImageProcessor.create()
+            .crop(image, polygonCrop)
+            .getOrThrow()
+        documentImage = ScanbotSdkImageProcessor.create().resize(documentImage, 200).getOrThrow()
 
-        val documentImage =
-            ImageProcessor(image).resize(200).crop(polygon).processedBitmap().getOrNull()
         resultView.post {
-            val bm = image.toBitmap()
-            when(bm){
-                is Result.Success<*> -> {}
-                is Result.Unexpected ->{ throw  IllegalStateException(bm.message) }
-            }
-            resultView.setImageBitmap(bm.getOrNull())
+            resultView.setImageBitmap(documentImage.toBitmap().getOrNull())
         }
 
         // continue scanning
diff --git a/classic-components-example/vin-scanner/src/main/java/io/scanbot/example/ExampleApplication.kt b/classic-components-example/vin-scanner/src/main/java/io/scanbot/example/ExampleApplication.kt
@@ -1,7 +1,6 @@
 package io.scanbot.example
 
 import android.app.Application
-import io.scanbot.sap.SdkFeature
 import io.scanbot.sdk.ScanbotSDK
 import io.scanbot.sdk.ScanbotSDKInitializer
 import io.scanbot.sdk.util.log.LoggerProvider
@@ -24,11 +23,9 @@ class ExampleApplication : Application() {
             .withLogging(true)
             // TODO 2/2: Enable the Scanbot SDK license key
             //.license(this, licenseKey)
-            .licenceErrorHandler { status, feature, statusMessage ->
+            .licenseErrorHandler { status, feature, statusMessage ->
                 LoggerProvider.logger.d("ExampleApplication", "+++> License status: ${status.name}. Status message: $statusMessage")
-                if (feature != SdkFeature.NoSdkFeature) {
-                    LoggerProvider.logger.d("ExampleApplication", "+++> Feature not available: ${feature.name}")
-                }
+                LoggerProvider.logger.d("ExampleApplication", "+++> Feature not available: ${feature.name}")
             }
             //.sdkFilesDirectory(this, getExternalFilesDir(null)!!)
             .initialize(this)
@@ -38,6 +35,6 @@ class ExampleApplication : Application() {
         val licenseInfo = ScanbotSDK(this).licenseInfo
         LoggerProvider.logger.d("ExampleApplication", "License status: ${licenseInfo.status}")
         LoggerProvider.logger.d("ExampleApplication", "License isValid: ${licenseInfo.isValid}")
-        LoggerProvider.logger.d("ExampleApplication", "License expirationDate: ${licenseInfo.expirationDate}")
+        LoggerProvider.logger.d("ExampleApplication", "License expirationDate: ${licenseInfo.expirationDateString}")
     }
 }
diff --git a/classic-components-example/vin-scanner/src/main/java/io/scanbot/example/ScannerActivity.kt b/classic-components-example/vin-scanner/src/main/java/io/scanbot/example/ScannerActivity.kt
@@ -5,11 +5,12 @@ import android.util.TypedValue
 import android.widget.Button
 import android.widget.TextView
 import androidx.appcompat.app.AppCompatActivity
+import io.scanbot.common.getOrThrow
 import io.scanbot.example.common.applyEdgeToEdge
 import io.scanbot.sdk.ScanbotSDK
 import io.scanbot.sdk.camera.CameraPreviewMode
 import io.scanbot.sdk.camera.FrameHandlerResult
-import io.scanbot.sdk.common.AspectRatio
+import io.scanbot.sdk.geometry.AspectRatio
 import io.scanbot.sdk.ui.camera.FinderOverlayView
 import io.scanbot.sdk.ui.camera.IScanbotCameraView
 import io.scanbot.sdk.ui.camera.ScanbotCameraXView
@@ -32,7 +33,7 @@ class ScannerActivity : AppCompatActivity() {
         supportActionBar!!.hide()
         applyEdgeToEdge(findViewById(R.id.root_view))
 
-        vinScanner = ScanbotSDK(this).createVinScanner()
+        vinScanner = ScanbotSDK(this).createVinScanner().getOrThrow()
 
         cameraView = findViewById<ScanbotCameraXView>(R.id.cameraView)
         resultTextView = findViewById(R.id.resultTextView)
diff --git a/data-capture-ready-to-use-ui-example/app/build.gradle b/data-capture-ready-to-use-ui-example/app/build.gradle
@@ -74,7 +74,7 @@ dependencies {
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version")
     implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:$coroutines_version")
 
-    def scanbotSdkVersion = "8.0.0.38-STAGING-SNAPSHOT"
+    def scanbotSdkVersion = "8.0.0_RESULT.54-STAGING-SNAPSHOT"
 
     implementation("io.scanbot:sdk-package-4:$scanbotSdkVersion")
     implementation("io.scanbot:sdk-package-ui:$scanbotSdkVersion")
diff --git a/data-capture-ready-to-use-ui-example/build.gradle b/data-capture-ready-to-use-ui-example/build.gradle
@@ -1,7 +1,7 @@
 
 plugins {
-    id "com.android.application" version "8.3.2" apply false
-    id "org.jetbrains.kotlin.android" version "1.9.23" apply false
+    id "com.android.application" version '8.13.0' apply false
+    id "org.jetbrains.kotlin.android" version "2.2.20" apply false
 }
 
 allprojects {
diff --git a/data-capture-ready-to-use-ui-example/gradle/wrapper/gradle-wrapper.properties b/data-capture-ready-to-use-ui-example/gradle/wrapper/gradle-wrapper.properties
@@ -3,4 +3,4 @@ distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
diff --git a/document-scanner-ready-to-use-ui-example/app/build.gradle b/document-scanner-ready-to-use-ui-example/app/build.gradle
@@ -39,7 +39,7 @@ android {
     }
 }
 
-def scanbotSdkVersion =  "8.0.0.39-STAGING-SNAPSHOT"
+def scanbotSdkVersion =  "8.0.0_RESULT.54-STAGING-SNAPSHOT"
 
 dependencies {
 
diff --git a/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/di/ExampleSingleton.kt b/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/di/ExampleSingleton.kt
@@ -7,9 +7,9 @@ import io.scanbot.sdk.docprocessing.PdfPagesExtractor
 import io.scanbot.sdk.documentqualityanalyzer.DocumentQualityAnalyzer
 import io.scanbot.sdk.ocr.OcrEngine
 import io.scanbot.sdk.ocr.OcrEngineManager
+import io.scanbot.sdk.pdf.PdfGenerator
 import io.scanbot.sdk.persistence.fileio.FileIOProcessor
 import io.scanbot.sdk.persistence.page.PageFileStorage
-import io.scanbot.sdk.process.PdfGenerator
 import io.scanbot.sdk.tiff.TiffGeneratorManager
 import io.scanbot.sdk.tiffgeneration.TiffGenerator
 
diff --git a/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/PdfFromDocumentSnippet.kt b/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/PdfFromDocumentSnippet.kt
@@ -83,7 +83,7 @@ class PdfFromDocumentSnippet : AppCompatActivity() {
             pageFit = PageFit.NONE,
             resamplingMethod = ResamplingMethod.NONE,
         )
-        val result = pdfGenerator.generateFromDocument(
+        val result = pdfGenerator.generate(
             document,
             config
         )
diff --git a/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/PdfFromImageSnippet.kt b/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/PdfFromImageSnippet.kt
@@ -56,8 +56,8 @@ class PdfFromImageSnippet : AppCompatActivity() {
             // notify the generator that the images are encrypted with global sdk-encryption settings
             val encryptionEnabled = false
             // Join the images into a PDF file.
-            val pdfFile = pdfGenerator.generateFromUris(
-                imageFileUris = list.toTypedArray(),
+            val pdfFile = pdfGenerator.generate(
+                imageFileUris = list,
                 sourceFilesEncrypted = encryptionEnabled,
                 config
             ).getOrNull()
diff --git a/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/ResultApi.kt b/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/ResultApi.kt
@@ -0,0 +1,105 @@
+package com.example.scanbot.doc_code_snippet
+
+import io.scanbot.common.Result
+import io.scanbot.common.getOrDefault
+import io.scanbot.common.getOrNull
+import io.scanbot.common.getOrThrow
+import io.scanbot.common.mapFailure
+import io.scanbot.common.mapSuccess
+import io.scanbot.common.onFailure
+import io.scanbot.common.onSuccess
+import io.scanbot.sdk.barcode.BarcodeFormat
+import io.scanbot.sdk.barcode.BarcodeScannerResult
+import io.scanbot.sdk.barcode.ScanbotSdkBarcodeScanner
+import io.scanbot.sdk.documentscanner.ScanbotSdkDocumentScanner
+import io.scanbot.sdk.image.ImageRef
+
+class ResultApi {
+    // @Tag("Handle Result with when/switch")
+    fun processResultWithSwitch(result: Result<BarcodeScannerResult>) = when (result) {
+        is Result.Success<*> -> {
+            val barcodeResult = result.data
+            // Handle successful result
+        }
+
+        is Result.ComponentUnavailableError,
+        is Result.IllegalStateError,
+        is Result.InvalidArgumentError,
+        is Result.InvalidDataError,
+        is Result.InvalidImageRefError,
+        is Result.InvalidLicenseError,
+        is Result.IoError,
+        is Result.NullPointerError,
+        is Result.OperationCanceledError,
+        is Result.OutOfMemoryError,
+        is Result.TimeoutError,
+        is Result.UnknownError -> {
+            // all Result.[ERROR_NAME] are also of type `Result.Unexpected` and can be handled together as throwable errors or logged etc.
+            val exception = result.message
+            // Handle error
+            println("Error scanning barcodes: ${exception}")
+        }
+    }
+    // @EndTag("Handle Result with when/switch")
+
+    // @Tag("Handle Result with getter functions")
+    fun proceedWithGetters(result: Result<BarcodeScannerResult>) {
+        // get value or null if unsuccessful
+        val nullableResult = result.getOrNull()
+        // get value or throw exception if unsuccessful then handle exception with try-catch
+        val nonNullableResult = result.getOrThrow()
+        // get value or put default value if unsuccessful
+        val resultOrDefaultValue = result.getOrDefault(
+            BarcodeScannerResult(
+                emptyList(),
+                false
+            )
+        ) // get value or throw exception if unsuccessful then handle exception with try-catch
+    }
+    // @EndTag("Handle Result with getter functions")
+
+    // @Tag("Handle Result with chain API")
+    fun processResultWithChainApi(result: Result<BarcodeScannerResult>) {
+        // handle success and failure in a chained way without nesting and result type checking
+        result.onSuccess { barcodeResult ->
+            // Handle successful barcode scanning result
+            val barcodes = barcodeResult.barcodes
+            // Process barcodes as needed
+        }.onFailure { exception ->
+            // Handle error during barcode scanning
+            println("Error scanning barcodes: ${exception.message}")
+        }
+
+        // chained transformations
+        val barcodeSize = result.mapSuccess { barcodeResult ->
+            // Transform the successful result to another successful result
+            barcodeResult.barcodes.size // or Return Result.Unexpected in case of error
+            //Result.IllegalStateError("Transformation error") // example of returning an error during transformation
+        }.mapFailure { exception ->
+            // Transform the error to a default value
+            0
+        }.getOrNull()
+    }
+    // @EndTag("Handle Result with chain API")
+
+    fun chainWithScannerCall(
+        image: ImageRef,
+        barcoderScanner: ScanbotSdkBarcodeScanner,
+        documentScanner: ScanbotSdkDocumentScanner
+    ) {
+        // @Tag("Chain Result with SDK calls")
+        val polygon = barcoderScanner.run(image)
+            .mapSuccess { barcodeScanResult ->
+                // Transform barcode scan result to document scan result if the document contains barcode with specified type
+                if (barcodeScanResult.barcodes.none { item -> item.format == BarcodeFormat.QR_CODE }) {
+                    // return from mapSuccess with Result.IllegalStateError
+                    throw Result.IllegalStateError("Document should contain unique qr code to be accepted")
+                }
+                // if result of document scanning is failed due to issues it will trigger mapSuccess function to return Unexpected Result type
+                val documentScanResult = documentScanner.run(image).getOrReturn()
+                // return document polygon if scanning result if successful
+                documentScanResult.pointsNormalized
+            }.getOrDefault(emptyList())
+        // @EndTag("Chain Result with SDK calls")
+    }
+}
diff --git a/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/ResultJ.java b/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/doc_code_snippet/ResultJ.java
@@ -0,0 +1,21 @@
+package com.example.scanbot.doc_code_snippet;
+
+import android.util.Log;
+
+import io.scanbot.common.Result;
+import io.scanbot.sdk.barcode.BarcodeScannerResult;
+
+public class ResultJ {
+
+    // @Tag("Handle Result with ifs")
+    public void result(Result<BarcodeScannerResult> result) {
+        if (result instanceof Result.Success) {
+            BarcodeScannerResult barcodeScannerResult = ((Result.Success<BarcodeScannerResult>) result).getData();
+            // Handle success
+        } else if (result instanceof Result.Unexpected) {
+            String message = ((Result.Unexpected) result).getMessage();
+            // Handle failure
+            Log.e("TAG", "Barcode scanning failed: " + message);
+        }
+    }
+}
diff --git a/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/usecases/GeneratePdfForSharingUseCase.kt b/document-scanner-ready-to-use-ui-example/app/src/main/java/com/example/scanbot/usecases/GeneratePdfForSharingUseCase.kt
@@ -2,12 +2,12 @@ package com.example.scanbot.usecases
 
 import com.example.scanbot.sharing.ISharingDocumentStorage
 import com.example.scanbot.sharing.ensureFileExists
-import io.scanbot.sdk.docprocessing.Document
 import java.io.File
 import javax.inject.Inject
+import io.scanbot.sdk.docprocessing.Document
+import io.scanbot.sdk.pdf.PdfGenerator
 import io.scanbot.sdk.pdfgeneration.PageSize
 import io.scanbot.sdk.pdfgeneration.PdfConfiguration
-import io.scanbot.sdk.process.PdfGenerator
 
 class GeneratePdfForSharingUseCase @Inject constructor(
     sharingDocumentStorage: ISharingDocumentStorage,
@@ -17,7 +17,7 @@ class GeneratePdfForSharingUseCase @Inject constructor(
     override suspend fun generateFilesForDocument(documentSharingDir: File, document: Document): List<File> {
         val sharingPdfFile =
             documentSharingDir.ensureFileExists().resolve("${documentSharingDir.name}.pdf")
-        pdfGenerator.generateFromDocument(document, sharingPdfFile, PdfConfiguration.default().copy(pageSize = PageSize.A4))
+        pdfGenerator.generate(document, sharingPdfFile, PdfConfiguration.default().copy(pageSize = PageSize.A4))
         return listOf(sharingPdfFile)
     }
 }
diff --git a/document-scanner-ready-to-use-ui-example/build.gradle b/document-scanner-ready-to-use-ui-example/build.gradle
@@ -1,5 +1,5 @@
 
 plugins {
-    id("com.android.application") version "8.3.2" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.23" apply false
+    id("com.android.application") version '8.13.0' apply false
+    id("org.jetbrains.kotlin.android") version "2.2.20" apply false
 }
diff --git a/document-scanner-ready-to-use-ui-example/gradle/wrapper/gradle-wrapper.properties b/document-scanner-ready-to-use-ui-example/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 #Tue Jun 13 15:13:31 CEST 2023
 distributionBase=GRADLE_USER_HOME
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
 distributionPath=wrapper/dists
 zipStorePath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
diff --git a/document-scanner-ready-to-use-ui-example/settings.gradle.kts b/document-scanner-ready-to-use-ui-example/settings.gradle.kts
@@ -16,14 +16,6 @@ dependencyResolutionManagement {
         // Scanbot SDK maven repos:
         maven(url = "https://nexus.scanbot.io/nexus/content/repositories/releases/")
         maven(url = "https://nexus.scanbot.io/nexus/content/repositories/snapshots/")
-        val stagingNexusLogin = System.getenv()["STAGING_NEXUS_LOGIN"] ?: providers.gradleProperty("STAGING_NEXUS_LOGIN").orNull
-        val stagingNexusPassword = System.getenv()["STAGING_NEXUS_PASSWORD"] ?: providers.gradleProperty("STAGING_NEXUS_PASSWORD").orNull
-        maven(url = "https://nexus2-staging.scanbot.io/nexus/content/repositories/snapshots/") {
-            credentials {
-                username = stagingNexusLogin
-                password = stagingNexusPassword
-            }
-        }
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`
`2`	`2`	`plugins {`
`3`		`- id "com.android.application" version "8.3.2" apply false`
`4`		`- id "org.jetbrains.kotlin.android" version "1.9.23" apply false`
	`3`	`+ id "com.android.application" version '8.13.0' apply false`
	`4`	`+ id "org.jetbrains.kotlin.android" version "2.2.20" apply false`
`5`	`5`	`}`
`6`	`6`
`7`	`7`	`allprojects {`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ android {`
`39`	`39`	`}`
`40`	`40`	`}`
`41`	`41`
`42`		`-def scanbotSdkVersion = "8.0.0.39-STAGING-SNAPSHOT"`
	`42`	`+def scanbotSdkVersion = "8.0.0_RESULT.54-STAGING-SNAPSHOT"`
`43`	`43`
`44`	`44`	`dependencies {`
`45`	`45`
Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ class PdfFromDocumentSnippet : AppCompatActivity() {`
`83`	`83`	`pageFit = PageFit.NONE,`
`84`	`84`	`resamplingMethod = ResamplingMethod.NONE,`
`85`	`85`	`)`
`86`		`- val result = pdfGenerator.generateFromDocument(`
	`86`	`+ val result = pdfGenerator.generate(`
`87`	`87`	`document,`
`88`	`88`	`config`
`89`	`89`	`)`