### QR Code Scanner Integration Example

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Launches a QR code scanner and handles the result. This example demonstrates how to register for the activity result, launch the scanner, and process success, cancellation, permission denial, or error states.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    when (result) {
        is QRResult.QRSuccess -> {
            val content = result.content
            Toast.makeText(this, "QR Code: ${content.rawValue}", Toast.LENGTH_SHORT).show()
        }
        is QRResult.QRUserCanceled -> {
            // User closed the scanner
        }
        is QRResult.QRMissingPermission -> {
            // Camera permission denied
        }
        is QRResult.QRError -> {
            Log.e("QRScanner", "Error:", result.exception)
        }
    }
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding.scanButton.setOnClickListener { scanQrCodeLauncher.launch(null) }
}
```

--------------------------------

### Launch QR Scanner with Animations

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/quick-start.md

This example demonstrates how to launch the QR code scanner with custom activity transition animations using ActivityOptionsCompat. Ensure the shared element name matches the XML layout.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    // Handle result
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    
    findViewById<Button>(R.id.scanButton).setOnClickListener { view ->
        val options = ActivityOptionsCompat.makeSceneTransitionAnimation(
            this,
            view,
            "shared_scan_element"
        )
        scanQrCodeLauncher.launch(null, options)
    }
}
```

--------------------------------

### Launch Map with GeoPoint

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/content-types.md

Opens a map application to display the coordinates from a GeoPoint. Ensure the device has a map application installed.

```kotlin
when (val content = result.content) {
    is QRContent.GeoPoint -> {
        val uri = Uri.parse("geo:${content.lat},${content.lng}")
        val intent = Intent(Intent.ACTION_VIEW, uri)
        startActivity(intent)
    }
}
```

--------------------------------

### Handling Different QR Content Types

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Provides examples of how to process various types of scanned QR code content, such as URLs, Wi-Fi credentials, and plain text, using pattern matching on the QRContent sealed class.

```kotlin
val content: QRContent = ... // obtained from QRResult.QRSuccess

when (content) {
    is QRContent.URL -> {
        val url = content.url
        val title = content.title
        Log.d("Content", "URL: $url, Title: $title")
    }
    is QRContent.Wifi -> {
        val ssid = content.ssid
        val password = content.password
        Log.d("Content", "WiFi: SSID=$ssid, Password=$password")
    }
    is QRContent.Sms -> {
        val phoneNumber = content.phoneNumber
        val message = content.message
        Log.d("Content", "SMS to $phoneNumber: $message")
    }
    is QRContent.Email -> {
        val emailAddress = content.emailAddress
        val subject = content.subject
        Log.d("Content", "Email to $emailAddress, Subject: $subject")
    }
    is QRContent.Phone -> {
        val phoneNumber = content.phoneNumber
        val type = content.type
        Log.d("Content", "Phone: $phoneNumber, Type: $type")
    }
    is QRContent.GeoPoint -> {
        val latitude = content.latitude
        val longitude = content.longitude
        Log.d("Content", "GeoPoint: $latitude, $longitude")
    }
    is QRContent.ContactInfo -> {
        val name = content.personName.firstName
        Log.d("Content", "Contact: $name")
    }
    is QRContent.CalendarEvent -> {
        val description = content.description
        Log.d("Content", "Calendar Event: $description")
    }
    is QRContent.Plain -> {
        val text = content.text
        Log.d("Content", "Plain Text: $text")
    }
}
```

--------------------------------

### Customizing Scanner UI Overlay

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Provides examples of how to customize the visual appearance of the scanner's overlay, including setting custom text and drawable resources.

```kotlin
val configWithText = ScannerConfig.Builder()
    .setOverlayStringRes(R.string.custom_scan_text)
    .build()

val configWithDrawable = ScannerConfig.Builder()
    .setOverlayDrawableRes(R.drawable.custom_scan_overlay)
    .build()

// Launch scanner with custom UI
// scanCustomCode.launch(configWithText)
```

--------------------------------

### Handle QR Scan Success

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/results.md

Example of how to process a successful QR code scan result. It demonstrates handling different content types like plain text, URLs, and Wi-Fi credentials.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    when (result) {
        is QRResult.QRSuccess -> {
            val content = result.content
            when (content) {
                is QRContent.Plain -> Toast.makeText(this, content.rawValue, Toast.LENGTH_SHORT).show()
                is QRContent.Url -> startActivity(Intent(Intent.ACTION_VIEW, Uri.parse(content.url)))
                is QRContent.Wifi -> handleWifi(content)
                else -> {}
            }
        }
    }
}
```

--------------------------------

### ScannerConfig Kotlin DSL Usage

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/types.md

Example of creating a ScannerConfig using Kotlin DSL. This provides a more concise way to configure the scanner.

```kotlin
val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
}
```

--------------------------------

### Handle QRContent.Url in Android

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/content-types.md

Example of how to handle parsed URL content from a QR code in an Android application. Launches an Intent to view the URL if the content is of type QRContent.Url.

```kotlin
when (val content = result.content) {
    is QRContent.Url -> {
        val intent = Intent(Intent.ACTION_VIEW, Uri.parse(content.url))
        startActivity(intent)
    }
}
```

--------------------------------

### Permission Request Flow

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

Illustrates the sequence of checks and actions for requesting camera permission. If granted, the camera starts; if denied, the activity finishes with a specific result.

```plaintext
requestCameraPermissionIfMissing()
  ├─ Check CAMERA permission
  ├─ If granted → startCamera()
  └─ If denied → setResult(RESULT_MISSING_PERMISSION) → finish()
