{"id":29633034,"url":"https://github.com/blinkid/blinkid-android","last_synced_at":"2025-10-18T14:59:49.359Z","repository":{"id":37580228,"uuid":"25651414","full_name":"BlinkID/blinkid-android","owner":"BlinkID","description":"Everything you need to add AI-driven ID scanning into your native Android app.","archived":false,"fork":false,"pushed_at":"2025-06-27T15:32:40.000Z","size":1636149,"stargazers_count":455,"open_issues_count":5,"forks_count":157,"subscribers_count":46,"default_branch":"master","last_synced_at":"2025-06-27T15:39:58.468Z","etag":null,"topics":["ai","android","id-card-camera","id-scanning","identity-document","identity-documents","java","kotlin","kyc","machine-learning","mrtd","mrz","onboarding","pdf417","scanning-id-cards"],"latest_commit_sha":null,"homepage":"https://microblink.com/identity/identity-document-scanning/ ","language":"Kotlin","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"other","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/BlinkID.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"License_notice.md","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null}},"created_at":"2014-10-23T18:23:07.000Z","updated_at":"2025-06-27T15:29:02.000Z","dependencies_parsed_at":"2024-01-11T10:35:38.371Z","dependency_job_id":"68a84a3e-8be9-4d68-bda8-2df9f2551428","html_url":"https://github.com/BlinkID/blinkid-android","commit_stats":null,"previous_names":[],"tags_count":118,"template":false,"template_full_name":null,"purl":"pkg:github/BlinkID/blinkid-android","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BlinkID%2Fblinkid-android","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BlinkID%2Fblinkid-android/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BlinkID%2Fblinkid-android/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BlinkID%2Fblinkid-android/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/BlinkID","download_url":"https://codeload.github.com/BlinkID/blinkid-android/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/BlinkID%2Fblinkid-android/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":266312804,"owners_count":23909752,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-07-21T11:47:31.412Z","response_time":64,"last_error":null,"robots_txt_status":null,"robots_txt_updated_at":null,"robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["ai","android","id-card-camera","id-scanning","identity-document","identity-documents","java","kotlin","kyc","machine-learning","mrtd","mrz","onboarding","pdf417","scanning-id-cards"],"created_at":"2025-07-21T13:38:01.730Z","updated_at":"2025-10-18T14:59:49.349Z","avatar_url":"https://github.com/BlinkID.png","language":"Kotlin","funding_links":[],"categories":[],"sub_categories":[],"readme":"\u003cp align=\"center\" \u003e\n  \u003cimg src=\"https://raw.githubusercontent.com/wiki/blinkid/blinkid-android/images/logo-microblink.png\" alt=\"Microblink\" title=\"Microblink\"\u003e\n\u003c/p\u003e\n\n# BlinkID SDK for Android\n\nThe _BlinkID_ Android SDK is a comprehensive solution for implementing secure document scanning and extraction. It offers powerful capabilities for extracting data from a wide range of identification documents.\n\n\n# Table of contents\n* [Quick Start](#quick-start)\n  * [Quick start with the sample app](#quick-sample)\n  * [SDK integration](#sdk-integration)\n* [Device requirements](#device-requirements)\n  * [Android version](#android-version-req)\n  * [Camera](#camera-req)\n  * [Processor architecture](#processor-arch-req)\n* [Pre-bundling the SDK resources in your app](#pre-bundling-resources)\n* [Customizing the look and UX](#customizing-the-look)\n  * [Simple customizations](#simple-customizations)\n  * [Advanced customizations](#advanced-customizations)\n* [Changing default strings and localization](#changing-strings-and-localization)\n  * [Defining your own string resources for UI elements](#using-own-string-resources)\n* [Using SDK through `BlinkIdScanActivity`](#using-scan-activity)\n* [Completely custom UX (advanced)](#low-level-api)\n  * [The `BlinkIdSdk` and `BlinkIdScanningSession`](#core-api-sdk-and-session)\n* [Using SDK with Java and Views](#legacy-api)\n* [Troubleshooting](#troubleshoot)\n* [Additional info](#additional-info)\n  * [BlinkID SDK size](#sdk-size)\n  * [API documentation](#api-documentation)\n  * [Contact](#contact)\n\n\n# \u003ca name=\"quick-start\"\u003e\u003c/a\u003e Quick Start\n\n## \u003ca name=\"quick-sample\"\u003e\u003c/a\u003e Quick start with the sample apps\n\n1. Open Android Studio.\n2. In `Quick Start` dialog choose _Open project_.\n3. In `File` dialog select _BlinkID_ folder.\n4. Wait for the project to load. If Android Studio asks you to reload the project on startup, select `Yes`.\n\n#### Included sample apps:\n\n- **_sample-app_** emonstrates quick and straightforward integration of the BlinkID SDK using the provided UX in Jetpack Compose to scan a document and display the results.\n- **_direct-api-sample-app_** demonstrates the functionality of BlinkID SDK by avoiding the document scanning process and without using the blinkid-ux library. This approach should be used if you are obtaining document images via other methods.\n- **_java-sample-app_** demonstrates quick and straightforward integration of the BlinkID SDK using only Java (without Jetpack Compose) through `BlinkIdScanActivity`.\n\n## \u003ca name=\"sdk-integration\"\u003e\u003c/a\u003e SDK integration\n\n### Adding _BlinkID_ SDK dependency\n\nThe `BlinkID` library is available on Maven Central repository.\n\nIn your project root, add `mavenCentral()` repository to the repositories list, if not already present:\n\n```\nrepositories {\n    // ... other repositories\n    mavenCentral()\n}\n```\n\nAdd _BlinkID_ as a dependency in module level `build.gradle(.kts)`:\n\n```\ndependencies {\n    implementation(\"com.microblink:blinkid-ux:7.5.0\")\n}\n```\n\n### Launching the BlinkID scanning session and obtaining the results\n\n1. A valid license key is required to initialize the document capture process. You can request a free trial license key, after you register, at [Microblink Developer Hub](https://developer.microblink.com/).. License is bound to the [application ID](https://developer.android.com/studio/build/configure-app-module#set-application-id) of your app, so please ensure you enter the correct application ID when asked.\n\n2. You first need to initialize the SDK and obtain the `BlinkIdSdk` instance:\n```kotlin\nval maybeInstance = BlinkIdSdk.initializeSdk(\n  context,\n  BlinkIdSdkSettings(\n    licenseKey = \u003cyour_license_key\u003e,\n)\n)\nwhen {\n  maybeInstance.isSuccess -\u003e {\n    val sdkInstance = maybeInstance.getOrNull()\n    // use the SDK instance\n  }\n\n  maybeInstance.isFailure -\u003e {\n    val exception = maybeInstance.exceptionOrNull()\n    Log.e(TAG, \"Initialization failed\", exception)\n  }\n}\n```\n`BlinkIdSdk.initializeSdk` is a suspend function which should be called from a coroutine.\n\n3. Use `BlinkIdCameraScanningScreen` composable to the scanning UX and obtain results:\n```kotlin\nBlinkIdCameraScanningScreen(\n  sdkInstance,\n  uiSettings = UiSettings(),\n  uxSettings = BlinkIdUxSettings(),\n  sessionSettings = BlinkIdSessionSettings(),\n  onScanningSuccess = { scanningResult -\u003e\n    // scanningResult is BlinkIdScanningResult\n  },\n  onScanningCanceled = {\n    // user canceled the scanning\n  }\n)\n```\n\n### Scanning session result\n\nAfter the document scanning session is finished the SDK returns an object of type [BlinkIdScanningResult](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core.session/-blink-id-scanning-result/index.html).\nThe object contains extraction process details, document class info, and extraction results. Results are separated into general results and section results.\nGeneral results are a combined set from each entry with the individual data points taken from the most reliable data source (Barcode \u003e MRZ \u003e Visual).\n\nSection results are separated by document side and by data source (Barcode, MRZ, Visual). Each of these individual data sources are available if present on the document (and allowed through scanning settings).\n\n# \u003ca name=\"device-requirements\"\u003e\u003c/a\u003e Device requirements\n\n## \u003ca name=\"android-version-req\"\u003e\u003c/a\u003e Android version\n\n_BlinkID_ SDK requires Android API level **24** or newer.\n\n## \u003ca name=\"camera-req\"\u003e\u003c/a\u003e Camera\n\nTo perform successful scans, the camera preview resolution must be at least **1080p**. Note that the camera preview resolution is not the same as the video recording resolution.\n\n## \u003ca name=\"processor-arch-req\"\u003e\u003c/a\u003e Processor architecture\n\n_BlinkID_ SDK is distributed with **ARMv7** and **ARM64** native library binaries.\n\n_BlinkID_ is a native library written in C++ and available for multiple platforms. Because of this, _BlinkID_ cannot work on devices with obscure hardware architectures. We have compiled SDK's native code only for the most popular Android [ABIs](https://en.wikipedia.org/wiki/Application_binary_interface).\n\nIf you are combining _BlinkID_ library with other libraries that contain native code in your application, make sure to match the architectures of all native libraries. For example, if the third-party library has only ARMv7 version, you must use exactly ARMv7 version of _BlinkID_ with that library, but not ARM64. Using different architectures will crash your app at the initialization step because JVM will try to load all its native dependencies in the same preferred architecture and fail with `UnsatisfiedLinkError`.\n\nTo avoid this issue and ensure that only architectures supported by the _BlinkID_ library are packaged in the final application, add the following statement to your `android/defaultConfig` block inside `build.gradle.kts`:\n\n```\nandroid {\n    ...\n    defaultConfig {\n        ...\n        ndk {\n            // Tells Gradle to package the following ABIs into your application\n            abiFilters += listOf(\"armeabi-v7a\", \"arm64-v8a\")\n        }\n    }\n}\n```\n\n# \u003ca name=\"pre-bundling-resources\"\u003e\u003c/a\u003e Pre-bundling the SDK resources into your app\n\nIf you want to reduce the SDK startup time and network traffic, you have option to pre-bundle the SDK resources as assets into your application. All required resources are located in [libs/resources/assets/microblink/blinkid](https://github.com/BlinkID/blinkid-android/tree/main/libs/resources/assets/microblink/blinki) folder. You can bundle it to your application by including the mentioned folder to application's assets. Copy mentioned `libs/resources/assets/microblink` directory to `src/main/assets` folder of your application module (or appropriate folder for desired app flavor).\n\nUse `BlinkIdSdkSettings` to set the following options when instantiating the SDK:\n\n```kotlin\nBlinkIdSdkSettings(\n    context = context,\n    licenseKey = \u003cyour_license_key\u003e,\n    // disable resource download\n    downloadResources = false,\n    // define path if you are not using a default one: \"microblink/blinkid\"\n    // resourceLocalFolder = \"path_within_app_assets\"\n)\n```\n\n# \u003ca name=\"customizing-the-look\"\u003e\u003c/a\u003e Customizing the look and the UX\n\nAlmost every UI element can be easily modified in many different ways (color, size, font, background). This chapter provides basic guides regarding each implementation method.\n\n\u003cp align=\"center\" \u003e\n  \u003cimg src=\"https://raw.githubusercontent.com/wiki/blinkid/blinkid-android/images/blinkid_v7_ui_customizations.png\" alt=\"BlinkID SDK\"\u003e\n\u003c/p\u003e\n\n\u003cp align=\"center\" \u003e\n  \u003cimg src=\"https://raw.githubusercontent.com/wiki/blinkid/blinkid-android/images/blinkid_v7_dialog_customizations.png\" alt=\"BlinkID SDK\"\u003e\n\u003c/p\u003e\n\n## \u003ca name=\"simple-customizations\"\u003e\u003c/a\u003e Simple customizations\n\nYou can use basic customization options in our default `BlinkIdCameraScanningScreen` composable:\n\n```kotlin\nBlinkIdCameraScanningScreen(\n    sdkInstance,\n    // ui settings options\n    uiSettings = UiSettings(\n        typography = yourTypography,\n        colorScheme = yourColorScheme,\n        uiColors = youReticleColors,\n        sdkStrings = yourSdkStrings,\n        showOnboardingDialog = true, // or false\n        showHelpButton = true // or false\n    ),\n    sessionSettings = BlinkIdSessionSettings(),\n    onScanningSuccess = { scanningResult -\u003e\n        // result is BlinkIdScanningResult\n    },\n    onScanningCanceled = {\n        // user canceled the scanning\n    }\n)\n```\n\nFor a complete reference on available customization options, see [UiSettings](https://blinkid.github.io/blinkid-android/microblink-ux/com.microblink.ux/-ui-settings/index.html) API docs.\n\n## \u003ca name=\"advanced-customizations\"\u003e\u003c/a\u003e Advanced customizations\n\n### Implementing scanning Composable\n\nIt is possible to use completely custom UI elements by implementing your own Composable.\n\nCreate your implementation of scanning ViewModel (which must be a subclass of our `CameraViewModel`) to handle UX events that come from our SDK:\n\n```kotlin\nclass YourBlinkIdScanningUxViewModel(\n    blinkIdSdkInstance: BlinkIdSdk,\n    sessionSettings: ScanningSessionSettings,\n    uxSettings: BlinkIdUxSettings\n) : CameraViewModel() {\n\n    val imageAnalyzer = BlinkIdAnalyzer(\n        blinkIdSdk = blinkIdSdkInstance,\n        sessionSettings = sessionSettings,\n        uxSettings = uxSettings,\n        scanningDoneHandler = object : BlinkIdScanningDoneHandler {\n            override fun onScanningFinished(result: BlinkIdScanningResult) {\n                // TODO use scanning result\n            }\n\n            override fun onScanningCancelled() {\n                // user cancelled the scanning\n            }\n            \n            override fun onError(error: ErrorReason) {\n                // handle scanning errors\n            }\n        },\n        uxEventHandler = object : ScanningUxEventHandler {\n            override fun onUxEvents(events: List\u003cScanningUxEvent\u003e) {\n                // handle scanning UX events to update UI state\n                for (event in events) {\n                    when (event) {\n                        is ScanningUxEvent.ScanningDone -\u003e {\n                            // TODO\n                        }\n\n                        is ScanningUxEvent.DocumentNotFound -\u003e {\n                            // TODO\n                        }\n\n                        is ScanningUxEvent.DocumentNotFullyVisible -\u003e {\n                            // TODO\n                        }\n\n                        is ScanningUxEvent.DocumentTooClose -\u003e {\n                            // TODO\n                        }\n                        \n                        is BlinkIdDocumentLocatedLocation -\u003e {\n                            // TODO\n                        }\n                        \n                        is DocumentImageAnalysisResult -\u003e {\n                            // TODO\n                        }\n                        \n                        // TODO ... handle other events, when must be exhaustive, omitted for brevity\n                    \n                    }\n                }\n            }\n        }\n    )\n    \n    override fun analyzeImage(image: ImageProxy) {\n        // image has to be closed after processing\n        image.use {\n            imageAnalyzer?.analyze(it)\n        }\n    }\n\n     override fun onCleared() {\n        super.onCleared()\n        // cancel and close image analyzer when view model is cleared\n        imageAnalyzer.cancel()\n        imageAnalyzer.close()\n    }\n}\n\n```\n\nImplement your camera scanning screen Composable by using our `CameraScreen` Composable which is responsible for camera management:\n\n```kotlin\n@Composable\nfun YourCameraScanningScreen(\n    viewModel: YourBlinkIdScanningUxViewModel\n    //... other required parameters for your UI\n) {\n    // ...\n    CameraScreen(\n        cameraViewModel = viewModel,\n    ) {\n        // TODO your camera overlay Compose content\n    }\n\n}\n``` \n\n### Customizing `BlinkIdScanActivity`\n\nCustomizing pre-made SDK scanning activity is somewhat limited compared to customizing a composable but still offers many customization options. Custom colors, fonts, and text styles are provided through [BlinkIdScanActivitySettings](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.contract/-blink-id-scan-activity-settings/index.html) class.\n\n```kotlin\ndata class BlinkIdScanActivitySettings(\n  val sdkSettings: BlinkIdSdkSettings,\n  val scanningSessionSettings: BlinkIdSessionSettings = BlinkIdSessionSettings(),\n  val uxSettings: BlinkIdUxSettings = BlinkIdUxSettings(),\n  val scanActivityUiColors: BlinkIdScanActivityColors? = null,\n  val scanActivityUiStrings: SdkStrings = SdkStrings.Default,\n  val scanActivityTypography: ParcelableUiTypography = ParcelableUiTypography.Default(null),\n  val showOnboardingDialog: Boolean = DefaultShowOnboardingDialog,\n  val showHelpButton: Boolean = DefaultShowHelpButton,\n  val enableEdgeToEdge: Boolean = true,\n  val deleteCachedAssetsAfterUse: Boolean = false\n) \n``` \n\nVariable `scanActivityUiColors` of type [BlinkIdScanActivityColors](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.contract/-blink-id-scan-activity-colors/index.html) defines UI colors during the scanning session.\n\nVariable `scanActivityUiStrings` of type [SdkStrings](https://blinkid.github.io/blinkid-android/microblink-ux/com.microblink.ux.theme/-sdk-strings/index.html) allows for Strings customizations and adjustment of default translations.\n\nFinally, through `scanActivityTypography` of type [ParcelableUiTypography](https://blinkid.github.io/blinkid-android/microblink-ux/com.microblink.ux.utils/-parcelable-ui-typography/index.html), you can define different fonts and text styles for every text object found in the scanning screen. Due to limitations of the native `Typography` class, we created a custom solution that enables all important text customizations.\n\n### Modifying our ux libraries source code\n\nFor larger control over the UX, you can use the open-source `blinkid-ux` and `microblink-ux` libraries and perform certain modifications. **Only the source files that specifically allow for modification by the license header** can be modified.\n\nTo do so, you can include the source code of our library directly in your application.\nThey are located in `libs/sources/blinkid-ux` and `libs/sources/microblink-ux` modules.\n\n**Please keep in mind that we will regularly make changes and update the source code with each release.**\n\n# \u003ca name=\"changing-strings-and-localization\"\u003e\u003c/a\u003e Changing default strings and localization\n\nStrings used within built-in activities and UX can be localized to any language.\n\nWe have already prepared strings for several languages which you can use out of the box. You can also modify those strings, or you can add your own language. Languages natively supported by our SDK are the following: `Arabic`, `Chinese simplified`, `Chinese traditional`, `Croatian`, `Czech`, `Dutch`, `Filipino`, `French`, `German`, `Hebrew`, `Hungarian`, `Indonesian`, `Italian`, `Malay`, `Portugese`, `Romanian`, `Serbian`, `Slovak`, `Slovenian`, `Spanish`, `Thai`, and `Vietnamese`.\n\nThe language is automatically adapted to the user's OS language settings. Additionally, to force a specific language, you have to enable it from the code.\n\n\n#### \u003ca name=\"addLanguage\"\u003e\u003c/a\u003e Adding new language\n\n_BlinkID_ can easily be translated to other languages. The `res` folder in `microblink-ux` has folder `values` which contains `strings_core.xml` - this file contains english strings. In order to make e.g. croatian translation, create a folder `values-hr` in your project and put the copy of `strings_core.xml` inside it. Then, open that file and translate the strings from English into Croatian.\n\n#### \u003ca name=\"stringChanging\"\u003e\u003c/a\u003e Changing strings in the existing language\n\nTo modify an existing string, the best approach would be to:\n\n1. Choose a language you want to modify. For example Croatian ('hr').\n2. Find `strings_core.xml` in folder `res/values-hr`\n3. Choose a string key which you want to change. For example: ```\u003cstring name=\"mb_close\"\u003eClose\u003c/string\u003e```\n4. In your project create a file `strings_core.xml` in the folder `res/values-hr`, if it doesn't already exist\n5. Create an entry in the file with the value for the string which you want. For example: ```\u003cstring name=\"mb_back\"\u003eZatvori\u003c/string\u003e```\n6. Repeat for all the string you wish to change\n\nYou can modify strings and add another language. For more information on how localization works in Android, check out the [official Android documentation](https://developer.android.com/guide/topics/resources/localization).\n\n## \u003ca name=\"using-own-string-resources\"\u003e\u003c/a\u003e Defining your own string resources for UI elements\n\nYou can define string resources that will be used instead of predefined ones by using the custom [SdkStrings](https://blinkid.github.io/blinkid-android/microblink-ux/com.microblink.ux.theme/-sdk-strings/index.html) while creating the `UiSettings`.\n\n## \u003ca name=\"using-scan-activity\"\u003e\u003c/a\u003e Using SDK through `BlinkIdScanActivity`\n\nThe simplest way of using BlinkID SDK is through our integrated activity.\nThis eliminates the need for Compose integration and allows for quick and easy access to results. By using this integration method customization is reduced, although most UI elements can still be customized.\n\nActivity is accessed through `rememberLauncherForActivityResult` by using [MbBlinkIdScan](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.contract/-mb-blink-id-scan/index.html) contract.\n```kotlin\nval blinkIdLauncher = rememberLauncherForActivityResult(\n  contract = MbBlinkIdScan(),\n  onResult = { activityResult -\u003e\n      if (activityResult.status == BlinkIdScanActivityResultStatus.DocumentScanned) {\n      // use activityResult.result (BlinkIdScanningResult)\n      }\n  }\n)\n```\nWhen launching the contract, [BlinkIdScanActivitySettings](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.contract/-blink-id-scan-activity-settings/index.html) need to be defined. These settings include basic SDK information such as license key and additional settings for customizing the scanning experience.\n```kotlin\nblinkIdLauncher.launch(\n  BlinkIdScanActivitySettings(\n    BlinkIdSdkSettings(\n      licenseKey = \u003cyour_license_key\u003e\n    ),\n    BlinkIdSessionSettings(\n      scanningSettings = ScanningSettings( \n      // define additional settings here\n      )\n    )\n  )\n)\n```\n[BlinkIdScanActivitySettings](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.contract/-blink-id-scan-activity-settings/index.html) contain the following:\n```kotlin\ndata class BlinkIdScanActivitySettings(\n  val sdkSettings: BlinkIdSdkSettings,\n  val scanningSessionSettings: BlinkIdSessionSettings = BlinkIdSessionSettings(),\n  val uxSettings: BlinkIdUxSettings = BlinkIdUxSettings(),\n  val scanActivityUiColors: BlinkIdScanActivityColors? = null,\n  val scanActivityUiStrings: SdkStrings = SdkStrings.Default,\n  val scanActivityTypography: ParcelableUiTypography = ParcelableUiTypography.Default(null),\n  val showOnboardingDialog: Boolean = DefaultShowOnboardingDialog,\n  val showHelpButton: Boolean = DefaultShowHelpButton,\n  val enableEdgeToEdge: Boolean = true,\n  val deleteCachedAssetsAfterUse: Boolean = false\n)\n```\nMost customizations regarding the UI are handled in the same way as with the Composable component.\nThe main difference can be found in how `Typography` is set.\n\nCustomizing SDK `Typography` is still available through `scanctivityTypography` which is [ParcelableUiTypography](https://blinkid.github.io/blinkid-android/microblink-ux/com.microblink.ux.utils/-parcelable-ui-typography/index.html) type. This class offers only the most important `TextStyle` and `Font` parameters.\n\nWhile `Colors` are fully customizable, the client needs to make sure that `Dark` and `Light` themes follow the current system state. In the Compose implementation, this is handled directly by the SDK.\n# \u003ca name=\"low-level-api\"\u003e\u003c/a\u003e Completely custom UX (advanced)\n\nWhen using the low-level API, you are responsible for preparing the input image stream (or static images) for analysis as well as building a completely custom UX from scratch based on the image-by-image feedback from the SDK.\n\nLow-level API gives you more flexibility with the cost of a significantly larger integration effort. For example, if you need a camera, you will be responsible for camera management and displaying real-time user guidance.\n\n### Adding _BlinkID_ Core SDK dependency for low-level API\n\nFor low-level API integration, only _BlinkID_ SDK core library: **blinkid-core** is needed.\nBoth `blinkid-ux` and `microblink-ux` are not needed.\n\nIn your project root, add `mavenCentral()` repository to the repositories list, if not already present:\n\n```\nrepositories {\n    // ... other repositories\n    mavenCentral()\n}\n```\n\nAdd _blinkid-core_ library as a dependency in module level `build.gradle(.kts)`:\n\n```\ndependencies {\n    implementation(\"com.microblink:blinkid-core:7.5.0\")\n}\n```\n\n## \u003ca name=\"core-api-sdk-and-session\"\u003e\u003c/a\u003e The `BlinkIdSdk` and `BlinkIdScanningSession`\n\n[BlinkIdSdk](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core/-blink-id-sdk/index.html) is a singleton that is main entry point to the _BlinkID_ SDK. It manages the global state of the SDK. This involves managing the main processing, unlocking the SDK, ensuring that licence check is up-to-date, downloading resources, and performing all necessary synchronization for the processing operations.\n\nOnce you obtain an instance of the `BlinkIdSdk` class after the SDK initialization is completed, you can use it to start a document capture session.\n\n[BlinkIdScanningSession](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core.session/-blink-id-scanning-session/index.html) is the main object that accepts images and camera frames, processes them and returns frame-by-frame results, and final result when it becomes available.\n\n\n### \u003ca name=\"analyzing-image-stream\"\u003e\u003c/a\u003e Analyzing the stream of images\n\n1. First initialize the SDK to obtain `BlinkIdSdk` instance by calling `BlinkIdSdk.initializeSdk` suspend function from a Coroutine:\n```kotlin\nval maybeInstance = BlinkIdSdk.initializeSdk(\n    context,\n    BlinkIdSdkSettings(\n        licenseKey = \"your_license_key\",\n    )\n)\nwhen {\n    maybeInstance.isSuccess -\u003e {\n        val sdkInstance = maybeInstance.getOrNull()\n        // use the SDK instance\n    }\n\n    maybeInstance.isFailure -\u003e {\n        val exception = maybeInstance.exceptionOrNull()\n        Log.e(TAG, \"Initialization failed\", exception)\n    }\n}\n```\n2. Create `BlinkIdScanningSession` by calling suspend function `BlinkIdSdk.createScanningSession(BlinkIdSessionSettings)`\n```kotlin\nval scanningSession = blinkIdSdk.createScanningSession(BlinkIdSessionSettings(\n    // use InputImageSource.Video to analyze stream of images, if you have few \n    // images (e.g. from gallery) use InputImageSource.Photo\n    inputImageSource = InputImageSource.Video,\n    // update other options if required\n))\n```\n\n3. To process each image (camera frame) that comes to the recognition, call the suspend function `BlinkIdScanningSession.process(InputImage): BlinkIdProcessResult`\n```kotlin\nval processResult = scanningSesionSession.process(inputImage)\n```\n\nThere are helper methods for creating [InputImage](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.core.image/-input-image/index.html) from `android.media.Image`, `androidx.camera.core.ImageProxy` and standard Android Bitmap.\n\nProcessing of the single frame returns [ProcessResult](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core.session/-blink-id-process-result/index.html) which contains:\n\n- Detailed analysis of the input image, including various detection statuses and potential issues that should be used for frame-by-frame UX updates.\n- Completeness status of the overall process.\n\nYou should keep calling the process function until the result completeness indicates that the result is complete, but you could have custom logic for cancellation and timeouts.\n\n### \u003ca name=\"core-api-obtaining-results\"\u003e\u003c/a\u003e Obtaining scanning results\n\nIf after analysis of some image completeness status of `BlinkIdProcessResult` indicates that document capture is complete, only then you should get the final result from the `ScanningSession`:\n\n```kotlin\nif (processResult.resultCompleteness.isComplete()) {\n    val captureResult = session.getResult()\n    // do something with the final result\n}\n```\n\nYou will get [BlinkIdScanningResult](https://blinkid.github.io/blinkid-android/blinkid-core/com.microblink.blinkid.core.session/-blink-id-scanning-result/index.html) with extraction results.\n\n**After scanning is completed, it is important to terminate the scanning session**\n\nTo terminate the scanning session, ensure that `BlinkIdScanningSession.close()` is called.\n\n**If you are finished with the SDK processing, terminate the SDK to free up resources** by invoking `BlinkIdSdk.closeAndDeleteCachedAssets()` on the SDK instance. If you just wish to close the SDK but may need to use it and the future, you can eliminate the need for re-downloading the resources by calling `BlinkId.close()`.\n\n# \u003ca name=\"legacy-api\"\u003e\u003c/a\u003e Using SDK with Java and Views\n\nEven though BlinkID v7 and above uses modern Android Jetpack components like Compose and coroutines, most functionalities still work with legacy code.\nIt is important to note that even without using Jetpack Compose, it is highly recommended to use Kotlin when implementing the SDK, as it not only eases the implementation process, but also allows for some new functionalities.\n\nIf the client insists on using only Java (and Android Views), BlinkID functionalities can be used through [`BlinkIdScanActivity`](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.activity/-blink-id-scan-activity/index.html?query=class%20BlinkIdScanActivity%20:%20AppCompatActivity).\nA simple implementation like the following should suffice:\n\n```java\nActivityResultLauncher\u003cBlinkIdScanActivitySettings\u003e resultLauncher = registerForActivityResult(\n        new MbBlinkIdScan(),\n        result -\u003e {\n          // handle result here\n        }\n);\n```\nWhen launching the contract, [BlinkIdScanActivitySettings](https://blinkid.github.io/blinkid-android/blinkid-ux/com.microblink.blinkid.ux.contract/-blink-id-scan-activity-settings/index.html) need to be defined. These settings include basic SDK information such as license key and additional settings for customizing the scanning experience.\n```java\nString licenseKey = \"your_license_key\";\nBlinkIdSdkSettings sdkSettings = new BlinkIdSdkSettings(licenseKey);\nBlinkIdScanActivitySettings activitySettings = new BlinkIdScanActivitySettings(sdkSettings);\n\nresultLauncher.launch(activitySettings);\n```\n\nA **_java-sample-app_** can be found in the sample app list where the SDK is implemented using Java and Android Views.\nAdditional helper functions have been created to simplify the implementation process with default class values from Kotlin.\n\nFor more information on how to use `BlinkIdScanActivity`, please refer to the [`Using SDK through BlinkIdScanActivity`](#using-scan-activity) section.\nCurrently, this is the **only officially supported** way of using our SDK with Java and without Kotlin/Jetpack Compose. \n\n# \u003ca name=\"troubleshoot\"\u003e\u003c/a\u003e Troubleshooting\n\n### Integration difficulties\nIn case of problems with SDK integration, make sure that you have followed [integration instructions](#sdk-integration) and [device requirements](#device-requirements). If you're still having problems, please contact us at [help.microblink.com](http://help.microblink.com) describing your problem and provide the following information:\n\n* high-resolution scan/photo of the item that you are trying to read\n* information about device that you are using - we need the exact model name of the device. You can obtain that information with any app like [this one](https://play.google.com/store/apps/details?id=ru.andr7e.deviceinfohw)\n* please stress that you are reporting a problem related to the Android version of _BlinkID_ SDK\n\n# \u003ca name=\"additional-info\"\u003e\u003c/a\u003e Additional info\n\n## \u003ca name=\"sdk-size\"\u003e\u003c/a\u003e BlinkID SDK size\n\nWe recommend that you distribute your app using [App Bundle](https://developer.android.com/platform/technology/app-bundle). This will defer APK generation to Google Play, allowing it to generate minimal APK for each specific device that downloads your app, including only required processor architecture support.\n\n\nHere is the SDK size, calculated for supported ABIs:\n\n| ABI | Download size | Install size |\n| --- |:-------------:|:------------:|\n| armeabi-v7a |    3.40 MB    |   4.54 MB    |\n| arm64-v8a |    3.46 MB    |   5.23 MB    |\n\nSDK size is calculated as application size increases when _BlinkID_ SDK is added, with all its dependencies included.\n\n## \u003ca name=\"api-documentation\"\u003e\u003c/a\u003e API documentation\nYou can find the BlinkID SDK **KDoc** documentation [here](https://blinkid.github.io/blinkid-android/index.html).\n\n## \u003ca name=\"contact\"\u003e\u003c/a\u003e Contact\nFor any other questions, feel free to contact us at [help.microblink.com](http://help.microblink.com).\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fblinkid%2Fblinkid-android","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fblinkid%2Fblinkid-android","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fblinkid%2Fblinkid-android/lists"}