```

--------------------------------

### Scan Custom Barcodes

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/00-START-HERE.md

Launches a custom barcode scanner with configurable formats and UI options. Requires a `ScannerConfig` object for setup.

```APIDOC
## Scan Custom Barcodes

### Description
Launches a custom barcode scanner with configurable formats and UI options. Requires a `ScannerConfig` object for setup.

### Method
`registerForActivityResult(ScanCustomCode())`

### Parameters
- `config` (`ScannerConfig`): Configuration object for the scanner.

### Request Example
```kotlin
val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_CODE_128))
    setShowTorchToggle(true)
}
scanCustomCodeLauncher.launch(config)
```

### Response
- `QRResult.QRSuccess(content)`: Contains the scanned content.
- `QRResult.QRError(exception)`: Contains the exception if an error occurred.
- `QRResult.QRUserCanceled`: If the user cancels the scan.
- `QRResult.QRMissingPermission`: If camera permission is missing.
```

--------------------------------

### Handle Plain QR Content in Scanner Result

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/content-types.md

Example of how to access and log the raw string value when a QR code scan result is of type QRContent.Plain.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    when (val content = result.content) {
        is QRContent.Plain -> {
            Log.d("Scanner", "Text: ${content.rawValue}")
        }
    }
}
```

--------------------------------

### QRScannerActivity onFailure Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Handles errors during camera setup or analysis. It sets an error result, checks for resolvable errors with MlKitErrorHandler, and either finishes the activity or shows an error dialog.

```kotlin
private fun onFailure(exception: Exception)
```

--------------------------------

### QRContent.CalendarEvent Type Definition

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Defines the structure for scanned calendar event content, including start and end times.

```kotlin
sealed class QRContent {
    // ... other content types
    data class CalendarEvent(
        val description: String? = null,
        val location: String? = null,
        val organizer: String? = null,
        val status: String? = null,
        val startDateTime: CalendarDateTime? = null,
        val endDateTime: CalendarDateTime? = null
    ) : QRContent() {
        data class CalendarDateTime(
            val timestamp: Long,
            val timezone: String? = null
        )
    }
    // ... other content types
}
```

--------------------------------

### QRScannerActivity startCamera Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Initializes and binds CameraX use cases for preview and image analysis. It selects the camera, sets up the UI, and handles potential binding errors.

```kotlin
private fun startCamera()
```

--------------------------------

### Add Wi-Fi Network Using QR Content

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/content-types.md

Demonstrates how to use the SSID and password from a QRContent.Wifi object to configure and add a new Wi-Fi network.

```kotlin
when (val content = result.content) {
    is QRContent.Wifi -> {
        val network = WifiConfiguration().apply {
            SSID = "${content.ssid}"
            preSharedKey = "${content.password}"
        }
        wifiManager.addNetwork(network)
    }
}
```

--------------------------------

### QRScannerActivity onCreate Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Initializes the scanner by setting up UI, handling edge-to-edge display, applying configuration, setting up an executor for ML Kit analysis, and managing camera permissions and startup.

```kotlin
override fun onCreate(savedInstanceState: Bundle?)
```

--------------------------------

### Selecting Camera Source

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Demonstrates how to specify whether the front or rear camera should be used for scanning.

```kotlin
val rearCameraConfig = ScannerConfig.Builder()
    .setCameraFacing(CameraFacing.BACK)
    .build()

val frontCameraConfig = ScannerConfig.Builder()
    .setCameraFacing(CameraFacing.FRONT)
    .build()

// Launch scanner with desired camera
// scanCustomCode.launch(rearCameraConfig)
```

--------------------------------

### Pattern Matching for QRResult

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/types.md

Demonstrates how to use a when statement for exhaustive pattern matching on QRResult subtypes.

```kotlin
when (result) {
    is QRResult.QRSuccess -> {}
    is QRResult.QRUserCanceled -> {}
    is QRResult.QRMissingPermission -> {}
    is QRResult.QRError -> {}
}
```

--------------------------------

### Android Build Configuration

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Configures the Android build settings for the quickie library, including namespace, resource prefix, and view binding.

```kotlin
android {
  namespace = "io.github.g00fy2.quickie"
  resourcePrefix = "quickie"
  
  defaultConfig {
    consumerProguardFiles("consumer-proguard-rules.pro")
  }
  
  buildFeatures {
    viewBinding = true
  }
}
```

--------------------------------

### Initialize QROverlayView

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Constructor for the QROverlayView. Use this to create an instance of the overlay view in your layout.

```kotlin
internal class QROverlayView @JvmOverloads constructor(
  context: Context,
  attrs: AttributeSet? = null,
  defStyleAttr: Int = 0
) : FrameLayout(context, attrs, defStyleAttr)
```

--------------------------------

### Configuration Methods

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Methods to customize the appearance and behavior of the QROverlayView.

```APIDOC
## setCustomText

### Description
Sets the overlay hint text from a string resource.

### Parameters
#### Path Parameters
- **stringRes** (Int) - Required - String resource ID (0 to use default)

### Example
```kotlin
binding.overlayView.setCustomText(R.string.scan_barcode_hint)
```
```

```APIDOC
## setCustomIcon

### Description
Sets the overlay icon from a drawable resource.

### Parameters
#### Path Parameters
- **drawableRes** (Int?) - Required - Drawable resource ID (null to hide icon)

### Example
```kotlin
binding.overlayView.setCustomIcon(R.drawable.ic_barcode)
```
```

```APIDOC
## setHorizontalFrameRatio

### Description
Sets the aspect ratio of the scanning frame.

### Parameters
#### Path Parameters
- **ratio** (Float) - Required - Width/height ratio (1.0 = square, 2.0 = 2:1 wide)

### Example
```kotlin
binding.overlayView.setHorizontalFrameRatio(2.2f)
```
```

```APIDOC
## setCloseVisibilityAndOnClick

### Description
Shows/hides close button and sets click callback.

### Parameters
#### Path Parameters
- **visible** (Boolean) - Required - Whether to show the button
- **onClick** (() -> Unit) - Required - Callback when button is clicked
```

```APIDOC
## setTorchVisibilityAndOnClick

### Description
Shows/hides flashlight toggle button and sets click callback.

### Parameters
#### Path Parameters
- **visible** (Boolean) - Required - Whether to show the button
- **onClick** ((Boolean) -> Unit) - Required - Callback with desired torch state (true = on)
```

```APIDOC
## setTorchState

### Description
Updates the visual state of the torch button.

### Parameters
#### Path Parameters
- **on** (Boolean) - Required - Whether torch is currently on
```

--------------------------------

### Launch QR Scanner in Activity/Fragment

Source: https://github.com/g00fy2/quickie/blob/main/README.md

Register the ScanQRCode ActivityResultContract and use the returned launcher to open the QR scanner. Handle the result in the callback.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    // handle QRResult
}

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    …
    binding.button.setOnClickListener { scanQrCodeLauncher.launch(null) }
}
```

--------------------------------

### Launch QR Scanner with Custom Configuration

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Launches a custom QR code scanner using ScanCustomCode. Configure barcode formats, overlay resources, haptic feedback, and UI toggles.

```kotlin
val scanCustomCodeLauncher = registerForActivityResult(ScanCustomCode()) { result ->
    if (result is QRResult.QRSuccess) {
        val barcode = result.content
        when (barcode) {
            is QRContent.Plain -> handlePlainText(barcode)
            is QRContent.Url -> openUrl(barcode.url)
            is QRContent.Wifi -> connectToWifi(barcode)
            else -> {}
        }
    }
}

val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_CODE_128, BarcodeFormat.FORMAT_EAN_13))
    setOverlayStringRes(R.string.scan_barcode)
    setOverlayDrawableRes(R.drawable.ic_barcode)
    setHapticSuccessFeedback(true)
    setShowTorchToggle(true)
    setShowCloseButton(true)
}

scanCustomCodeLauncher.launch(config)
```

--------------------------------

### Run All Unit Tests with Gradle

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Execute all unit tests defined in the project using the Gradle wrapper. This command is typically used for quick checks during development.

```bash
./gradlew test
```

--------------------------------

### Handle QRContent.Sms in Android

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/content-types.md

Example of how to handle parsed SMS content from a QR code in an Android application. Creates an Intent to send an SMS with the specified phone number and message body if the content is of type QRContent.Sms.

```kotlin
when (val content = result.content) {
    is QRContent.Sms -> {
        val uri = Uri.parse("smsto:${content.phoneNumber}")
        val intent = Intent(Intent.ACTION_SENDTO, uri).apply {
            putExtra("sms_body", content.message)
        }
        startActivity(intent)
    }
}
```

--------------------------------

### QRScannerActivity setupEdgeToEdgeUI Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Configures the Activity for an edge-to-edge display mode. It sets up a listener for window insets to correctly apply padding for system bars.

```kotlin
private fun setupEdgeToEdgeUI()
```

--------------------------------

### Quickie Architecture Overview

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/README.md

Illustrates the flow of data and control within the Quickie barcode scanner, from user interaction to result delivery.

```text
User App
  ↓
registerForActivityResult(ScanQRCode or ScanCustomCode)
  ↓
ScanQRCode/ScanCustomCode.createIntent()
  ↓
QRScannerActivity (Camera + UI)
  ├─ CameraX (Preview + ImageAnalysis)
  │  ├─ QRCodeAnalyzer
  │  │  └─ ML Kit BarcodeScanner
  │  └─ QROverlayView (Drawing overlay)
  ├─ Permission handling
  └─ Result setting
  ↓
QRScannerActivity.onSuccess() / onFailure()
  ├─ Barcode conversion (ML Kit → Parcelable)
  └─ Intent result delivery
  ↓
ScanQRCode/ScanCustomCode.parseResult()
  ├─ Parcelable → QRContent conversion
  └─ QRResult creation
  ↓
Activity result callback
  └─ when (result) pattern matching
```

--------------------------------

### Assemble Bundled Debug Build Variant

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Build the bundled debug variant of the Quickie library. This command is used to prepare a specific build configuration for testing or deployment.

```bash
./gradlew :quickie:assembleBundledDebug
```

--------------------------------

### Pattern Matching for QRContent Subtypes

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/types.md

Demonstrates pattern matching on various QRContent subtypes to extract specific data like URLs, Wi-Fi credentials, phone numbers, etc.

```kotlin
when (val content = result.content) {
    is QRContent.Plain -> {
        val text = content.rawValue
    }
    is QRContent.Url -> {
        val url = content.url
        val title = content.title
    }
    is QRContent.Wifi -> {
        val ssid = content.ssid
        val password = content.password
        val encryption = content.encryptionType
    }
    is QRContent.Phone -> {
        val number = content.number
        val type = content.type
    }
    is QRContent.Email -> {
        val address = content.address
        val subject = content.subject
        val body = content.body
    }
    is QRContent.Sms -> {
        val phoneNumber = content.phoneNumber
        val message = content.message
    }
    is QRContent.GeoPoint -> {
        val latitude = content.lat
        val longitude = content.lng
    }
    is QRContent.ContactInfo -> {
        val name = content.name.formattedName
        val organization = content.organization
        val phones = content.phones
        val emails = content.emails
        val addresses = content.addresses
    }
    is QRContent.CalendarEvent -> {
        val summary = content.summary
        val startDate = content.start
        val endDate = content.end
        val location = content.location
    }
}
```

--------------------------------

### Apply Build Plugins

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Apply common Android and Kotlin build plugins for library, parcelization, and documentation generation.

```kotlin
alias(libs.plugins.android.library)
alias(libs.plugins.kotlin.parcelize)
alias(libs.plugins.kotlin.dokka.javadoc)
```

--------------------------------

### QRCodeAnalyzer Constructor

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Initializes the QRCodeAnalyzer with barcode formats, success, failure, and pass completion callbacks. Use this to set up the barcode analysis process.

```kotlin
internal class QRCodeAnalyzer(
  private val barcodeFormats: IntArray,
  private val onSuccess: ((Barcode) -> Unit),
  private val onFailure: ((Exception) -> Unit),
  private val onPassCompleted: ((Boolean) -> Unit)
) : ImageAnalysis.Analyzer
```

--------------------------------

### createIntent Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Creates an intent to launch the QRScannerActivity. The input parameter is unused and should be null.

```kotlin
override fun createIntent(context: Context, input: Nothing?): Intent
```

--------------------------------

### Handling Scanner Errors and Permissions

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Illustrates how to handle potential errors during the scanning process and cases where camera permissions are denied.

```kotlin
val scannerLauncher = registerForActivityResult(ScanQRCode()) {
    when (it) {
        is QRResult.QRSuccess -> {
            // Process success
        }
        is QRResult.QRUserCanceled -> {
            // Handle user cancellation
        }
        is QRResult.QRMissingPermission -> {
            // Request camera permission
            // Example: ActivityCompat.requestPermissions(activity, arrayOf(Manifest.permission.CAMERA), CAMERA_PERMISSION_REQUEST_CODE)
            Log.e("ScanError", "Camera permission is required.")
        }
        is QRResult.QRError -> {
            // Handle other errors
            Log.e("ScanError", "Scan failed: ${it.exception.message}")
        }
    }
}
```

--------------------------------

### Initiate QR Code Scan

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

Launches a QR code scan using either the default or a custom configuration. The default option requires no arguments, while the custom option accepts a ScannerConfig builder.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    // Handle result
}
scanQrCodeLauncher.launch(null)
```

```kotlin
val scanCustomCodeLauncher = registerForActivityResult(ScanCustomCode()) { result ->
    // Handle result
}
val config = ScannerConfig.build { /* configure */ }
scanCustomCodeLauncher.launch(config)
```

--------------------------------

### Add Quickie Dependency

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/quick-start.md

Include the quickie library dependency in your app's build.gradle file. Choose either the bundled or unbundled variant based on your needs.

```kotlin
dependencies {
    // Bundled variant (model included in app)
    implementation("io.github.g00fy2.quickie:quickie-bundled:1.12.0")
    
    // OR unbundled variant (model downloaded from Play Services)
    // implementation("io.github.g00fy2.quickie:quickie-unbundled:1.12.0")
}
```

--------------------------------

### Version Catalog Configuration

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Defines versions, libraries, and plugins in a central TOML file for consistent dependency management.

```toml
[versions]
androidx-appcompat = "1.x.x"
androidx-core = "1.x.x"
androidx-camera = "1.x.x"
mlkit-barcode = "17.x.x"

[libraries]
androidx-appcompat = { group = "androidx.appcompat", name = "appcompat", version.ref = "androidx-appcompat" }
androidx-core = { group = "androidx.core", name = "core", version.ref = "androidx-core" }
androidx-camera = { group = "androidx.camera", name = "camera-core", version.ref = "androidx-camera" }
androidx-camera-lifecycle = { group = "androidx.camera", name = "camera-lifecycle", version.ref = "androidx-camera" }
androidx-camera-preview = { group = "androidx.camera", name = "camera-preview", version.ref = "androidx-camera" }
mlkit-barcode-scanning = { group = "com.google.mlkit", name = "barcode-scanning", version.ref = "mlkit-barcode" }
mlkit-barcode-scanning-gms = { group = "com.google.android.gms", name = "play-services-mlkit-barcode-scanning", version.ref = "mlkit-barcode" }

[plugins]
android-library = { id = "com.android.library", version = "x.x.x" }
kotlin-parcelize = { id = "kotlin-parcelize" }
kotlin-dokka-javadoc = { id = "org.jetbrains.dokka", version = "x.x.x" }
```

--------------------------------

### Add Quickie Bundled Dependency

Source: https://github.com/g00fy2/quickie/blob/main/README.md

Include this dependency to bundle the ML Kit model directly within your application. This increases app size but makes it independent of Google Services.

```kotlin
implementation("io.github.g00fy2.quickie:quickie-bundled:1.12.0")
```

--------------------------------

### Product Flavors and Source Sets Configuration

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Defines product flavors for ML Kit integration (bundled and unbundled) and configures flavor-specific source sets.

```kotlin
flavorDimensions += "mlkit"

productFlavors {
  create("bundled").dimension = "mlkit"
  create("unbundled").dimension = "mlkit"
}

sourceSets {
  getByName("bundled").java.directories.add("src/bundled/kotlin")
  getByName("unbundled").java.directories.add("src/unbundled/kotlin")
}
```

--------------------------------

### Build ScannerConfig with DSL

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Use the `build` function from the companion object to create a ScannerConfig instance using a Kotlin DSL. This function accepts a lambda to configure the builder.

```kotlin
val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_CODE_128))
    setOverlayStringRes(R.string.scan_code)
    setShowTorchToggle(true)
    setShowCloseButton(true)
    setHapticSuccessFeedback(true)
}
```

--------------------------------

### Configuring Barcode Format Selection

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Shows how to specify which barcode formats the scanner should recognize, allowing for single, multiple, or all supported formats.

```kotlin
// Scan only QR codes
val configSingle = ScannerConfig.Builder()
    .setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
    .build()

// Scan QR codes and Code 128 barcodes
val configMultiple = ScannerConfig.Builder()
    .setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE, BarcodeFormat.FORMAT_CODE_128))
    .build()

// Scan all supported formats
val configAll = ScannerConfig.Builder()
    .setBarcodeFormats(BarcodeFormat.values().toList())
    .build()

// Launch scanner with one of the configurations
// scanCustomCode.launch(configSingle)
```

--------------------------------

### ScannerConfig Builder Pattern (Traditional)

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

Demonstrates the traditional builder pattern for configuring the QR code scanner with various options.

```kotlin
// Traditional builder
val config = ScannerConfig.Builder()
    .setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
    .setShowTorchToggle(true)
    .build()
```

--------------------------------

### Select Camera Source

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/quick-start.md

Choose between the front or rear camera for scanning operations by setting the `useFrontCamera` option in the scanner configuration.

```kotlin
val config = ScannerConfig.build {
    // Use front camera instead of rear
    setUseFrontCamera(true)
}
```

--------------------------------

### Add Testing Dependencies

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Include JUnit 5 for unit tests and the platform launcher for test discovery.

```kotlin
testImplementation(libs.test.junit)
testRuntimeOnly(libs.test.junit.platformLauncher)
```

--------------------------------

### Assemble Unbundled Debug Build Variant

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Build the unbundled debug variant of the Quickie library. This prepares a build configuration where ML Kit dependencies are handled externally.

```bash
./gradlew :quickie:assembleUnbundledDebug
```

--------------------------------

### Add Quickie Unbundled Dependency

Source: https://github.com/g00fy2/quickie/blob/main/README.md

Include this dependency to use the unbundled ML Kit model, which is downloaded via Play Services. This results in a smaller app size increase.

```kotlin
implementation("io.github.g00fy2.quickie:quickie-unbundled:1.12.0")
```

--------------------------------

### Scan QR Code with Custom Configuration

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Shows how to initiate a QR code scan with custom settings using the ScanCustomCode ActivityResultContract. This allows for specifying barcode formats and other UI customizations.

```kotlin
val scanCustomCode = registerForActivityResult(ScanCustomCode()) {
    // Handle the result, similar to ScanQRCode
    when (it) {
        is QRResult.QRSuccess -> {
            Log.d("QRScan", "Scanned content: ${it.content}")
        }
        // ... other result types
        else -> { /* Handle other results */ }
    }
}

// Example of creating an intent with custom configuration
val config = ScannerConfig.Builder()
    .setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE, BarcodeFormat.FORMAT_CODE_128))
    .setOverlayStringRes(R.string.custom_overlay_text)
    .build()

scanCustomCode.launch(config)
```

--------------------------------

### createIntent

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Creates an intent to launch the QRScannerActivity with custom configuration.

```APIDOC
## createIntent

### Description
Creates an intent to launch the QRScannerActivity with custom configuration.

### Method
```kotlin
override fun createIntent(context: Context, input: ScannerConfig): Intent
```

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| context | Context | Yes | — | The application context |
| input | ScannerConfig | Yes | — | Configuration object defining barcode formats and UI options |

### Request Example
```kotlin
val scanCustomCodeLauncher = registerForActivityResult(ScanCustomCode()) { result ->
    if (result is QRResult.QRSuccess) {
        val barcode = result.content
        when (barcode) {
            is QRContent.Plain -> handlePlainText(barcode)
            is QRContent.Url -> openUrl(barcode.url)
            is QRContent.Wifi -> connectToWifi(barcode)
            else -> {}
        }
    }
}

val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_CODE_128, BarcodeFormat.FORMAT_EAN_13))
    setOverlayStringRes(R.string.scan_barcode)
    setOverlayDrawableRes(R.drawable.ic_barcode)
    setHapticSuccessFeedback(true)
    setShowTorchToggle(true)
    setShowCloseButton(true)
}

scanCustomCodeLauncher.launch(config)
```

### Response
#### Success Response (200)
- **content** (Intent) - An intent targeting QRScannerActivity with configuration attached
```

--------------------------------

### Run Bundled Flavor Tests with Gradle

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Execute tests specifically for the bundled flavor of the application. This is useful for testing the version of the library that includes ML Kit dependencies.

```bash
./gradlew testBundledDebug
```

--------------------------------

### Launch QR Scanner in Jetpack Compose

Source: https://github.com/g00fy2/quickie/blob/main/README.md

Use rememberLauncherForActivityResult to register the ScanQRCode ActivityResultContract within a composable. Launch the scanner via a button click.

```kotlin
@Composable
fun GetQRCodeExample() {
    val scanQrCodeLauncher = rememberLauncherForActivityResult(ScanQRCode()) { result ->
        // handle QRResult
    }
    
    Button(onClick = { scanQrCodeLauncher.launch(null) }) {
    …
}
```

--------------------------------

### ScannerConfig Builder Pattern (Kotlin DSL)

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

Utilizes a Kotlin DSL helper for a more fluent and readable way to configure the QR code scanner.

```kotlin
// Kotlin DSL helper
val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
    setShowTorchToggle(true)
}
```

--------------------------------

### Add AndroidX and Jetpack Libraries

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Include core AndroidX and Jetpack libraries for app functionality and UI.

```kotlin
implementation(libs.androidx.appcompat)
implementation(libs.androidx.core)
implementation(libs.androidx.camera)
implementation(libs.androidx.cameraLifecycle)
implementation(libs.androidx.cameraPreview)
```

--------------------------------

### ProGuard Rules for Quickie Consumer Apps

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

These ProGuard rules are automatically applied to consumer applications. They preserve necessary ML Kit and Quickie API classes while allowing internal code obfuscation.

```proguard
# ML Kit
-keep class com.google.mlkit.vision.barcode.common.Barcode { *; }
-keep class com.google.mlkit.vision.barcode.BarcodeScannerOptions { *; }
-keep class com.google.mlkit.vision.barcode.BarcodeScannerOptions$Builder { *; }

# Keep quickie public API
-keep public class io.github.g00fy2.quickie.ScanQRCode { *; }
-keep public class io.github.g00fy2.quickie.ScanCustomCode { *; }
-keep public class io.github.g00fy2.quickie.QRResult { *; }
-keep public class io.github.g00fy2.quickie.QRResult$* { *; }
-keep public class io.github.g00fy2.quickie.content.QRContent { *; }
-keep public class io.github.g00fy2.quickie.content.QRContent$* { *; }
-keep public class io.github.g00fy2.quickie.config.ScannerConfig { *; }
-keep public class io.github.g00fy2.quickie.config.ScannerConfig$Builder { *; }
-keep public class io.github.g00fy2.quickie.config.BarcodeFormat { *; }
```

--------------------------------

### parseResult

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Parses the activity result and converts it to a QRResult object.

```APIDOC
## parseResult

### Description
Parses the activity result and converts it to a QRResult object.

### Method
```kotlin
override fun parseResult(resultCode: Int, intent: Intent?): QRResult
```

### Parameters
#### Path Parameters
- None

#### Query Parameters
- None

#### Request Body
- None

### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| resultCode | Int | Yes | — | The result code returned by the activity |
| intent | Intent? | No | — | The intent returned by the activity |

### Response
#### Success Response (200)
- **QRResult** - One of QRSuccess, QRUserCanceled, QRMissingPermission, or QRError

### Throws
| Error Type | Condition |
|-----------|-----------|
| IllegalStateException | When resultCode is unknown |
```

--------------------------------

### Publishing Configuration for Variants

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Configures publishing for 'bundledRelease' and 'unbundledRelease' variants, including source JARs.

```kotlin
publishing {
  singleVariant("bundledRelease") {
    withSourcesJar()
  }
  singleVariant("unbundledRelease") {
    withSourcesJar()
  }
}
```

--------------------------------

### Configure Barcode Formats

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/quick-start.md

Optimize scanning speed by selecting specific barcode formats. Use a single format for the fastest detection, multiple for balanced detection, or all for comprehensive scanning.

```kotlin
setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
```

```kotlin
setBarcodeFormats(listOf(
    BarcodeFormat.FORMAT_CODE_128,
    BarcodeFormat.FORMAT_EAN_13
))
```

```kotlin
setBarcodeFormats(listOf(BarcodeFormat.FORMAT_ALL_FORMATS))
```

--------------------------------

### Set All Supported Barcode Formats

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/types.md

Use this snippet to enable detection of all barcode formats supported by the ML Kit library.

```kotlin
setBarcodeFormats(listOf(BarcodeFormat.FORMAT_ALL_FORMATS))
```

--------------------------------

### Handle Missing Camera Permission

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/results.md

Displays a toast message informing the user that camera permission is required when the QRMissingPermission result is received.

```kotlin
when (result) {
    is QRResult.QRMissingPermission -> {
        Toast.makeText(this, "Camera permission required", Toast.LENGTH_SHORT).show()
    }
}
```

--------------------------------

### Declare Camera Permission in Android Manifest

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Add the CAMERA permission to your application's AndroidManifest.xml file. This is required for the Quickie library to access the device's camera.

```xml
<uses-permission android:name="android.permission.CAMERA" />
```

--------------------------------

### Scan QR Codes

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/00-START-HERE.md

Launch the default QR code scanner and handle the result. The result can be one of several content types or an error.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    when (result) {
        is QRResult.QRSuccess -> {
            val content = result.content
            // Handle: Plain, Wifi, Url, Sms, Email, Phone, GeoPoint, ContactInfo, CalendarEvent
        }
        is QRResult.QRError -> { Log.e("Scanner", result.exception.toString()) }
    }
}
scanQrCodeLauncher.launch(null)
```

--------------------------------

### QRCodeAnalyzer analyze Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Processes camera frames for barcode detection using ML Kit. It handles image extraction, ML Kit processing, and callback invocation for success, failure, or completion. Includes error cooldown and proxy closing.

```kotlin
@ExperimentalGetImage
override fun analyze(imageProxy: ImageProxy)
```

--------------------------------

### Add ML Kit Barcode Scanning (Unbundled)

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Integrate ML Kit barcode scanning where the model is delivered via Play Services. The model is downloaded on-demand.

```kotlin
add("unbundledImplementation", libs.mlkit.barcodeScanningGms)
```

--------------------------------

### QRMissingPermission Data Object

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/results.md

Indicates that the user denied the camera permission. Prompt the user to grant the necessary permission.

```kotlin
public data object QRMissingPermission : QRResult()
```

--------------------------------

### QRScannerActivity applyScannerConfig Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Reads and applies scanner configurations from intent extras. This includes settings for barcode formats, overlay appearance, frame ratios, haptic feedback, camera selection, and more.

```kotlin
private fun applyScannerConfig()
```

--------------------------------

### Scan QR Code with Default Settings

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Demonstrates basic QR code scanning using the ScanQRCode ActivityResultContract. This is suitable for general-purpose QR code scanning without custom configurations.

```kotlin
val scanQRCode = registerForActivityResult(ScanQRCode()) {
    // Handle the result
    when (it) {
        is QRResult.QRSuccess -> {
            // Process the scanned content
            Log.d("QRScan", "Scanned content: ${it.content}")
        }
        is QRResult.QRUserCanceled -> {
            Log.d("QRScan", "User canceled the scan")
        }
        is QRResult.QRMissingPermission -> {
            Log.e("QRScan", "Camera permission not granted")
        }
        is QRResult.QRError -> {
            Log.e("QRScan", "An error occurred: ${it.exception.message}")
        }
    }
}
```

--------------------------------

### Set Custom Hint Text

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Sets the overlay hint text using a string resource ID. Pass 0 to revert to the default text.

```kotlin
binding.overlayView.setCustomText(R.string.scan_barcode_hint)
```

--------------------------------

### ScanQRCode Constructor

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Defines the ScanQRCode contract for launching a QR code scanner.

```kotlin
public class ScanQRCode : ActivityResultContract<Nothing?, QRResult>()
```

--------------------------------

### Basic QR Code Scan

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/README.md

Launches a QR code scanner and handles the result, differentiating between success and error states. Use this for standard QR code scanning functionality.

```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    when (result) {
        is QRResult.QRSuccess -> {
            val content = result.content
            // Handle specific content type
        }
        is QRResult.QRError -> {
            Log.e("Scanner", "Error: ${result.exception.message}")
        }
    }
}

scanQrCodeLauncher.launch(null)
```

--------------------------------

### Build ScannerConfig Object

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Finalizes the configuration process and returns the constructed ScannerConfig object.

```kotlin
public fun build(): ScannerConfig
```

--------------------------------

### Parcelable to QRContent Conversion

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

Shows the process of converting a Parcelable object, received via Intent extra, into Quickie's type-safe QRContent sealed class.

```text
Parcelable subclass
  → Intent.toQuickieContentType() (IntentExtensions)
  → QRContent sealed class (Plain, Wifi, Url, etc.)
  → QRSuccess wrapper
```

--------------------------------

### Add ML Kit Barcode Scanning (Bundled)

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Integrate ML Kit barcode scanning with the model bundled directly into the app. This avoids a Play Services dependency.

```kotlin
add("bundledImplementation", libs.mlkit.barcodeScanning)
```

--------------------------------

### ML Kit Barcode to Parcelable Conversion

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

Illustrates the data transformation steps from ML Kit's native Barcode object to a Parcelable subclass, enabling data transfer across process boundaries.

```text
Barcode (ML Kit)
  → toParcelableContentType() (BarcodeExtensions)
  → Parcelable subclass (ContactInfoParcelable, UrlBookmarkParcelable, etc.)
  → Intent extra
```

--------------------------------

### Run Unbundled Flavor Tests with Gradle

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/gradle-configuration.md

Execute tests for the unbundled flavor of the application. This targets the version of the library where ML Kit dependencies are loaded separately.

```bash
./gradlew testUnbundledDebug
```

--------------------------------

### parseResult Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Parses the activity result code and intent into a QRResult object. Throws an IllegalStateException if the resultCode is unknown.

```kotlin
override fun parseResult(resultCode: Int, intent: Intent?): QRResult
```

--------------------------------

### ML Kit BarcodeScanner Lazy Initialization

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Lazily initializes the ML Kit BarcodeScanner with specified formats. Handles potential initialization exceptions and reports them via the onFailure callback. Supports multiple, single, or unknown formats.

```kotlin
private val barcodeScanner by lazy { ... }
```

--------------------------------

### Scan QR Codes

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/00-START-HERE.md

Launches the default QR code scanner. Handles success by providing the scanned content or failure through an error result.

```APIDOC
## Scan QR Codes

### Description
Launches the default QR code scanner. Handles success by providing the scanned content or failure through an error result.

### Method
`registerForActivityResult(ScanQRCode())`

### Parameters
None directly for launch, configuration is implicit via `ScanQRCode()`.

### Request Example
```kotlin
val scanQrCodeLauncher = registerForActivityResult(ScanQRCode()) { result ->
    when (result) {
        is QRResult.QRSuccess -> { /* Handle content */ }
        is QRResult.QRError -> { /* Handle error */ }
    }
}
scanQrCodeLauncher.launch(null)
```

### Response
- `QRResult.QRSuccess(content)`: Contains the scanned content.
- `QRResult.QRError(exception)`: Contains the exception if an error occurred.
- `QRResult.QRUserCanceled`: If the user cancels the scan.
- `QRResult.QRMissingPermission`: If camera permission is missing.
```

--------------------------------

### ScannerConfig Factory Methods

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/types.md

Factory methods for creating ScannerConfig instances using either the traditional builder pattern or Kotlin DSL.

```APIDOC
## ScannerConfig Factory Methods

### Description
Factory methods for creating ScannerConfig instances using either the traditional builder pattern or Kotlin DSL.

### Examples
```kotlin
// Traditional builder
val config = ScannerConfig.Builder()
    .setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
    .build()

// Kotlin DSL
val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
}
```
```

--------------------------------

### QROverlayView Drawing Logic

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Overrides the onDraw method to render the scanning frame, background, and loading indicator. Customizes colors based on the highlighting state.

```kotlin
@Suppress("UnsafeCallOnNullableType")
override fun onDraw(canvas: Canvas)
```

--------------------------------

### Set Overlay String Resource

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Sets the string resource ID for the hint text displayed in the scanner overlay.

```kotlin
public fun setOverlayStringRes(@StringRes stringRes: Int): Builder
```

--------------------------------

### ScanCustomCode Constructor

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

Initializes the ScanCustomCode contract. This contract is used to launch a configurable barcode scanner.

```kotlin
public class ScanCustomCode : ActivityResultContract<ScannerConfig, QRResult>()
```

--------------------------------

### Configure Torch Toggle Button

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Manages the visibility of the flashlight toggle button and provides a callback for its click events. The callback receives the desired torch state (true for on).

```kotlin
binding.overlayView.setTorchVisibilityAndOnClick(visible = true) { isTorchOn -> /* handle torch toggle */ }
```

--------------------------------

### ScannerConfig.build

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/api-reference.md

A Kotlin-friendly DSL function to construct a ScannerConfig object. It accepts a lambda to configure the builder, allowing for customization of various scanner settings.

```APIDOC
## ScannerConfig.build

### Description
A Kotlin-friendly DSL function to build ScannerConfig.

### Method
Static Factory (Kotlin DSL)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```kotlin
val config = ScannerConfig.build {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_CODE_128))
    setOverlayStringRes(R.string.scan_code)
    setShowTorchToggle(true)
    setShowCloseButton(true)
    setHapticSuccessFeedback(true)
}
```

### Response
#### Success Response
- **ScannerConfig** (ScannerConfig) - Configuration object

#### Response Example
```kotlin
// No explicit response example provided, but the return type is ScannerConfig
```
```

--------------------------------

### Create Android Calendar Event Intent

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/content-types.md

Demonstrates how to create an Android Intent to insert a calendar event using data extracted from a QRContent.CalendarEvent. This snippet requires the `android.content.Intent` and `android.provider.CalendarContract.Events` classes.

```kotlin
when (val content = result.content) {
    is QRContent.CalendarEvent -> {
        val intent = Intent(Intent.ACTION_INSERT).apply {
            data = CalendarContract.Events.CONTENT_URI
            putExtra(CalendarContract.Events.TITLE, content.summary)
            putExtra(CalendarContract.Events.DESCRIPTION, content.description)
            putExtra(CalendarContract.Events.EVENT_LOCATION, content.location)
        }
        startActivity(intent)
    }
}
```

--------------------------------

### Public Properties

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

These properties control the visual state of the overlay, such as highlighting and loading indicators.

```APIDOC
## isHighlighted

### Description
Whether the scanning frame should be highlighted (success state). Triggers redraw when changed.

### Type
Boolean
```

```APIDOC
## isLoading

### Description
Whether the loading indicator should be visible. Toggles progress view visibility.

### Type
Boolean
```

--------------------------------

### QRScannerActivity onSuccess Method

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/internal-components.md

Handles successful barcode detection. It stops analysis, provides visual feedback, triggers haptic feedback, converts the barcode data, and finishes the activity with a result.

```kotlin
private fun onSuccess(result: Barcode)
```

--------------------------------

### Parcelable to QRContent Conversion Extension Function

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/architecture.md

An internal extension function to convert a Parcelable object (from Intent) into Quickie's QRContent sealed class.

```kotlin
// Parcelable → QRContent (for public API)
internal fun Intent?.toQuickieContentType(): QRContent
```

--------------------------------

### Scanner Configuration

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/00-START-HERE.md

Provides methods to configure the scanner's behavior and appearance, such as barcode formats and UI elements.

```APIDOC
## Scanner Configuration

### Description
Provides methods to configure the scanner's behavior and appearance, such as barcode formats and UI elements.

### Methods
- `ScannerConfig.build { }`: Builder function to create a `ScannerConfig` object.
- `setBarcodeFormats(formats: List<BarcodeFormat>)`: Sets the list of barcode formats to recognize.
- `setShowTorchToggle(show: Boolean)`: Determines whether to display the torch toggle button.
```

--------------------------------

### ScannerConfig Builder

Source: https://github.com/g00fy2/quickie/blob/main/_autodocs/INDEX.md

Configuration builder for customizing the QR code scanner's behavior and appearance.

```APIDOC
## ScannerConfig Configuration Builder

### Description
Use the `ScannerConfig` builder to define custom settings for the scanner, including supported barcode formats, overlay resources, and other UI elements.

### Method
N/A (Configuration Builder)

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Builder Methods
- **setBarcodeFormats**(formats: List<BarcodeFormat>): `ScannerConfig.Builder`
- **setOverlayStringRes**(resId: Int): `ScannerConfig.Builder`
- **setOverlayDrawableRes**(resId: Int): `ScannerConfig.Builder`
- **setTorchButton**(torchButton: TorchButton): `ScannerConfig.Builder`
- **setFrameRatio**(ratio: Float): `ScannerConfig.Builder`
- **setBeepEnabled**(enabled: Boolean): `ScannerConfig.Builder`
- **setVibrateEnabled**(enabled: Boolean): `ScannerConfig.Builder`
- **setCameraSelector**(selector: CameraSelector): `ScannerConfig.Builder`
- **setScanMode**(mode: ScanMode): `ScannerConfig.Builder`

### Build Method
- **build**(): `ScannerConfig`
  - Returns the configured `ScannerConfig` object.

### DSL Factory Function
- **scannerConfig**(block: ScannerConfig.Builder.() -> Unit): `ScannerConfig`
  - A Kotlin DSL function for creating `ScannerConfig` instances.

### Example
```kotlin
val config = scannerConfig {
    setBarcodeFormats(listOf(BarcodeFormat.FORMAT_QR_CODE))
    setOverlayStringRes(R.string.scan_qr_code)
    setTorchButton(TorchButton.Show)
}
```
```