Advance version number to 1.64.2

These are two different use cases.

CHANGELOG.md

@@ -1,5 +1,264 @@
 # Change Log
 
+## 1.64.2
+* Separate crop window settings for image scanning
+* Fix initializing dataMask
+* Update Russian translation
+
+## 1.64.1
+* Handle empty input for recreation
+* Fix setting up database
+
+## 1.64.0
+* Find barcode by content
+* Immediately replace toasts
+* Use detected barcode for recreation
+* Show data mask of QR Codes
+* Fix deep linking
+* Replace margin with quiet zone switch when generating barcodes
+* Update Russian translation
+* Update Portuguese (Brazil) translation
+
+## 1.63.13
+* Fix UTF-8 conversion of binary escape sequences when creating barcodes
+* Fix scan order for intervals under one second
+* Add arabic translation
+* Update French translation
+
+## 1.63.12
+* Fix magnifying barcode recreation
+
+## 1.63.11
+* Update parcel tracking URL
+* Update multiple translations
+* Only ask for barcode size when exporting/sharing
+
+## 1.63.10
+* Use maximum brightness when showing a generated barcode
+* Allow file input from share menu
+* Update multiple translations
+
+## 1.63.9
+* Export/share as JPEG
+* Ignore "URL:" before URLs in barcode content
+* Fix exporting/sharing multiple history items
+* Update multiple translations
+
+## 1.63.8
+* Add an option to show a checksum for the decoded content
+* Add support for encoding escape sequences for non-printable characters
+* Update Italian translation
+
+## 1.63.7
+* Update ZXingCpp for Aztec Runes
+* Update Italian translation
+
+## 1.63.6
+* Add history shortcut
+* Return Codabar start/stop codes
+* Update French, Russian, Spanish and Ukrainian translations
+
+## 1.63.5
+* Add an option to ignore any duplicates
+* Fix invalid bluetooth connection
+* Update Russian translation
+* Update Ukrainian translation
+
+## 1.63.4
+* Update Chinese translation
+* Improve support for old devices
+
+## 1.63.3
+* Fix SCAN Intent
+
+## 1.63.2
+* Add DX Film Edge barcode format
+* Update Turkish translation
+* Update Ukrainian translation
+
+## 1.63.1
+* Include scan label in exports/shares
+* Update Russian translation
+
+## 1.63.0
+* Edit scan label in decoding screen
+* Add a button to add generated codes to the history
+* Improve scanning from images
+* Improve asking for camera permission
+* Fix margin for recreated barcodes
+* Limit duration of error beep to 1s
+* Update Ukrainian translation
+* Update Spanish translation
+
+## 1.62.3
+* Extend selection with single taps in history listing
+* Update Brazilian Portuguese translation
+
+## 1.62.2
+* Include rMQR Code for updates
+
+## 1.62.1
+* Make rMQR Code selectable
+
+## 1.62.0
+* Add support for rMQR (rectangular Micro QR) Code
+* Share history as a file
+* Only share selected scans from history
+
+## 1.61.2
+* Fix quick settings tile for Android 14
+* Fix Xiaomi MIUI lockscreen barcode shortcut
+* Update French translation
+* Update Czech translation
+* Update Russian translation
+
+## 1.61.1
+* Share scanned contents as a file
+* Recreate binary barcodes too
+* Add Bulgarian translation and Brave search engine
+* Update Russian translation
+* Fix general format restriction from preferences
+
+## 1.61.0
+* Support encoding binary data
+* Add margin parameter for encoding
+* Add copying binary data as hex dump
+* Fix parsing TYPE argument in VCARDs
+* Update Russian translation
+* Update Brazilian Portuguese translation
+* Update Ukrainian translation
+* Update Chinese translation
+
+## 1.60.3
+* Fix saving custom language
+* Update Brazilian Portuguese translation
+* Update Chinese translation
+* Update Czech localisation
+* Update Russian translation
+* Update Italian language
+
+## 1.60.2
+* Expand escape sequences in encoding input
+* Update Taiwan translation
+
+## 1.60.1
+* Support sending scans via bluetooth
+* Fix resolving error correction level for recreation
+* Improve asset image compression
+* Update ZXing C++
+* Update Italian translation
+* Update Russian translation
+
+## 1.59.0
+* Add setting error correction for AZTEC/PDF417
+* Fix setting error correction level for QR Codes
+* Make error beeps follow beep settings too
+* Don't close the app when cameras is unavailable
+
+## 1.58.2
+* Fix parsing WiFi network suggestions
+
+## 1.58.1
+* Update zh-rCn translation
+* Fix monochrome launcher icon
+
+## 1.58.0
+* Improve detection of inverted barcodes
+* Optionally allow duplicates in bulk scan
+* Add Danish translation
+* Update Italian translation
+* Update Japanese translation
+* Update Russian translation
+* Fix charset decoding for PDF 417
+* Fix monochrome icon
+
+## 1.57.0
+* Add optional audio feedback for scanning
+* Allow removing individual WiFi network suggestions
+* Recognize incomplete and malformed WiFi barcodes
+* Fix using shared text for encoding
+* Add Korean language
+* Update Chinese translation
+* Update Português/Brasil translation
+* Update Russian translation
+
+## 1.56.3
+* Fix parsing URLs in barcodes
+* Update French, Portuguese, Turkish and Taiwan translation
+
+## 1.56.2
+* Fix generating 1D barcode text output
+
+## 1.56.1
+* Allow pinching a barcode to its generated size
+* Fix view/frame transformation matrix
+* Fix handling of tab characters
+* Update Indonesian translation
+* Update Russian translation
+
+## 1.56.0
+* Add an action item to lock/unlock free rotation
+* Support setting fore and background colors when creating barcodes
+* Fix creating barcodes with UTF-8 content
+
+## 1.55.0
+* Make recreated barcode interactive
+* Update to latest ZXing C++
+* Update Italian translation
+
+## 1.54.1
+* Update Russian translation
+* Update Turkish translation
+* Update Italian translation
+* Fix handling GS1 and ISO15434 content types
+* Fix VerifyError on Android 4
+
+## 1.54.0
+* Recreate and show barcode from read contents if possible
+* Add ebay, Amazon and barcodelookup.com to search engines
+
+## 1.53.1
+* Fix proguard configuration
+
+## 1.53.0
+* Migrate to ZXing-C++ and add support for Micro QR Codes
+* Multi-select scans in history listing
+* Remove preset content for Encode shortcut
+* Always show QR Code version and remove setting
+* Fix PDF-417 UTF-8 text encoding
+* Hide sensitive content from clipboard
+* Remove setting a custom language on Android 13+
+* Condense text output of generated barcodes
+* Update Russian translation
+* Update Spanish translation
+* Add Persian translation
+
+## 1.52.0
+* Fix parsing timezone in calendar dates
+* Update French translation
+
+## 1.51.1
+* Fix extraction of raw bytes for some barcodes
+
+## 1.51.0
+* Add support for Deutsche Post Matrixcode stamp
+* Allow free image rotation for scanning from images
+* Fix setting TO field in MATMSG format
+* Update Italian translation
+* Update zh-rCN translation
+* Update pt-br translation
+
+## 1.50.0
+* Add support for MATMSG format
+* Add a setting to show the QR Code version
+* Add timezone offset in calendar dates
+* Recognize colloquial incomplete URLs
+* Update ZXing library to latest version
+* Update Czech translation
+* Update Russian translation
+* Update Japanese translation
+* Update Hungarian translation
+
 ## 1.49.2
 * Update design of app icon
 * Update pt-br translation

CONTRIBUTING.md

@@ -16,5 +16,10 @@ to squash when merging into master:
 Then write a [good commit message][commit_messages] to keep the history
 meaningful and useful. One feature, one commit.
 
+## Translations
+
+For translations use [Toolate][toolate].
+
 [android_best_practices]: https://developer.android.com/distribute/best-practices/develop/
-[commit_messages]: https://juffalow.com/other/write-good-git-commit-message
+[commit_messages]: https://git-scm.com/book/en/v2/Distributed-Git-Contributing-to-a-Project#_commit_guidelines
+[toolate]: https://toolate.othing.xyz/projects/binaryeye/

Makefile

@@ -20,9 +20,6 @@ infer: clean
 test:
 	./gradlew test
 
-cat:
-	./gradlew test cAT
-
 testview:
 	adb shell am start -W -a android.intent.action.VIEW -d 'binaryeye://scan'
 
@@ -36,6 +33,11 @@ testurl:
 		-c android.intent.category.BROWSABLE \
 		-d 'http://markusfisch.de/BinaryEye?ret=http%3A%2F%2Fmarkusfisch.de%2F%3Fresult%3D{RESULT}'
 
+testxiaomi:
+	adb shell am start -a android.intent.action.VIEW \
+		-c android.intent.category.BROWSABLE \
+		-d 'market://details?id=com.xiaomi.scanner'
+
 install:
 	adb $(TARGET) install -r app/build/outputs/apk/debug/app-debug.apk
 

PRIVACY.md

@@ -12,10 +12,17 @@ hesitate to contact me.
 Required to add a WiFi network from a barcode (usually a QR Code).
 
 Before Android Q, this feature requires using
-[WifiManager.getConfiguredNetworks][configuredNetworks]
+[WifiManager.getConfiguredNetworks][getConfiguredNetworks]
 which requires `ACCESS_FINE_LOCATION`.
 
-On Android Q an better, this permission is not requested nor required.
+On Android Q and better, this permission is not requested nor required.
+
+### [BLUETOOTH][BLUETOOTH], [BLUETOOTH_ADMIN][BLUETOOTH_ADMIN] and [BLUETOOTH_CONNECT][BLUETOOTH_CONNECT]
+
+Required to optionally forward scans to a Bluetooth device.
+
+[BLUETOOTH][BLUETOOTH] and [BLUETOOTH_ADMIN][BLUETOOTH_ADMIN] are required
+before Android S. [BLUETOOTH_CONNECT][BLUETOOTH_CONNECT] from Android S on.
 
 ### [CAMERA][CAMERA]
 
@@ -46,15 +53,23 @@ which requires `CHANGE_WIFI_STATE`.
 Required to add a WiFi network from a barcode (usually a QR Code).
 
 Before Android Q, this feature requires using
-[WifiManager.getConfiguredNetworks][configuredNetworks]
+[WifiManager.getConfiguredNetworks][getConfiguredNetworks]
 which requires `ACCESS_WIFI_STATE`.
 
+From Android R, `ACCESS_WIFI_STATE` is required for
+[WifiManager.getNetworkSuggestions][getNetworkSuggestions]
+which is used to remove individual network suggestions.
+
 [ACCESS_FINE_LOCATION]: https://developer.android.com/reference/android/Manifest.permission#ACCESS_FINE_LOCATION
+[BLUETOOTH]: https://developer.android.com/reference/android/Manifest.permission#BLUETOOTH
+[BLUETOOTH_ADMIN]: https://developer.android.com/reference/android/Manifest.permission#BLUETOOTH_ADMIN
+[BLUETOOTH_CONNECT]: https://developer.android.com/reference/android/Manifest.permission#BLUETOOTH_CONNECT
 [CAMERA]: https://developer.android.com/reference/android/Manifest.permission#CAMERA
 [INTERNET]: https://developer.android.com/reference/android/Manifest.permission#INTERNET
 [VIBRATE]: https://developer.android.com/reference/android/Manifest.permission#VIBRATE
 [WRITE_EXTERNAL_STORAGE]: https://developer.android.com/reference/android/Manifest.permission#WRITE_EXTERNAL_STORAGE
 [CHANGE_WIFI_STATE]: https://developer.android.com/reference/android/Manifest.permission#CHANGE_WIFI_STATE
 [ACCESS_WIFI_STATE]: https://developer.android.com/reference/android/Manifest.permission#ACCESS_FINE_LOCATION
-[configuredNetworks]: https://developer.android.com/reference/android/net/wifi/WifiManager#getConfiguredNetworks()
+[getConfiguredNetworks]: https://developer.android.com/reference/android/net/wifi/WifiManager#getConfiguredNetworks()
 [addNetworkSuggestions]: https://developer.android.com/reference/android/net/wifi/WifiManager#addNetworkSuggestions(java.util.List%3Candroid.net.wifi.WifiNetworkSuggestion%3E)
+[getNetworkSuggestions]: https://developer.android.com/reference/android/net/wifi/WifiManager#getNetworkSuggestions()

README.md

@@ -2,13 +2,30 @@
 
 Yet another barcode scanner for Android. As if there weren't [enough][play].
 
-This one is free, without any ads and open source.
+This one is free, without any ads, and open source.
 
 Works in portrait and landscape orientation, can read inverted codes,
 comes in Material Design and can also generate barcodes.
 
-Binary Eye uses the [ZXing][zxing] ("Zebra Crossing") barcode scanning
-library.
+Binary Eye uses the [ZXing-C++][zxing_cpp] ("Zebra Crossing") barcode
+scanning library.
+
+If you find this app useful and wish to support its continued development,
+you can [buy me a coffee](https://www.buymeacoffee.com/markusfisch) or
+send some Bitcoin decimals to `bc1q2guk2rpll587aymrfadkdtpq32448x5khk5j8z`.
+
+<a href="https://www.buymeacoffee.com/markusfisch" target="_blank"><img
+	src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png"
+	alt="Buy Me A Coffee"
+	style="height: 60px !important;width: 217px !important;"/></a>&nbsp;<a
+	href="https://liberapay.com/markusfisch/" target="_blank"><img
+	src="https://liberapay.com/assets/widgets/donate.svg"
+	alt="Liberapay"
+	style="height: 60px !important"/></a>&nbsp;<a
+	href="https://ko-fi.com/markusfisch" target="_blank"><img
+	src="https://storage.ko-fi.com/cdn/brandasset/kofi_s_tag_dark.png"
+	alt="Ko-fi"
+	style="height: 60px !important"/></a>
 
 ## Screenshots
 
@@ -36,13 +53,15 @@ ZXing can read the following barcode formats:
 * [CODE 93][code_93]
 * [CODE 128][code_128]
 * [DATA MATRIX][data_matrix]
+* [DX FILM EDGE][dx_film_edge]
 * [EAN 8][ean_8]
 * [EAN 13][ean_13]
 * [ITF][itf]
-* [MAXICODE][maxicode] (only when unrotated and unskewed, see [77][77],
-	because of which Binary Eye *cannot* read this barcode)
+* [MAXICODE][maxicode] (partial)
 * [PDF417][pdf417]
 * [QR CODE][qr_code]
+* [Micro QR Code][micro_qr_code]
+* [rMQR Code][rmqr_code]
 * [RSS 14][rss]
 * [RSS EXPANDED][rss]
 * [UPC A][upc_a]
@@ -71,7 +90,7 @@ ZXing can generate the following barcode formats:
 You can invoke Binary Eye with a web URI intent from anything that can
 open URIs. There are two options:
 
-1. [binaryeye://scan](binaryeye://scan)
+1. [binaryeye://scan](binaryeye://scan)       (note: Github Markdown does not render this as clickable link)
 2. [http(s)://markusfisch.de/BinaryEye](http://markusfisch.de/BinaryEye)
 
 If you want to get the scanned contents, you can add a `ret` query
@@ -84,65 +103,60 @@ Supported symbols are:
 * `RESULT` - scanned content
 * `RESULT_BYTES` - raw result as a hex string
 * `FORMAT` - barcode format
-* `META` - the meta data, if available
 
 ### SCAN Intent
 
 You can also use Binary Eye from other apps by using the
-`com.google.zxing.client.android.SCAN` Intent with `startActivityForResult()`
-like this:
+`com.google.zxing.client.android.SCAN` Intent with
+[startActivityForResult()][start_activity] like this:
 
-	startActivityForResult(
-		Intent("com.google.zxing.client.android.SCAN"),
-		SOME_NUMBER
-	)
+```kotlin
+startActivityForResult(
+	Intent("com.google.zxing.client.android.SCAN"),
+	SOME_NUMBER
+)
+```
 
-And process the result in `onActivityResult()` of your `Activity`:
+And process the result in [onActivityResult()][on_activity_result] of your
+`Activity`:
 
-	override fun onActivityResult(
-		requestCode: Int,
-		resultCode: Int,
-		data: Intent?
-	) {
-		when (requestCode) {
-			SOME_NUMBER -> if (resultCode == RESULT_OK) {
-				val result = data.getStringExtra("SCAN_RESULT")
-				…
-			}
+```kotlin
+override fun onActivityResult(
+	requestCode: Int,
+	resultCode: Int,
+	data: Intent?
+) {
+	when (requestCode) {
+		SOME_NUMBER -> if (resultCode == RESULT_OK) {
+			val result = data.getStringExtra("SCAN_RESULT")
+			…
+		}
+	}
+}
+```
+
+If you're using AndroidX, this would be the new,
+[recommended way][intent_result]:
+
+```kotlin
+class YourActivity : AppCompatActivity() {
+	private val resultLauncher = registerForActivityResult(
+		ActivityResultContracts.StartActivityForResult()
+	) { result ->
+		if (result.resultCode == RESULT_OK) {
+			val content = result.data?.getStringExtra("SCAN_RESULT")
+			…
 		}
 	}
 
-## RenderScript
-
-This app uses [RenderScript][rs] to resize and rotate the camera image.
-Unfortunately, RenderScript has some nasty gotchas.
-
-### RenderScript.forceCompat()
-
-It's necessary to call `RenderScript.forceCompat()` on some devices/roms.
-
-`RenderScript.forceCompat()` needs to be run before any other RenderScript
-function and unfortunately there is no way to know if invoking `forceCompat()`
-is necessary or not.
-
-If `RenderScript.forceCompat()` is necessary, a `RSRuntimeException` will
-be thrown and the only option is to restart the app, this time with calling
-`forceCompat()` first.
-
-Calling `RenderScript.forceCompat()` means the processing is done in
-software so you probably don't want to enable it by default.
-
-### 2D barcodes
-
-If you want to fork this and are only interested in reading 2D barcodes
-(like QR or Aztec), you may want to remove the custom rotation kernel
-altogether as ZXing can read 2D barcodes in any orientation.
-
-This will make your app a bit simpler and saves you from compiling a
-custom RenderScript kernel for each architecture you want to support.
+	fun openScanner() {
+		resultLauncher.launch(Intent("com.google.zxing.client.android.SCAN"))
+	}
+}
+```
 
 [play]: https://play.google.com/store/search?q=barcode%20scanner&c=apps
-[zxing]: https://github.com/zxing/zxing
+[zxing_cpp]: https://github.com/zxing-cpp/zxing-cpp
 [kotlin]: http://kotlinlang.org/
 [aztec]: https://en.wikipedia.org/wiki/Aztec_Code
 [codabar]: https://en.wikipedia.org/wiki/Codabar
@@ -150,15 +164,19 @@ custom RenderScript kernel for each architecture you want to support.
 [code_93]: https://en.wikipedia.org/wiki/Code_93
 [code_128]: https://en.wikipedia.org/wiki/Code_128
 [data_matrix]: https://en.wikipedia.org/wiki/Data_Matrix
+[dx_film_edge]: https://en.wikipedia.org/wiki/DX_encoding
 [ean_8]: https://en.wikipedia.org/wiki/EAN-8
 [ean_13]: https://en.wikipedia.org/wiki/International_Article_Number
 [itf]: https://en.wikipedia.org/wiki/Interleaved_2_of_5
 [maxicode]: https://en.wikipedia.org/wiki/MaxiCode
 [pdf417]: https://en.wikipedia.org/wiki/PDF417
 [qr_code]: https://en.wikipedia.org/wiki/QR_code
+[micro_qr_code]: https://en.wikipedia.org/wiki/QR_code#Micro_QR_code
+[rmqr_code]: https://www.qrcode.com/en/codes/rmqr.html
 [rss]: https://en.wikipedia.org/wiki/GS1_DataBar
 [upc_a]: https://en.wikipedia.org/wiki/Universal_Product_Code
 [upc_e]: https://en.wikipedia.org/wiki/Universal_Product_Code#UPC-E
 [upc_ean]: https://en.wikipedia.org/wiki/Universal_Product_Code#EAN-13
-[77]: https://github.com/markusfisch/BinaryEye/issues/77
-[rs]: https://developer.android.com/guide/topics/renderscript/compute
+[start_activity]: https://developer.android.com/reference/android/app/Activity#startActivityForResult(android.content.Intent,%20int)
+[on_activity_result]: https://developer.android.com/reference/android/app/Activity#onActivityResult(int,%20int,%20android.content.Intent)
+[intent_result]: https://developer.android.com/training/basics/intents/result

app/build.gradle

@@ -2,25 +2,15 @@ apply plugin: 'com.android.application'
 apply plugin: 'kotlin-android'
 
 android {
-	compileSdkVersion sdk_version
+	namespace "de.markusfisch.android.binaryeye"
+	compileSdk sdk_version
 
 	defaultConfig {
-		minSdkVersion 9
-		targetSdkVersion sdk_version
+		minSdk 9
+		targetSdk sdk_version
 
-		versionCode 96
-		versionName '1.49.2'
-
-		// Required for desugaring.
-		multiDexEnabled true
-
-		// It's recommended to set this value to the lowest API level
-		// able to provide all the functionality.
-		renderscriptTargetApi 24
-		renderscriptSupportModeEnabled true
-		renderscriptSupportModeBlasEnabled true
-
-		testInstrumentationRunner 'android.support.test.runner.AndroidJUnitRunner'
+		versionCode 144
+		versionName '1.64.2'
 	}
 
 	signingConfigs {
@@ -52,6 +42,10 @@ android {
 		}
 	}
 
+	buildFeatures {
+		buildConfig true
+	}
+
 	bundle {
 		language {
 			// To make the app bundle contain all language resources
@@ -64,38 +58,32 @@ android {
 		}
 	}
 
+	// Required since Gradle 8.
 	compileOptions {
-		// To desugar fancy Java features in ZXing 3.4.+ that don't
-		// work on SDK < 24. See:
-		// https://github.com/zxing/zxing/issues/1170
-		coreLibraryDesugaringEnabled true
+		sourceCompatibility = JavaVersion.VERSION_1_8
+		targetCompatibility = JavaVersion.VERSION_1_8
 	}
-
-	lintOptions {
-		// Because at the time of writing, even the latest version
-		// of RenderScript is raising this error no matter if
-		// renderscriptTargetApi matches targetSdkVersion.
-		disable 'GradleCompatible'
+	kotlinOptions {
+		jvmTarget = "1.8"
 	}
 }
 
 dependencies {
-	androidTestImplementation('com.android.support.test:runner:1.0.2') {
-		exclude module: 'support-annotations'
-	}
-	androidTestImplementation('com.android.support.test:rules:1.0.2') {
-		exclude module: 'support-annotations'
-	}
-	testImplementation 'junit:junit:4.13.2'
-
-	coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.5'
+	// Kotlin
 	implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.5.2"
+	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.9.0"
+
+	// Support
 	implementation "com.android.support:appcompat-v7:$support_version"
 	implementation "com.android.support:design:$support_version"
 	implementation "com.android.support:preference-v7:$support_version"
 	implementation "com.android.support:preference-v14:$support_version"
-	implementation 'com.google.zxing:core:3.4.1'
-	implementation 'com.github.markusfisch:CameraView:1.9.1'
-	implementation 'com.github.markusfisch:ScalingImageView:1.3.0'
+
+	// External
+	implementation 'com.github.markusfisch:CameraView:1.10.0'
+	implementation 'com.github.markusfisch:ScalingImageView:1.4.1'
+	implementation 'com.github.markusfisch:zxing-cpp:v2.3.0.2'
+
+	// Testing
+	testImplementation 'junit:junit:4.13.2'
 }

app/proguard-rules.pro

@@ -3,4 +3,3 @@
 -dontwarn android.support.v8.**
 
 -keep class android.support.v7.widget.SearchView { *; }
--keep class android.support.v8.renderscript.** { *; }

app/src/androidTest/kotlin/de/markusfisch/android/binaryeye/PreprocessorTest.kt

@@ -1,107 +0,0 @@
-package de.markusfisch.android.binaryeye
-
-import android.graphics.Bitmap
-import android.graphics.BitmapFactory
-import android.support.test.InstrumentationRegistry
-import android.support.test.runner.AndroidJUnit4
-import android.support.v8.renderscript.RenderScript
-import de.markusfisch.android.binaryeye.rs.Preprocessor
-import de.markusfisch.android.binaryeye.zxing.Zxing
-import org.junit.Assert.fail;
-import org.junit.Test
-import org.junit.runner.RunWith
-import java.util.regex.Pattern
-
-@RunWith(AndroidJUnit4::class)
-class PreprocessorTest {
-	@Test
-	fun processSamples() {
-		val assets = InstrumentationRegistry.getInstrumentation()
-			.context.assets
-		val samples = assets.list("samples")
-		checkNotNull(samples) { "no samples found" }
-		val pattern = Pattern.compile(
-			"[0-9]+-([0-9]+)deg.jpg"
-		)
-		val rs = RenderScript.create(
-			InstrumentationRegistry.getTargetContext(),
-		)
-		val zxing = Zxing()
-		for (sample in samples) {
-			val m = pattern.matcher(sample)
-			if (!m.find() || m.groupCount() < 1) {
-				fail("invalid sample: $sample")
-			}
-			val bitmap = BitmapFactory.decodeStream(
-				assets.open("samples/$sample")
-			)
-			val frameData = getNV21(bitmap)
-			val frameWidth = bitmap.width
-			val frameHeight = bitmap.height
-			val frameOrientation = m.group(1) ?: return
-			val preprocessor = Preprocessor(
-				rs,
-				frameWidth,
-				frameHeight,
-				null
-			)
-			val outWidth: Int
-			val outHeight: Int
-			val orientation = frameOrientation.toInt()
-			if (orientation == 90 || orientation == 270) {
-				preprocessor.resizeAndRotate(frameData)
-				outWidth = preprocessor.outHeight
-				outHeight = preprocessor.outWidth
-			} else {
-				preprocessor.resizeOnly(frameData)
-				outWidth = preprocessor.outWidth
-				outHeight = preprocessor.outHeight
-			}
-			val result = zxing.decode(frameData, outWidth, outHeight)
-			preprocessor.destroy()
-			checkNotNull(result) { "no barcode found in $sample" }
-		}
-		rs.destroy()
-	}
-}
-
-fun getNV21(bitmap: Bitmap): ByteArray {
-	val width = bitmap.width
-	val height = bitmap.height
-	val argb = IntArray(width * height)
-	bitmap.getPixels(argb, 0, width, 0, 0, width, height)
-	return encodeYUV420SP(argb, width, height)
-}
-
-private fun encodeYUV420SP(argb: IntArray, width: Int, height: Int): ByteArray {
-	val yuv = ByteArray(ceilIfUneven(width) * ceilIfUneven(height) * 3 / 2)
-	var yIndex = 0
-	var uvIndex = width * height
-	var r: Int
-	var g: Int
-	var b: Int
-	var y: Int
-	var u: Int
-	var v: Int
-	var index = 0
-	for (t in 0 until height) {
-		for (s in 0 until width) {
-			val pixel = argb[index]
-			r = pixel and 0xff0000 shr 16
-			g = pixel and 0xff00 shr 8
-			b = pixel and 0xff
-			y = (66 * r + 129 * g + 25 * b + 128 shr 8) + 16
-			u = (-38 * r - 74 * g + 112 * b + 128 shr 8) + 128
-			v = (112 * r - 94 * g - 18 * b + 128 shr 8) + 128
-			yuv[yIndex++] = (if (y < 0) 0 else if (y > 255) 255 else y).toByte()
-			if (t % 2 == 0 && index % 2 == 0) {
-				yuv[uvIndex++] = (if (v < 0) 0 else if (v > 255) 255 else v).toByte()
-				yuv[uvIndex++] = (if (u < 0) 0 else if (u > 255) 255 else u).toByte()
-			}
-			++index
-		}
-	}
-	return yuv
-}
-
-private fun ceilIfUneven(n: Int) = if (n and 1 == 1) n + 1 else n

app/src/main/AndroidManifest.xml

@@ -1,22 +1,26 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
 	xmlns:tools="http://schemas.android.com/tools"
-	package="de.markusfisch.android.binaryeye"
 	android:installLocation="auto">
 	<supports-screens
 		android:largeScreens="true"
 		android:xlargeScreens="true"/>
 	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"
 		android:maxSdkVersion="28"/>
+	<uses-permission android:name="android.permission.BLUETOOTH"
+		android:maxSdkVersion="30"/>
+	<uses-permission android:name="android.permission.BLUETOOTH_ADMIN"
+		android:maxSdkVersion="30"/>
+	<uses-permission android:name="android.permission.BLUETOOTH_CONNECT"/>
 	<uses-permission android:name="android.permission.CAMERA"/>
 	<uses-permission android:name="android.permission.INTERNET"/>
 	<uses-permission android:name="android.permission.VIBRATE"/>
 	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"
 		android:maxSdkVersion="28"/>
 	<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
-	<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"
-		android:maxSdkVersion="28"/>
+	<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
 	<uses-feature android:name="android.hardware.camera"/>
-	<uses-feature android:name="android.hardware.camera.autofocus"/>
+	<uses-feature android:name="android.hardware.camera.autofocus"
+		android:required="false" />
 	<uses-sdk tools:overrideLibrary="android.support.v14.preference"/>
 	<queries>
 		<intent>
@@ -59,13 +63,20 @@
 			<intent-filter android:label="@string/compose_barcode">
 				<action android:name="android.intent.action.SEND"/>
 				<category android:name="android.intent.category.DEFAULT"/>
-				<data android:mimeType="text/plain"/>
+				<data android:mimeType="text/*"/>
 			</intent-filter>
 			<intent-filter>
 				<action android:name="com.google.zxing.client.android.SCAN"/>
 				<category android:name="android.intent.category.DEFAULT"/>
 			</intent-filter>
 			<intent-filter>
+				<action android:name="android.intent.action.VIEW"/>
+				<category android:name="android.intent.category.DEFAULT"/>
+				<category android:name="android.intent.category.BROWSABLE"/>
+				<data android:host="details" android:scheme="market"
+					android:pathSuffix="id=com.xiaomi.scanner"/>
+			</intent-filter>
+			<intent-filter android:autoVerify="true">
 				<action android:name="android.intent.action.VIEW"/>
 				<category android:name="android.intent.category.DEFAULT"/>
 				<category android:name="android.intent.category.BROWSABLE"/>
@@ -105,7 +116,8 @@
 			android:icon="@drawable/ic_action_scan"
 			android:label="@string/scan_code"
 			android:exported="true"
-			android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+			android:permission="android.permission.BIND_QUICK_SETTINGS_TILE"
+			tools:targetApi="n">
 			<intent-filter>
 				<action android:name="android.service.quicksettings.action.QS_TILE"/>
 			</intent-filter>

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/ActionRegistry.kt

@@ -1,6 +1,7 @@
 package de.markusfisch.android.binaryeye.actions
 
 import de.markusfisch.android.binaryeye.actions.mail.MailAction
+import de.markusfisch.android.binaryeye.actions.mail.MatMsgAction
 import de.markusfisch.android.binaryeye.actions.otpauth.OtpauthAction
 import de.markusfisch.android.binaryeye.actions.search.OpenOrSearchAction
 import de.markusfisch.android.binaryeye.actions.sms.SmsAction
@@ -15,13 +16,16 @@ object ActionRegistry {
 
 	private val REGISTRY: Set<IAction> = setOf(
 		MailAction,
+		MatMsgAction,
 		OtpauthAction,
 		SmsAction,
 		TelAction,
 		VCardAction,
 		VEventAction,
-		WebAction,
-		WifiAction
+		WifiAction,
+		// Try WebAction last because recognizing colloquial URLs is
+		// very aggressive.
+		WebAction
 	)
 
 	fun getAction(data: ByteArray): IAction = REGISTRY.find {

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/IAction.kt

@@ -39,8 +39,10 @@ abstract class SchemeAction : IAction {
 	final override fun canExecuteOn(data: ByteArray): Boolean {
 		val content = String(data)
 		return if (buildRegex) {
-			content.matches("""^$scheme://[\w\W]+$""".toRegex(
-				RegexOption.IGNORE_CASE)
+			content.matches(
+				"""^$scheme://[\w\W]+$""".toRegex(
+					RegexOption.IGNORE_CASE
+				)
 			)
 		} else {
 			content.startsWith("$scheme://", ignoreCase = true)

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/mail/MatMsgAction.kt

@@ -0,0 +1,55 @@
+package de.markusfisch.android.binaryeye.actions.mail
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.actions.IntentAction
+
+object MatMsgAction : IntentAction() {
+	override val iconResId: Int = R.drawable.ic_action_mail
+	override val titleResId: Int = R.string.mail_send
+	override val errorMsg: Int = R.string.mail_error
+
+	override fun canExecuteOn(data: ByteArray): Boolean {
+		return String(data).startsWith("MATMSG:")
+	}
+
+	override suspend fun createIntent(
+		context: Context,
+		data: ByteArray
+	): Intent? {
+		val mm = MatMsg(String(data))
+		// Allow incomplete but not completely missing data.
+		if (mm.isEmpty()) {
+			return null
+		}
+		return Intent(
+			Intent.ACTION_SENDTO,
+			Uri.parse("mailto:")
+		).apply {
+			mm.to?.let {
+				putExtra(Intent.EXTRA_EMAIL, arrayOf(mm.to))
+			}
+			mm.sub?.let {
+				putExtra(Intent.EXTRA_SUBJECT, mm.sub)
+			}
+			mm.body?.let {
+				putExtra(Intent.EXTRA_TEXT, mm.body)
+			}
+		}
+	}
+}
+
+// Public so this can be tested.
+class MatMsg(encoded: String) {
+	// Allow arbitrary order.
+	val to = encoded.extractFirst("""[:;]TO:([\w.%@+-]+);""")
+	val sub = encoded.extractFirst("""[:;]SUB:([^;]+);""")
+	val body = encoded.extractFirst("""[:;]BODY:([^;]+);""")
+
+	fun isEmpty() = to == null && sub == null && body == null
+}
+
+private fun String.extractFirst(regex: String) =
+	regex.toRegex().find(this)?.groupValues?.get(1)

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/search/OpenOrSearchAction.kt

@@ -4,9 +4,9 @@ import android.content.Context
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.actions.IAction
 import de.markusfisch.android.binaryeye.app.alertDialog
-import de.markusfisch.android.binaryeye.app.urlEncode
 import de.markusfisch.android.binaryeye.app.prefs
 import de.markusfisch.android.binaryeye.content.openUrl
+import de.markusfisch.android.binaryeye.net.urlEncode
 
 object OpenOrSearchAction : IAction {
 	override val iconResId: Int = R.drawable.ic_action_search
@@ -23,7 +23,7 @@ object OpenOrSearchAction : IAction {
 		url: String,
 		search: Boolean
 	) {
-		if (!context.openUrl(url) && search) {
+		if (!context.openUrl(url, silent = true) && search) {
 			openSearch(context, url)
 		}
 	}
@@ -46,8 +46,8 @@ object OpenOrSearchAction : IAction {
 		).toMutableList()
 		// Remove the "Always ask" entry. The arrays search_engines_*
 		// are used in the preferences too.
-		names.removeFirst()
-		urls.removeFirst()
+		names.removeAt(0)
+		urls.removeAt(0)
 		if (prefs.openWithUrl.isNotEmpty()) {
 			names.add(prefs.openWithUrl)
 			urls.add(prefs.openWithUrl)

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/tel/TelAction.kt

@@ -4,7 +4,7 @@ import android.content.Context
 import android.content.Intent
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.actions.IntentAction
-import de.markusfisch.android.binaryeye.app.parseAndNormalizeUri
+import de.markusfisch.android.binaryeye.content.parseAndNormalizeUri
 
 object TelAction : IntentAction() {
 	private val telRegex = """^tel:(\+?[0-9]+)$""".toRegex(

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/vtype/VType.kt

@@ -1,6 +1,6 @@
 package de.markusfisch.android.binaryeye.actions.vtype
 
-import java.util.*
+import java.util.Locale
 
 object VTypeParser {
 	private const val BACKSLASH_R_LEGACY =
@@ -39,6 +39,6 @@ data class VTypeProperty(
 		} ?: this.info.firstOrNull()
 
 	companion object {
-		private val typeRegex = """^(?:TYPE=)(.+?)[:;]?.*$""".toRegex(RegexOption.IGNORE_CASE)
+		private val typeRegex = """^TYPE=([A-Z_]+)[:;]?.*$""".toRegex(RegexOption.IGNORE_CASE)
 	}
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/vtype/vcard/VCardAction.kt

@@ -8,8 +8,7 @@ import android.provider.ContactsContract
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.actions.IntentAction
 import de.markusfisch.android.binaryeye.actions.vtype.VTypeParser
-import java.util.*
-import kotlin.collections.ArrayList
+import java.util.Locale
 
 object VCardAction : IntentAction() {
 	override val iconResId: Int
@@ -46,10 +45,13 @@ object VCardAction : IntentAction() {
 				val (extraPhoneType, extraPhone) = when (index) {
 					0 -> ContactsContract.Intents.Insert.PHONE_TYPE to
 							ContactsContract.Intents.Insert.PHONE
+
 					1 -> ContactsContract.Intents.Insert.SECONDARY_PHONE_TYPE to
 							ContactsContract.Intents.Insert.SECONDARY_PHONE
+
 					2 -> ContactsContract.Intents.Insert.TERTIARY_PHONE_TYPE to
 							ContactsContract.Intents.Insert.TERTIARY_PHONE_TYPE
+
 					else -> return@forEachIndexed
 				}
 				phoneProperty.firstTypeOrFirstInfo?.also {
@@ -66,10 +68,13 @@ object VCardAction : IntentAction() {
 				val (extraMailType, extraMail) = when (index) {
 					0 -> ContactsContract.Intents.Insert.EMAIL_TYPE to
 							ContactsContract.Intents.Insert.EMAIL
+
 					1 -> ContactsContract.Intents.Insert.SECONDARY_EMAIL_TYPE to
 							ContactsContract.Intents.Insert.SECONDARY_EMAIL
+
 					2 -> ContactsContract.Intents.Insert.TERTIARY_EMAIL_TYPE to
 							ContactsContract.Intents.Insert.TERTIARY_EMAIL
+
 					else -> return@forEachIndexed
 				}
 				mailProperty.firstTypeOrFirstInfo?.also {
@@ -185,7 +190,7 @@ object VCardAction : IntentAction() {
 		}
 
 	private val String.addressType: Int?
-		get() = when (this.toUpperCase(Locale.US)) {
+		get() = when (this.uppercase()) {
 			"HOME" -> ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME
 			"WORK" -> ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK
 			"OTHER" -> ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/vtype/vevent/VEventAction.kt

@@ -1,6 +1,5 @@
 package de.markusfisch.android.binaryeye.actions.vtype.vevent
 
-import android.annotation.SuppressLint
 import android.content.Context
 import android.content.Intent
 import android.os.Build
@@ -10,7 +9,8 @@ import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.actions.IntentAction
 import de.markusfisch.android.binaryeye.actions.vtype.VTypeParser
 import java.text.SimpleDateFormat
-import java.util.*
+import java.util.Date
+import java.util.Locale
 
 object VEventAction : IntentAction() {
 	override val iconResId: Int
@@ -45,38 +45,49 @@ object VEventAction : IntentAction() {
 			}
 			info["DTSTART"]?.singleOrNull()?.also { eventStart ->
 				dateFormats.simpleFindParse(eventStart.value)?.also {
-					putExtra(CalendarContract.EXTRA_EVENT_BEGIN_TIME, it.time)
+					putExtra(
+						CalendarContract.EXTRA_EVENT_BEGIN_TIME,
+						it.time
+					)
 				}
 			}
 			info["DTEND"]?.singleOrNull()?.also { eventEnd ->
 				dateFormats.simpleFindParse(eventEnd.value)?.also {
-					putExtra(CalendarContract.EXTRA_EVENT_END_TIME, it.time)
+					putExtra(
+						CalendarContract.EXTRA_EVENT_END_TIME,
+						it.time
+					)
 				}
 			}
 		}
 	}
-
-	// We definitely don't wan't the local format.
-	@SuppressLint("SimpleDateFormat")
-	private val dateFormats = listOf(
-		SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss'Z'"),
-		SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss"),
-		SimpleDateFormat("yyyyMMdd'T'HHmmss'Z'"),
-		SimpleDateFormat("yyyyMMdd'T'HHmmss"),
-		SimpleDateFormat("yyyy-MM-dd"),
-		SimpleDateFormat("yyyyMMdd")
-	)
-
-	private fun List<SimpleDateFormat>.simpleFindParse(data: String): Date? {
-		for (simpleDataFormat in this) {
-			return simpleDataFormat.simpleParse(data) ?: continue
-		}
-		return null
-	}
-
-	private fun SimpleDateFormat.simpleParse(data: String): Date? = try {
-		this.parse(data)
-	} catch (e: Exception) {
-		null
-	}
+}
+
+private val dateFormats = listOf(
+	"yyyy-MM-dd'T'HH:mm:ssXXX",
+	"yyyy-MM-dd'T'HH:mm:ssZ",
+	"yyyy-MM-dd'T'HH:mm:ssz",
+	"yyyy-MM-dd'T'HH:mm:ss",
+	"yyyyMMdd'T'HHmmssXXX",
+	"yyyyMMdd'T'HHmmssZ",
+	"yyyyMMdd'T'HHmmssz",
+	"yyyyMMdd'T'HHmmss",
+	"yyyy-MM-dd",
+	"yyyyMMdd"
+)
+
+private fun List<String>.simpleFindParse(date: String): Date? {
+	for (pattern in this) {
+		return SimpleDateFormat(
+			pattern,
+			Locale.getDefault()
+		).simpleParse(date) ?: continue
+	}
+	return null
+}
+
+private fun SimpleDateFormat.simpleParse(date: String): Date? = try {
+	parse(date)
+} catch (e: Exception) {
+	null
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/web/WebAction.kt

@@ -1,11 +1,29 @@
 package de.markusfisch.android.binaryeye.actions.web
 
+import android.content.Context
 import de.markusfisch.android.binaryeye.R
-import de.markusfisch.android.binaryeye.actions.SchemeAction
+import de.markusfisch.android.binaryeye.actions.IAction
+import de.markusfisch.android.binaryeye.content.openUrl
+
+object WebAction : IAction {
+	private val colloquialRegex =
+		"^(URL:[ ]*)*(http[s]*://)*[A-Za-z0-9-]{3,}\\.[A-Za-z]{2,}[^ \t\r\n]*$".toRegex()
 
-object WebAction : SchemeAction() {
 	override val iconResId: Int = R.drawable.ic_action_open
 	override val titleResId: Int = R.string.open_url
-	override val scheme: String = "https?"
-	override val buildRegex: Boolean = true
+
+	override fun canExecuteOn(data: ByteArray): Boolean {
+		return String(data).trim().matches(colloquialRegex)
+	}
+
+	override suspend fun execute(context: Context, data: ByteArray) {
+		var url = String(data).trim()
+		if (url.startsWith("URL:")) {
+			url = url.substring(4).trim()
+		}
+		if (!url.startsWith("http") && !url.startsWith("ftp")) {
+			url = "http://${url}"
+		}
+		context.openUrl(url)
+	}
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/wifi/WifiAction.kt

@@ -22,10 +22,9 @@ object WifiAction : IAction {
 		context: Context,
 		data: ByteArray
 	) = withContext(Dispatchers.IO) {
-		val wifiConfig = WifiConnector.parse(
-			String(data)
-		) ?: return@withContext
-		val message = WifiConnector.addNetwork(context, wifiConfig)
+		val message = WifiConnector.parse(String(data))?.let {
+			WifiConnector.addNetwork(context, it)
+		} ?: R.string.wifi_config_failed
 		withContext(Dispatchers.Main) {
 			context.toast(message)
 		}

app/src/main/kotlin/de/markusfisch/android/binaryeye/actions/wifi/WifiConnector.kt

@@ -10,12 +10,6 @@ import android.support.annotation.RequiresApi
 import de.markusfisch.android.binaryeye.R
 import java.util.*
 
-@RequiresApi(Build.VERSION_CODES.Q)
-fun removeNetworkSuggestions(context: Context): Int =
-	(context.applicationContext.getSystemService(
-		Context.WIFI_SERVICE
-	) as WifiManager).removeNetworkSuggestions(listOf())
-
 /**
  * Normal:
  * WIFI:S:[network SSID];T:<WPA|WEP|nopass|>;P:[network password];H:<true|false|>;;
@@ -50,12 +44,21 @@ object WifiConnector {
 		passwordBlock?.apply {
 			invoke(parsedData.password)
 		}
-		return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-			// WifiConfiguration is deprecated in Android Q.
-			@Suppress("DEPRECATION")
-			WifiConfiguration().apply(parsedData)
-		} else {
-			WifiNetworkSuggestion.Builder().apply(parsedData)
+		return try {
+			if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q) {
+				// WifiConfiguration is deprecated in Android Q but
+				// because it's only possible in R to query network
+				// suggestions, we still use the deprecated API on Q.
+				@Suppress("DEPRECATION")
+				WifiConfiguration().apply(parsedData)
+			} else {
+				WifiNetworkSuggestion.Builder().apply(parsedData)
+			}
+		} catch (e: IllegalArgumentException) {
+			// Some arguments may be out of range, e.g. SSIDs cannot
+			// be longer than 32 characters in some versions of Android.
+			// See: https://github.com/markusfisch/BinaryEye/issues/402
+			null
 		}
 	}
 
@@ -63,33 +66,23 @@ object WifiConnector {
 		val wifiManager = context.applicationContext.getSystemService(
 			Context.WIFI_SERVICE
 		) as WifiManager
-		return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-			// WifiConfiguration is deprecated in Android Q.
-			@Suppress("DEPRECATION")
-			val wifiConfig = config as WifiConfiguration
-			if (wifiManager.enableWifi() &&
-				wifiManager.removeOldNetwork(wifiConfig) &&
-				wifiManager.enableNewNetwork(wifiConfig)
-			) {
-				R.string.wifi_added
-			} else {
-				R.string.wifi_config_failed
-			}
+		// WifiConfiguration is deprecated in Android Q.
+		@Suppress("DEPRECATION")
+		return if ((config is WifiConfiguration &&
+					wifiManager.enableWifi() &&
+					wifiManager.removeOldNetwork(config) &&
+					wifiManager.enableNewNetwork(config)) ||
+			(Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q &&
+					config is WifiNetworkSuggestion.Builder &&
+					wifiManager.addNetworkFromBuilder(config))
+		) {
+			R.string.wifi_added
 		} else {
-			val suggestion = (config as WifiNetworkSuggestion.Builder).build()
-			val suggestions = listOf(suggestion)
-			// Remove previous conflicting network suggestion.
-			wifiManager.removeNetworkSuggestions(suggestions)
-			val result = wifiManager.addNetworkSuggestions(suggestions)
-			if (result == WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS) {
-				R.string.wifi_added
-			} else {
-				R.string.wifi_config_failed
-			}
+			R.string.wifi_config_failed
 		}
 	}
 
-	internal fun parseMap(string: String): Map<String, String>? {
+	internal fun parseMap(input: String): Map<String, String>? {
 		// Normally those codes should have the last semicolon, but many
 		// generators don't add it.
 		val wifiRegex = """^WIFI:((?:.+?:(?:[^\\;]|\\.)*;)+);?$""".toRegex()
@@ -97,7 +90,7 @@ object WifiConnector {
 		// and : because many QR Code creators don't escape properly.
 		val pairRegex = """(.+?):((?:[^\\;]|\\.)*);""".toRegex()
 		return wifiRegex.matchEntire(
-			string
+			input.trimAndTerminate()
 		)?.groupValues?.get(1)?.let { pairs ->
 			pairRegex.findAll(pairs).map { pair ->
 				pair.groupValues[1].uppercase(Locale.US) to pair.groupValues[2]
@@ -126,7 +119,7 @@ object WifiConnector {
 				requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) {
 					WifiEnterpriseConfig.Eap.NONE
 				}
-			} else when (inputMap["E"]) {
+			} else when (inputMap["E"]?.uppercase()) {
 				"AKA" -> requireSdk(Build.VERSION_CODES.LOLLIPOP) { WifiEnterpriseConfig.Eap.AKA }
 				"AKA_PRIME" -> requireSdk(Build.VERSION_CODES.M) { WifiEnterpriseConfig.Eap.AKA_PRIME }
 				"NONE" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Eap.NONE }
@@ -143,7 +136,7 @@ object WifiConnector {
 				requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) {
 					WifiEnterpriseConfig.Phase2.NONE
 				}
-			} else when (inputMap["PH2"]) {
+			} else when (inputMap["PH2"]?.uppercase()) {
 				"AKA" -> requireSdk(Build.VERSION_CODES.O) { WifiEnterpriseConfig.Phase2.AKA }
 				"AKA_PRIME" -> requireSdk(Build.VERSION_CODES.O) { WifiEnterpriseConfig.Phase2.AKA_PRIME }
 				"GTC" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Phase2.GTC }
@@ -179,10 +172,11 @@ object WifiConnector {
 			data: SimpleDataAccessor
 		): WifiNetworkSuggestion.Builder? {
 			try {
-				when (data.securityType) {
+				when (data.securityType.uppercase()) {
 					"WPA", "WPA2" -> {
 						data.password?.let { setWpa2Passphrase(it) }
 					}
+
 					"WPA2-EAP" -> {
 						setWpa2EnterpriseConfig(WifiEnterpriseConfig().apply {
 							identity = data.identity
@@ -192,9 +186,11 @@ object WifiConnector {
 							data.phase2Method?.let { phase2Method = it }
 						})
 					}
+
 					"WPA3" -> {
 						data.password?.let { setWpa3Passphrase(it) }
 					}
+
 					"WPA3-EAP" -> {
 						setWpa3EnterpriseConfig(WifiEnterpriseConfig().apply {
 							identity = data.identity
@@ -240,8 +236,8 @@ object WifiConnector {
 		fun WifiConfiguration.applySecurity(
 			data: SimpleDataAccessor
 		): WifiConfiguration? {
-			when (data.securityType) {
-				"", "nopass" -> allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
+			when (data.securityType.uppercase()) {
+				"", "NOPASS" -> allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
 				"WEP" -> @Suppress("DEPRECATION") /* WEP as insecure */ {
 					passwordWithQuotes?.let {
 						wepKeys[0] = it
@@ -254,6 +250,7 @@ object WifiConnector {
 					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40)
 					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104)
 				}
+
 				"WPA" -> {
 					passwordWithQuotes?.let {
 						preSharedKey = it
@@ -270,6 +267,7 @@ object WifiConnector {
 					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
 					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
 				}
+
 				"WPA2-EAP" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) {
 					passwordWithQuotes?.let {
 						preSharedKey = it
@@ -303,11 +301,32 @@ object WifiConnector {
 	}
 }
 
+@RequiresApi(Build.VERSION_CODES.Q)
+private fun WifiManager.addNetworkFromBuilder(
+	builder: WifiNetworkSuggestion.Builder
+): Boolean {
+	val suggestion = builder.build()
+	val suggestions = listOf(suggestion)
+	// Remove previous conflicting network suggestion.
+	removeNetworkSuggestions(suggestions)
+	val result = addNetworkSuggestions(suggestions)
+	return result == WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS
+}
+
+// Make sure the string ends with a semicolon.
+private fun String.trimAndTerminate(): String {
+	var trimmed = trim()
+	if (trimmed.isNotEmpty() && trimmed.last() != ';') {
+		trimmed += ";"
+	}
+	return trimmed
+}
+
 // Keep possibility of wrongly unescaped \ by explicitly searching
 // for special chars.
 private val escapedRegex = """\\([\\;,":])""".toRegex()
 private val String.unescape: String
-	get() = this.replace(escapedRegex) { escaped ->
+	get() = replace(escapedRegex) { escaped ->
 		escaped.groupValues[1]
 	}
 

app/src/main/kotlin/de/markusfisch/android/binaryeye/activity/CameraActivity.kt

@@ -1,5 +1,6 @@
 package de.markusfisch.android.binaryeye.activity
 
+import android.annotation.SuppressLint
 import android.app.Activity
 import android.app.AlertDialog
 import android.content.Context
@@ -7,76 +8,69 @@ import android.content.Intent
 import android.content.pm.PackageManager
 import android.graphics.Matrix
 import android.graphics.Rect
-import android.graphics.RectF
 import android.hardware.Camera
-import android.media.AudioManager
-import android.media.ToneGenerator
 import android.net.Uri
+import android.os.Build
 import android.os.Bundle
-import android.os.Vibrator
 import android.support.design.widget.FloatingActionButton
 import android.support.v7.app.AppCompatActivity
-import android.support.v7.widget.Toolbar
-import android.support.v8.renderscript.RSRuntimeException
-import android.support.v8.renderscript.RenderScript
 import android.view.Menu
 import android.view.MenuItem
 import android.view.MotionEvent
 import android.view.View
+import android.widget.EditText
 import android.widget.SeekBar
-import com.google.zxing.Result
-import com.google.zxing.ResultMetadataType
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.adapter.prettifyFormatName
-import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.app.PERMISSION_CAMERA
+import de.markusfisch.android.binaryeye.app.applyLocale
+import de.markusfisch.android.binaryeye.app.db
+import de.markusfisch.android.binaryeye.app.hasBluetoothPermission
+import de.markusfisch.android.binaryeye.app.hasCameraPermission
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.bluetooth.sendBluetoothAsync
 import de.markusfisch.android.binaryeye.content.copyToClipboard
 import de.markusfisch.android.binaryeye.content.execShareIntent
 import de.markusfisch.android.binaryeye.content.openUrl
+import de.markusfisch.android.binaryeye.content.toHexString
 import de.markusfisch.android.binaryeye.database.toScan
-import de.markusfisch.android.binaryeye.graphics.getFrameToViewMatrix
-import de.markusfisch.android.binaryeye.graphics.map
+import de.markusfisch.android.binaryeye.graphics.FrameMetrics
+import de.markusfisch.android.binaryeye.graphics.mapPosition
+import de.markusfisch.android.binaryeye.graphics.setFrameRoi
+import de.markusfisch.android.binaryeye.graphics.setFrameToView
+import de.markusfisch.android.binaryeye.media.releaseToneGenerators
 import de.markusfisch.android.binaryeye.net.sendAsync
-import de.markusfisch.android.binaryeye.os.error
-import de.markusfisch.android.binaryeye.os.getVibrator
-import de.markusfisch.android.binaryeye.os.vibrate
-import de.markusfisch.android.binaryeye.rs.Preprocessor
-import de.markusfisch.android.binaryeye.view.initSystemBars
+import de.markusfisch.android.binaryeye.net.urlEncode
+import de.markusfisch.android.binaryeye.preference.Preferences
+import de.markusfisch.android.binaryeye.view.errorFeedback
+import de.markusfisch.android.binaryeye.view.initBars
+import de.markusfisch.android.binaryeye.view.scanFeedback
 import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
 import de.markusfisch.android.binaryeye.widget.DetectorView
 import de.markusfisch.android.binaryeye.widget.toast
-import de.markusfisch.android.binaryeye.zxing.Zxing
 import de.markusfisch.android.cameraview.widget.CameraView
+import de.markusfisch.android.zxingcpp.ZxingCpp
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
+import de.markusfisch.android.zxingcpp.ZxingCpp.Binarizer
+import de.markusfisch.android.zxingcpp.ZxingCpp.ReaderOptions
+import de.markusfisch.android.zxingcpp.ZxingCpp.Result
+import java.io.FileInputStream
+import java.util.Scanner
 import kotlin.math.max
 import kotlin.math.min
 import kotlin.math.roundToInt
 
 class CameraActivity : AppCompatActivity() {
-	private val zxing = Zxing { point ->
-		point ?: return@Zxing
-		val matrix = getMappingMatrix() ?: return@Zxing
-		detectorView.post {
-			detectorView.update(
-				matrix.map(
-					arrayOf(point),
-					detectorView.coordinates
-				)
-			)
-		}
-	}
+	private val frameRoi = Rect()
+	private val matrix = Matrix()
 
-	private lateinit var rs: RenderScript
-	private lateinit var vibrator: Vibrator
 	private lateinit var cameraView: CameraView
 	private lateinit var detectorView: DetectorView
 	private lateinit var zoomBar: SeekBar
 	private lateinit var flashFab: FloatingActionButton
 
-	private var preprocessor: Preprocessor? = null
-	private var nativeMappingMatrix: Matrix? = null
-	private var rotatedMappingMatrix: Matrix? = null
-	private var recreatePreprocessor = false
-	private var rotate = false
-	private var invert = false
+	private var formatsToRead = setOf<BarcodeFormat>()
+	private var frameMetrics = FrameMetrics()
 	private var decoding = true
 	private var returnResult = false
 	private var returnUrlTemplate: String? = null
@@ -84,8 +78,10 @@ class CameraActivity : AppCompatActivity() {
 	private var frontFacing = false
 	private var bulkMode = prefs.bulkMode
 	private var restrictFormat: String? = null
+	private var searchTerm: String? = null
 	private var ignoreNext: String? = null
 	private var fallbackBuffer: IntArray? = null
+	private var requestCameraPermission = true
 
 	override fun onRequestPermissionsResult(
 		requestCode: Int,
@@ -96,8 +92,7 @@ class CameraActivity : AppCompatActivity() {
 			PERMISSION_CAMERA -> if (grantResults.isNotEmpty() &&
 				grantResults[0] != PackageManager.PERMISSION_GRANTED
 			) {
-				toast(R.string.no_camera_no_fun)
-				finish()
+				toast(R.string.camera_error)
 			}
 		}
 	}
@@ -132,11 +127,7 @@ class CameraActivity : AppCompatActivity() {
 		// custom locale.
 		setTitle(R.string.scan_code)
 
-		rs = RenderScript.create(this)
-		vibrator = getVibrator()
-
-		initSystemBars(this)
-		setSupportActionBar(findViewById(R.id.toolbar) as Toolbar)
+		initBars()
 
 		cameraView = findViewById(R.id.camera_view) as CameraView
 		detectorView = findViewById(R.id.detector_view) as DetectorView
@@ -148,7 +139,7 @@ class CameraActivity : AppCompatActivity() {
 		initDetectorView()
 
 		if (intent?.action == Intent.ACTION_SEND &&
-			intent.type == "text/plain"
+			intent.type?.startsWith("text/") == true
 		) {
 			handleSendText(intent)
 		}
@@ -156,41 +147,55 @@ class CameraActivity : AppCompatActivity() {
 
 	override fun onDestroy() {
 		super.onDestroy()
-		resetPreProcessor()
 		fallbackBuffer = null
 		saveZoom()
-		detectorView.saveCropHandlePos()
-		rs.destroy()
+		detectorView.storeCropHandlePos(CAMERA_CROP_HANDLE)
+		releaseToneGenerators()
 	}
 
 	override fun onResume() {
 		super.onResume()
 		System.gc()
-		updateHints()
+		updateHintsAndTitle()
 		if (prefs.bulkMode && bulkMode != prefs.bulkMode) {
 			bulkMode = prefs.bulkMode
 			invalidateOptionsMenu()
 			ignoreNext = null
 		}
 		setReturnTarget(intent)
-		if (hasCameraPermission()) {
+		// Avoid asking multiple times when the user has denied access
+		// for this session. Otherwise ActivityCompat.requestPermissions()
+		// will trigger onResume() again and again.
+		if (hasCameraPermission(requestCameraPermission)) {
 			openCamera()
 		}
+		requestCameraPermission = false
 	}
 
-	private fun updateHints() {
+	private fun updateHintsAndTitle() {
 		val restriction = restrictFormat
-		val formats = if (restriction != null) {
-			title = getString(
-				R.string.scan_format,
-				prettifyFormatName(restriction)
-			)
+		formatsToRead = if (restriction != null) {
 			setOf(restriction)
 		} else {
-			setTitle(R.string.scan_code)
 			prefs.barcodeFormats
+		}.toFormatSet()
+		updateTitle()
+	}
+
+	private fun updateTitle() {
+		if (searchTerm != null || restrictFormat != null) {
+			title = getString(
+				R.string.scan_format,
+				prettifyFormatName(
+					listOfNotNull(
+						restrictFormat,
+						searchTerm
+					).joinToString(",")
+				)
+			)
+		} else {
+			setTitle(R.string.scan_code)
 		}
-		zxing.updateHints(prefs.tryHarder, formats)
 	}
 
 	private fun setReturnTarget(intent: Intent?) {
@@ -198,6 +203,7 @@ class CameraActivity : AppCompatActivity() {
 			intent?.action == "com.google.zxing.client.android.SCAN" -> {
 				returnResult = true
 			}
+
 			intent?.dataString?.isReturnUrl() == true -> {
 				finishAfterShowingResult = true
 				returnUrlTemplate = intent.data?.getQueryParameter("ret")
@@ -205,11 +211,6 @@ class CameraActivity : AppCompatActivity() {
 		}
 	}
 
-	private fun resetPreProcessor() {
-		preprocessor?.destroy()
-		preprocessor = null
-	}
-
 	private fun openCamera() {
 		cameraView.openAsync(
 			CameraView.findCameraId(
@@ -239,6 +240,7 @@ class CameraActivity : AppCompatActivity() {
 		frontFacing = savedState.getBoolean(FRONT_FACING)
 		bulkMode = savedState.getBoolean(BULK_MODE)
 		restrictFormat = savedState.getString(RESTRICT_FORMAT)
+		searchTerm = savedState.getString(SEARCH_TERM)
 	}
 
 	override fun onSaveInstanceState(outState: Bundle) {
@@ -247,6 +249,7 @@ class CameraActivity : AppCompatActivity() {
 		outState.putBoolean(FRONT_FACING, frontFacing)
 		outState.putBoolean(BULK_MODE, bulkMode)
 		outState.putString(RESTRICT_FORMAT, restrictFormat)
+		outState.putString(SEARCH_TERM, searchTerm)
 		super.onSaveInstanceState(outState)
 	}
 
@@ -271,44 +274,57 @@ class CameraActivity : AppCompatActivity() {
 				createBarcode()
 				true
 			}
+
 			R.id.history -> {
 				startActivity(MainActivity.getHistoryIntent(this))
 				true
 			}
+
 			R.id.pick_file -> {
 				startActivityForResult(
 					Intent.createChooser(
 						Intent(Intent.ACTION_GET_CONTENT).apply {
 							type = "image/*"
 						},
-						getString(R.string.pick_file)
+						getString(R.string.pick_image_file)
 					),
 					PICK_FILE_RESULT_CODE
 				)
 				true
 			}
+
 			R.id.switch_camera -> {
 				switchCamera()
 				true
 			}
+
 			R.id.bulk_mode -> {
 				bulkMode = bulkMode xor true
 				item.isChecked = bulkMode
 				ignoreNext = null
 				true
 			}
+
 			R.id.restrict_format -> {
 				showRestrictionDialog()
 				true
 			}
+
+			R.id.find_code -> {
+				askForCode()
+				true
+			}
+
 			R.id.preferences -> {
 				startActivity(MainActivity.getPreferencesIntent(this))
 				true
 			}
+
 			R.id.info -> {
 				openReadme()
 				true
 			}
+
 			else -> super.onOptionsItemSelected(item)
 		}
 	}
@@ -338,12 +354,36 @@ class CameraActivity : AppCompatActivity() {
 			setTitle(R.string.restrict_format)
 			setItems(names.toTypedArray()) { _, which ->
 				restrictFormat = formats[which]
-				updateHints()
+				updateHintsAndTitle()
 			}
 			show()
 		}
 	}
 
+	// Dialogs do not have a parent view.
+	@SuppressLint("InflateParams")
+	private fun askForCode() {
+		val view = layoutInflater.inflate(R.layout.dialog_find_code, null)
+		val editText = view.findViewById<EditText>(R.id.term)
+		searchTerm.let {
+			editText.setText(it)
+		}
+		AlertDialog.Builder(this)
+			.setView(view)
+			.setPositiveButton(android.R.string.ok) { _, _ ->
+				searchTerm = editText.text.toString()
+				if (searchTerm?.isEmpty() == true) {
+					searchTerm = null
+				}
+				updateTitle()
+			}
+			.setNegativeButton(android.R.string.cancel) { _, _ ->
+				searchTerm = null
+				updateTitle()
+			}
+			.show()
+	}
+
 	private fun openReadme() {
 		val intent = Intent(
 			Intent.ACTION_VIEW,
@@ -354,9 +394,34 @@ class CameraActivity : AppCompatActivity() {
 
 	private fun handleSendText(intent: Intent) {
 		val text = intent.getStringExtra(Intent.EXTRA_TEXT)
+
 		if (text?.isEmpty() == false) {
 			startActivity(MainActivity.getEncodeIntent(this, text, true))
 			finish()
+			return
+		}
+
+		// Read text from file.
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+			@Suppress("DEPRECATION")
+			intent.getParcelableExtra(Intent.EXTRA_STREAM) as Uri?
+		} else {
+			intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
+		}?.let { textUri ->
+			val file = contentResolver.openFileDescriptor(textUri, "r")
+			if (file != null) {
+				val fs = FileInputStream(file.fileDescriptor)
+				val scn = Scanner(fs).useDelimiter("\\A")
+				if (scn.hasNext()) {
+					startActivity(
+						MainActivity.getEncodeIntent(
+							this, scn.next(), true
+						)
+					)
+					finish()
+				}
+				file.close()
+			}
 		}
 	}
 
@@ -377,6 +442,7 @@ class CameraActivity : AppCompatActivity() {
 						progress = zoomBar.progress
 						return true
 					}
+
 					MotionEvent.ACTION_MOVE -> {
 						if (prefs.zoomBySwiping) {
 							v ?: return false
@@ -390,6 +456,7 @@ class CameraActivity : AppCompatActivity() {
 							return true
 						}
 					}
+
 					MotionEvent.ACTION_UP -> {
 						// Stop calling focusTo() as soon as it returns false
 						// to avoid throwing and catching future exceptions.
@@ -437,28 +504,54 @@ class CameraActivity : AppCompatActivity() {
 
 			override fun onCameraError() {
 				this@CameraActivity.toast(R.string.camera_error)
-				finish()
 			}
 
 			override fun onCameraReady(camera: Camera) {
-				// Reset preprocessor to make sure it always fits the current
-				// frame orientation. Important for landscape to landscape
-				// orientation changes.
-				resetPreProcessor()
-				val frameWidth = cameraView.frameWidth
-				val frameHeight = cameraView.frameHeight
-				val frameOrientation = cameraView.frameOrientation
+				frameMetrics = FrameMetrics(
+					cameraView.frameWidth,
+					cameraView.frameHeight,
+					cameraView.frameOrientation
+				)
+				updateFrameRoiAndMappingMatrix()
 				ignoreNext = null
 				decoding = true
+				// These settings can't change while the camera is open.
+				val options = ReaderOptions(
+					tryHarder = prefs.tryHarder,
+					tryRotate = prefs.autoRotate,
+					tryInvert = true,
+					tryDownscale = true,
+					returnCodabarStartEnd = true,
+					maxNumberOfSymbols = 1
+				)
+				var useLocalAverage = false
 				camera.setPreviewCallback { frameData, _ ->
 					if (decoding) {
-						decodeFrame(
+						useLocalAverage = useLocalAverage xor true
+						ZxingCpp.readByteArray(
 							frameData,
-							frameWidth,
-							frameHeight,
-							frameOrientation
-						)?.let { result ->
-							if (result.text != ignoreNext) {
+							frameMetrics.width,
+							frameRoi.left, frameRoi.top,
+							frameRoi.width(), frameRoi.height(),
+							frameMetrics.orientation,
+							options.apply {
+								// By default, ZXing uses LOCAL_AVERAGE, but
+								// this does not work well with inverted
+								// barcodes on low-contrast backgrounds.
+								binarizer = if (useLocalAverage) {
+									Binarizer.LOCAL_AVERAGE
+								} else {
+									Binarizer.GLOBAL_HISTOGRAM
+								}
+								formats = formatsToRead
+							}
+						)?.let { results ->
+							val result = results.first()
+							val text = result.text
+							val term = searchTerm
+							if (text != ignoreNext &&
+								(term == null || text.contains(term))
+							) {
 								postResult(result)
 								decoding = false
 							}
@@ -526,10 +619,21 @@ class CameraActivity : AppCompatActivity() {
 		}
 		detectorView.onRoiChanged = {
 			decoding = true
-			recreatePreprocessor = true
+			updateFrameRoiAndMappingMatrix()
 		}
 		detectorView.setPaddingFromWindowInsets()
-		detectorView.restoreCropHandlePos()
+		detectorView.restoreCropHandlePos(CAMERA_CROP_HANDLE)
+	}
+
+	private fun updateFrameRoiAndMappingMatrix() {
+		val viewRect = cameraView.previewRect
+		val viewRoi = if (detectorView.roi.width() < 1) {
+			viewRect
+		} else {
+			detectorView.roi
+		}
+		frameRoi.setFrameRoi(frameMetrics, viewRect, viewRoi)
+		matrix.setFrameToView(frameMetrics, viewRect, viewRoi)
 	}
 
 	private fun updateFlashFab(unavailable: Boolean) {
@@ -560,162 +664,15 @@ class CameraActivity : AppCompatActivity() {
 		}
 	}
 
-	private fun decodeFrame(
-		frameData: ByteArray?,
-		frameWidth: Int,
-		frameHeight: Int,
-		frameOrientation: Int
-	): Result? {
-		frameData ?: return null
-		rotate = if (prefs.autoRotate) {
-			rotate xor true
-		} else {
-			invert = invert xor true
-			isPortrait(frameOrientation)
-		}
-		return try {
-			if (recreatePreprocessor) {
-				resetPreProcessor()
-				recreatePreprocessor = false
-			}
-			val pp = preprocessor ?: createPreprocessorAndMapping(
-				frameWidth,
-				frameHeight,
-				frameOrientation
-			)
-			val w: Int
-			val h: Int
-			if (rotate) {
-				pp.resizeAndRotate(frameData)
-				w = pp.outHeight
-				h = pp.outWidth
-			} else {
-				invert = invert xor true
-				pp.resizeOnly(frameData)
-				w = pp.outWidth
-				h = pp.outHeight
-			}
-			preprocessor = pp
-			zxing.decode(frameData, w, h, invert)
-		} catch (e: RSRuntimeException) {
-			prefs.forceCompat = prefs.forceCompat xor true
-			// Now the only option is to restart the app because
-			// RenderScript.forceCompat() needs to be called before
-			// RenderScript is initialized.
-			restartApp()
-			null
-		}
-	}
-
-	private fun createPreprocessorAndMapping(
-		frameWidth: Int,
-		frameHeight: Int,
-		frameOrientation: Int
-	): Preprocessor {
-		val frameRoi = calculateFrameRect(
-			frameWidth,
-			frameHeight,
-			frameOrientation
-		)
-		val pp = Preprocessor(
-			rs,
-			frameWidth,
-			frameHeight,
-			frameRoi
-		)
-		val viewRect = if (frameRoi != null) {
-			detectorView.roi
-		} else {
-			cameraView.previewRect
-		}
-		nativeMappingMatrix = getFrameToViewMatrix(
-			pp.outWidth,
-			pp.outHeight,
-			frameOrientation,
-			viewRect
-		)
-		rotatedMappingMatrix = getFrameToViewMatrix(
-			pp.outHeight,
-			pp.outWidth,
-			(frameOrientation - 90 + 360) % 360,
-			viewRect
-		)
-		return pp
-	}
-
-	private fun calculateFrameRect(
-		frameWidth: Int,
-		frameHeight: Int,
-		frameOrientation: Int
-	): Rect? {
-		val viewRoi = detectorView.roi
-		return if (
-			viewRoi.width() == 0 ||
-			viewRoi.height() == 0
-		) {
-			null
-		} else {
-			// Map ROI in detectorView to cameraView.
-			val previewRect = cameraView.previewRect
-			// previewRect may be larger than the screen (and thus as the
-			// detectorView) in which case its left and/or top coordinate
-			// will be negative which must then be clamped to the
-			// screen/DetectorView.
-			val previewLeft = max(0, previewRect.left)
-			val previewTop = max(0, previewRect.top)
-			val previewRoi = Rect(
-				previewLeft + viewRoi.left,
-				previewTop + viewRoi.top,
-				previewLeft + viewRoi.right,
-				previewTop + viewRoi.bottom
-			)
-			val previewRectWidth = previewRect.width().toFloat()
-			val previewRectHeight = previewRect.height().toFloat()
-			val normalizedRoi = RectF(
-				previewRoi.left.toFloat() / previewRectWidth,
-				previewRoi.top.toFloat() / previewRectHeight,
-				previewRoi.right.toFloat() / previewRectWidth,
-				previewRoi.bottom.toFloat() / previewRectHeight
-			)
-			// Since the ROI is always centered and symmetric, we don't
-			// need to distinguish between 0 and 180 or 90 and 270 degree.
-			val errectedRoi = if (isPortrait(frameOrientation)) {
-				RectF(
-					normalizedRoi.top,
-					normalizedRoi.left,
-					normalizedRoi.bottom,
-					normalizedRoi.right
-				)
-			} else {
-				normalizedRoi
-			}
-			Rect(
-				(errectedRoi.left * frameWidth.toFloat()).roundToInt(),
-				(errectedRoi.top * frameHeight.toFloat()).roundToInt(),
-				(errectedRoi.right * frameWidth.toFloat()).roundToInt(),
-				(errectedRoi.bottom * frameHeight.toFloat()).roundToInt()
-			)
-		}
-	}
-
 	private fun postResult(result: Result) {
-		// Get matrix for the current rotate value.
-		val matrix = getMappingMatrix()
-		val resultPoints = result.resultPoints
-		if (matrix == null ||
-			resultPoints == null ||
-			resultPoints.isEmpty()
-		) {
-			return
-		}
 		cameraView.post {
 			detectorView.update(
-				matrix.map(
-					resultPoints,
+				matrix.mapPosition(
+					result.position,
 					detectorView.coordinates
 				)
 			)
-			vibrator.vibrate()
+			scanFeedback()
 			val returnUri = returnUrlTemplate?.let {
 				try {
 					completeUrl(it, result)
@@ -731,16 +688,13 @@ class CameraActivity : AppCompatActivity() {
 					setResult(Activity.RESULT_OK, getReturnIntent(result))
 					finish()
 				}
+
 				returnUri != null -> execShareIntent(
 					Intent(Intent.ACTION_VIEW, returnUri)
 				)
+
 				else -> {
-					showResult(
-						this@CameraActivity,
-						result,
-						vibrator,
-						bulkMode
-					)
+					showResult(result, bulkMode)
 					// If this app was invoked via a deep link but without
 					// a return URI, we probably don't want to return to
 					// the camera screen after scanning, but to the caller.
@@ -750,7 +704,13 @@ class CameraActivity : AppCompatActivity() {
 				}
 			}
 			if (bulkMode) {
-				ignoreNext = result.text
+				when (prefs.ignoreDuplicates()) {
+					Preferences.Companion.IgnoreDuplicates.Consecutive,
+					Preferences.Companion.IgnoreDuplicates.Any ->
+						ignoreNext = result.text
+
+					else -> Unit
+				}
 				if (prefs.showToastInBulkMode) {
 					toast(result.text)
 				}
@@ -761,30 +721,29 @@ class CameraActivity : AppCompatActivity() {
 		}
 	}
 
-	private fun getMappingMatrix() = if (rotate) {
-		rotatedMappingMatrix
-	} else {
-		nativeMappingMatrix
-	}
-
 	companion object {
+		const val CAMERA_CROP_HANDLE = "camera_crop_handle"
+
 		private const val PICK_FILE_RESULT_CODE = 1
 		private const val ZOOM_MAX = "zoom_max"
 		private const val ZOOM_LEVEL = "zoom_level"
 		private const val FRONT_FACING = "front_facing"
 		private const val BULK_MODE = "bulk_mode"
 		private const val RESTRICT_FORMAT = "restrict_format"
+		private const val SEARCH_TERM = "search_term"
 	}
 }
 
-fun showResult(
-	activity: Activity,
+fun Set<String>.toFormatSet(): Set<BarcodeFormat> = map {
+	BarcodeFormat.valueOf(it)
+}.toSet()
+
+fun Activity.showResult(
 	result: Result,
-	vibrator: Vibrator,
 	bulkMode: Boolean = false,
 ) {
 	if (prefs.copyImmediately) {
-		activity.copyToClipboard(result.text)
+		copyToClipboard(result.text)
 	}
 	val scan = result.toScan()
 	if (prefs.useHistory) {
@@ -792,8 +751,8 @@ fun showResult(
 	}
 	if (prefs.sendScanActive && prefs.sendScanUrl.isNotEmpty()) {
 		if (prefs.sendScanType == "4") {
-			activity.openUrl(
-				prefs.sendScanUrl + scan.content.urlEncode()
+			openUrl(
+				prefs.sendScanUrl + scan.text.urlEncode()
 			)
 			return
 		}
@@ -802,64 +761,54 @@ fun showResult(
 			prefs.sendScanType
 		) { code, body ->
 			if (code == null || code < 200 || code > 299) {
-				vibrator.error()
-				if (!activity.isSilent()) {
-					beepBeepBeep()
-				}
+				errorFeedback()
 			}
-			if (body != null && body.isNotEmpty()) {
-				activity.toast(body)
+			if (!body.isNullOrEmpty()) {
+				toast(body)
 			} else if (code == null || code > 299) {
-				activity.toast(R.string.background_request_failed)
+				toast(R.string.background_request_failed)
 			}
 		}
 	}
+	if (prefs.sendScanBluetooth &&
+		prefs.sendScanBluetoothHost.isNotEmpty() &&
+		hasBluetoothPermission()
+	) {
+		scan.sendBluetoothAsync(
+			prefs.sendScanBluetoothHost
+		) { connected, sent ->
+			toast(
+				when {
+					!connected -> {
+						errorFeedback()
+						R.string.bluetooth_connect_fail
+					}
+
+					!sent -> {
+						errorFeedback()
+						R.string.bluetooth_send_fail
+					}
+
+					else -> R.string.bluetooth_send_success
+				}
+			)
+		}
+	}
 	if (!bulkMode) {
-		activity.startActivity(
-			MainActivity.getDecodeIntent(activity, scan)
+		startActivity(
+			MainActivity.getDecodeIntent(this, scan)
 		)
 	}
 }
 
-fun getReturnIntent(result: Result): Intent {
-	val intent = Intent()
-	intent.putExtra("SCAN_RESULT", result.text)
-	intent.putExtra(
-		"SCAN_RESULT_FORMAT",
-		result.barcodeFormat.toString()
-	)
-	if (result.rawBytes?.isNotEmpty() == true) {
-		intent.putExtra("SCAN_RESULT_BYTES", result.rawBytes)
+private fun getReturnIntent(result: Result) = Intent().apply {
+	putExtra("SCAN_RESULT", result.text)
+	putExtra("SCAN_RESULT_FORMAT", result.format.toString())
+	putExtra("SCAN_RESULT_ORIENTATION", result.orientation)
+	putExtra("SCAN_RESULT_ERROR_CORRECTION_LEVEL", result.ecLevel)
+	if (result.rawBytes.isNotEmpty()) {
+		putExtra("SCAN_RESULT_BYTES", result.rawBytes)
 	}
-	result.resultMetadata?.let { metadata ->
-		metadata[ResultMetadataType.ORIENTATION]?.let {
-			intent.putExtra(
-				"SCAN_RESULT_ORIENTATION",
-				it.toString()
-			)
-		}
-		metadata[ResultMetadataType.ERROR_CORRECTION_LEVEL]?.let {
-			intent.putExtra(
-				"SCAN_RESULT_ERROR_CORRECTION_LEVEL",
-				it.toString()
-			)
-		}
-		metadata[ResultMetadataType.UPC_EAN_EXTENSION]?.let {
-			intent.putExtra(
-				"SCAN_RESULT_UPC_EAN_EXTENSION",
-				it.toString()
-			)
-		}
-		metadata[ResultMetadataType.BYTE_SEGMENTS]?.let {
-			var i = 0
-			@Suppress("UNCHECKED_CAST")
-			for (seg in it as Iterable<ByteArray>) {
-				intent.putExtra("SCAN_RESULT_BYTE_SEGMENTS_$i", seg)
-				++i
-			}
-		}
-	}
-	return intent
 }
 
 private fun String.isReturnUrl() = listOf(
@@ -871,33 +820,8 @@ private fun String.isReturnUrl() = listOf(
 private fun completeUrl(urlTemplate: String, result: Result) = Uri.parse(
 	urlTemplate
 		.replace("{RESULT}", result.text.urlEncode())
-		.replace("{RESULT_BYTES}", result.rawBytes?.toHexString() ?: "")
-		.replace(
-			"{FORMAT}", result.barcodeFormat.toString().urlEncode()
-		)
-		.replace(
-			"{META}", result.resultMetadata?.toString()?.urlEncode() ?: ""
-		)
+		.replace("{RESULT_BYTES}", result.rawBytes.toHexString())
+		.replace("{FORMAT}", result.format.name.urlEncode())
 		// And support {CODE} from the old ZXing app, too.
 		.replace("{CODE}", result.text.urlEncode())
 )
-
-private fun Context.isSilent(): Boolean {
-	val am = getSystemService(Context.AUDIO_SERVICE) as AudioManager
-	return when (am.ringerMode) {
-		AudioManager.RINGER_MODE_SILENT,
-		AudioManager.RINGER_MODE_VIBRATE -> true
-		else -> false
-	}
-}
-
-private fun beepBeepBeep() {
-	ToneGenerator(AudioManager.STREAM_ALARM, 100).startTone(
-		ToneGenerator.TONE_CDMA_CONFIRM,
-		1000
-	)
-}
-
-private fun isPortrait(
-	orientation: Int
-) = orientation == 90 || orientation == 270

app/src/main/kotlin/de/markusfisch/android/binaryeye/activity/MainActivity.kt

@@ -7,17 +7,20 @@ import android.os.Build
 import android.os.Bundle
 import android.support.v4.app.Fragment
 import android.support.v7.app.AppCompatActivity
-import android.support.v7.widget.Toolbar
 import de.markusfisch.android.binaryeye.R
-import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.app.PERMISSION_LOCATION
+import de.markusfisch.android.binaryeye.app.PERMISSION_WRITE
+import de.markusfisch.android.binaryeye.app.applyLocale
+import de.markusfisch.android.binaryeye.app.permissionGrantedCallback
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.app.setFragment
 import de.markusfisch.android.binaryeye.database.Scan
 import de.markusfisch.android.binaryeye.fragment.DecodeFragment
 import de.markusfisch.android.binaryeye.fragment.EncodeFragment
 import de.markusfisch.android.binaryeye.fragment.HistoryFragment
 import de.markusfisch.android.binaryeye.fragment.PreferencesFragment
 import de.markusfisch.android.binaryeye.view.colorSystemAndToolBars
-import de.markusfisch.android.binaryeye.view.initSystemBars
-import de.markusfisch.android.binaryeye.view.recordToolbarHeight
+import de.markusfisch.android.binaryeye.view.initBars
 
 class MainActivity : AppCompatActivity() {
 	override fun onRequestPermissionsResult(
@@ -54,10 +57,7 @@ class MainActivity : AppCompatActivity() {
 		super.onCreate(state)
 		setContentView(R.layout.activity_main)
 
-		initSystemBars(this)
-		val toolbar = findViewById(R.id.toolbar) as Toolbar
-		recordToolbarHeight(toolbar)
-		setSupportActionBar(toolbar)
+		initBars()
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)
 
 		supportFragmentManager.addOnBackStackChangedListener {
@@ -81,11 +81,13 @@ class MainActivity : AppCompatActivity() {
 				intent.hasExtra(PREFERENCES) -> PreferencesFragment()
 				intent.hasExtra(HISTORY) -> HistoryFragment()
 				intent.hasExtra(ENCODE) -> EncodeFragment.newInstance(
-					intent.getStringExtra(ENCODE)!!
-				)
-				intent.hasExtra(DECODED) -> DecodeFragment.newInstance(
-					intent.getParcelableExtra(DECODED)!!
+					intent.getStringExtra(ENCODE)
 				)
+
+				intent.hasExtra(DECODED) -> intent.getScanExtra(DECODED)?.let {
+					DecodeFragment.newInstance(it)
+				} ?: DecodeFragment()
+
 				else -> PreferencesFragment()
 			}
 		}
@@ -130,3 +132,12 @@ class MainActivity : AppCompatActivity() {
 		}
 	}
 }
+
+private fun Intent.getScanExtra(name: String): Scan? = if (
+	Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU
+) {
+	@Suppress("DEPRECATION")
+	getParcelableExtra(name)
+} else {
+	getParcelableExtra(name, Scan::class.java)
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/activity/PickActivity.kt

@@ -3,46 +3,61 @@ package de.markusfisch.android.binaryeye.activity
 import android.content.Context
 import android.content.Intent
 import android.graphics.Bitmap
+import android.graphics.Matrix
 import android.graphics.Rect
 import android.graphics.RectF
 import android.net.Uri
+import android.os.Build
 import android.os.Bundle
-import android.os.Parcelable
-import android.os.Vibrator
 import android.support.v7.app.AppCompatActivity
-import android.support.v7.widget.Toolbar
-import android.support.v8.renderscript.RenderScript
 import android.view.Menu
 import android.view.MenuItem
-import com.google.zxing.Result
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.app.applyLocale
 import de.markusfisch.android.binaryeye.app.prefs
 import de.markusfisch.android.binaryeye.graphics.crop
+import de.markusfisch.android.binaryeye.graphics.fixTransparency
 import de.markusfisch.android.binaryeye.graphics.loadImageUri
-import de.markusfisch.android.binaryeye.graphics.mapResultToView
-import de.markusfisch.android.binaryeye.os.getVibrator
-import de.markusfisch.android.binaryeye.os.vibrate
-import de.markusfisch.android.binaryeye.rs.fixTransparency
+import de.markusfisch.android.binaryeye.graphics.mapPosition
+import de.markusfisch.android.binaryeye.media.releaseToneGenerators
+import de.markusfisch.android.binaryeye.preference.Preferences
 import de.markusfisch.android.binaryeye.view.colorSystemAndToolBars
-import de.markusfisch.android.binaryeye.view.initSystemBars
-import de.markusfisch.android.binaryeye.view.recordToolbarHeight
+import de.markusfisch.android.binaryeye.view.initBars
+import de.markusfisch.android.binaryeye.view.scanFeedback
 import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
 import de.markusfisch.android.binaryeye.widget.CropImageView
 import de.markusfisch.android.binaryeye.widget.DetectorView
 import de.markusfisch.android.binaryeye.widget.toast
-import de.markusfisch.android.binaryeye.zxing.Zxing
-import kotlinx.coroutines.*
+import de.markusfisch.android.zxingcpp.ZxingCpp
+import de.markusfisch.android.zxingcpp.ZxingCpp.Binarizer
+import de.markusfisch.android.zxingcpp.ZxingCpp.ReaderOptions
+import de.markusfisch.android.zxingcpp.ZxingCpp.Result
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
 
 class PickActivity : AppCompatActivity() {
-	private val zxing = Zxing()
+	private val matrix = Matrix()
 	private val parentJob = Job()
 	private val scope = CoroutineScope(Dispatchers.IO + parentJob)
+	private val options = ReaderOptions(
+		tryHarder = true,
+		tryRotate = true,
+		tryInvert = true,
+		tryDownscale = true,
+		returnCodabarStartEnd = true,
+		maxNumberOfSymbols = 1,
+		formats = prefs.barcodeFormats.toFormatSet()
+	)
 
-	private lateinit var rs: RenderScript
-	private lateinit var vibrator: Vibrator
 	private lateinit var cropImageView: CropImageView
 	private lateinit var detectorView: DetectorView
+	private lateinit var freeRotationItem: MenuItem
 
 	private var result: Result? = null
 
@@ -59,23 +74,13 @@ class PickActivity : AppCompatActivity() {
 		// locale.
 		setTitle(R.string.pick_code_to_scan)
 
-		zxing.updateHints(
-			true,
-			prefs.barcodeFormats
-		)
-		rs = RenderScript.create(this)
-		vibrator = getVibrator()
-
-		initSystemBars(this)
-		val toolbar = findViewById(R.id.toolbar) as Toolbar
-		recordToolbarHeight(toolbar)
-		setSupportActionBar(toolbar)
+		initBars()
 
 		supportFragmentManager.addOnBackStackChangedListener {
 			colorSystemAndToolBars(this@PickActivity)
 		}
 
-		val bitmap = fixTransparency(rs, getBitmapFromIntent())
+		val bitmap = getBitmapFromIntent()?.fixTransparency()
 		if (bitmap == null) {
 			applicationContext.toast(R.string.error_no_content)
 			finish()
@@ -84,6 +89,7 @@ class PickActivity : AppCompatActivity() {
 
 		cropImageView = findViewById(R.id.image) as CropImageView
 		cropImageView.restrictTranslation = false
+		cropImageView.freeRotation = prefs.freeRotation
 		cropImageView.setImageBitmap(bitmap)
 		cropImageView.onScan = {
 			scanWithinBounds(bitmap)
@@ -94,7 +100,7 @@ class PickActivity : AppCompatActivity() {
 			scanWithinBounds(bitmap)
 		}
 		detectorView.setPaddingFromWindowInsets()
-		detectorView.restoreCropHandlePos()
+		detectorView.restoreCropHandlePos(PICKER_CROP_HANDLE)
 
 		findViewById(R.id.scan).setOnClickListener {
 			showResult()
@@ -116,38 +122,50 @@ class PickActivity : AppCompatActivity() {
 	}
 
 	private fun scanWithinBounds(bitmap: Bitmap) {
-		val roi = Rect(detectorView.roi)
-		val rectInView = if (roi.width() < 1) {
-			cropImageView.getBoundsRect()
-		} else {
-			roi
-		}
-		val imageRect = cropImageView.mappedRect
-		val rectInImage = normalizeRoi(imageRect, rectInView)
-		val cropped = bitmap.crop(
-			rectInImage,
-			cropImageView.imageRotation
-		) ?: return
+		val viewRoi = Rect(
+			if (detectorView.roi.width() < 1) {
+				cropImageView.getBoundsRect()
+			} else {
+				detectorView.roi
+			}
+		)
+		val mappedRect = RectF(cropImageView.mappedRect)
+		val imageRotation = cropImageView.imageRotation
+		val pivotX = cropImageView.pivotX
+		val pivotY = cropImageView.pivotY
 		scope.launch {
-			result = zxing.decodePositiveNegative(cropped)
-			result?.let {
+			val cropped = bitmap.crop(
+				getNormalizedRoi(mappedRect, viewRoi),
+				imageRotation,
+				pivotX,
+				pivotY
+			) ?: return@launch
+			val croppedInView = Rect(
+				max(viewRoi.left, mappedRect.left.roundToInt()),
+				max(viewRoi.top, mappedRect.top.roundToInt()),
+				min(viewRoi.right, mappedRect.right.roundToInt()),
+				min(viewRoi.bottom, mappedRect.bottom.roundToInt())
+			)
+			matrix.apply {
+				setScale(
+					croppedInView.width().toFloat() / cropped.width,
+					croppedInView.height().toFloat() / cropped.height
+				)
+				postTranslate(
+					croppedInView.left.toFloat(),
+					croppedInView.top.toFloat()
+				)
+			}
+			cropped.decode()?.first()?.let {
 				withContext(Dispatchers.Main) {
 					if (isFinishing) {
 						return@withContext
 					}
-					vibrator.vibrate()
-					val rc = Rect()
-					imageRect.round(rc)
-					if (!rectInView.intersect(rc)) {
-						return@withContext
-					}
+					result = it
+					scanFeedback()
 					detectorView.update(
-						mapResultToView(
-							cropped.width,
-							cropped.height,
-							0,
-							rectInView,
-							it.resultPoints,
+						matrix.mapPosition(
+							it.position,
 							detectorView.coordinates
 						)
 					)
@@ -156,15 +174,38 @@ class PickActivity : AppCompatActivity() {
 		}
 	}
 
+	// By default, ZXing uses LOCAL_AVERAGE, but this does not work
+	// well with inverted barcodes on low-contrast backgrounds.
+	private fun Bitmap.decode() = ZxingCpp.readBitmap(
+		this,
+		0, 0,
+		width, height,
+		0,
+		options.apply {
+			binarizer = Binarizer.LOCAL_AVERAGE
+		}
+	) ?: ZxingCpp.readBitmap(
+		this,
+		0, 0,
+		width, height,
+		0,
+		options.apply {
+			binarizer = Binarizer.GLOBAL_HISTOGRAM
+		}
+	)
+
 	override fun onDestroy() {
 		super.onDestroy()
-		detectorView.saveCropHandlePos()
-		rs.destroy()
+		detectorView.storeCropHandlePos(PICKER_CROP_HANDLE)
 		parentJob.cancel()
+		releaseToneGenerators()
 	}
 
 	override fun onCreateOptionsMenu(menu: Menu): Boolean {
 		menuInflater.inflate(R.menu.activity_pick, menu)
+		freeRotationItem = menu.findItem(R.id.toggle_free).apply {
+			updateFreeRotationIcon()
+		}
 		return true
 	}
 
@@ -174,18 +215,34 @@ class PickActivity : AppCompatActivity() {
 				rotateClockwise()
 				true
 			}
+
+			R.id.toggle_free -> {
+				prefs.freeRotation = prefs.freeRotation xor true
+				cropImageView.freeRotation = prefs.freeRotation
+				freeRotationItem.updateFreeRotationIcon()
+				true
+			}
+
 			else -> super.onOptionsItemSelected(item)
 		}
 	}
 
+	private fun MenuItem.updateFreeRotationIcon() {
+		setIcon(
+			if (prefs.freeRotation) {
+				R.drawable.ic_action_rotation_unlocked
+			} else {
+				R.drawable.ic_action_rotation_locked
+			}
+		)
+	}
+
 	private fun rotateClockwise() {
-		cropImageView.imageRotation = cropImageView.imageRotation + 90 % 360
+		cropImageView.imageRotation = (cropImageView.imageRotation + 90) % 360
 	}
 
 	private fun loadSentImage(intent: Intent): Bitmap? {
-		val uri = intent.getParcelableExtra<Parcelable>(
-			Intent.EXTRA_STREAM
-		) as? Uri ?: return null
+		val uri = intent.getUriExtra() ?: return null
 		return contentResolver.loadImageUri(uri)
 	}
 
@@ -197,15 +254,19 @@ class PickActivity : AppCompatActivity() {
 	private fun showResult() {
 		val r = result
 		if (r != null) {
-			showResult(this, r, vibrator)
+			showResult(r)
 			finish()
 		} else {
 			applicationContext.toast(R.string.no_barcode_found)
 		}
 	}
+
+	companion object {
+		private const val PICKER_CROP_HANDLE = "picker_crop_handle"
+	}
 }
 
-private fun normalizeRoi(imageRect: RectF, roi: Rect): RectF {
+private fun getNormalizedRoi(imageRect: RectF, roi: Rect): RectF {
 	val w = imageRect.width()
 	val h = imageRect.height()
 	return RectF(
@@ -215,3 +276,12 @@ private fun normalizeRoi(imageRect: RectF, roi: Rect): RectF {
 		(roi.bottom - imageRect.top) / h
 	)
 }
+
+private fun Intent.getUriExtra(): Uri? = if (
+	Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU
+) {
+	@Suppress("DEPRECATION")
+	getParcelableExtra(Intent.EXTRA_STREAM)
+} else {
+	getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/activity/SplashActivity.kt

@@ -3,7 +3,6 @@ package de.markusfisch.android.binaryeye.activity
 import android.content.Intent
 import android.os.Bundle
 import android.support.v7.app.AppCompatActivity
-import de.markusfisch.android.binaryeye.app.setRestartCount
 
 class SplashActivity : AppCompatActivity() {
 	override fun onCreate(state: Bundle?) {
@@ -13,7 +12,6 @@ class SplashActivity : AppCompatActivity() {
 		// because that would happen after the app is fully
 		// initialized what is too late.
 
-		intent?.setRestartCount()
 		startActivity(Intent(applicationContext, CameraActivity::class.java))
 		finish()
 	}

app/src/main/kotlin/de/markusfisch/android/binaryeye/adapter/ScansAdapter.kt

@@ -2,6 +2,7 @@ package de.markusfisch.android.binaryeye.adapter
 
 import android.content.Context
 import android.database.Cursor
+import android.support.v4.content.ContextCompat
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
@@ -10,41 +11,71 @@ import android.widget.TextView
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.database.Database
 import java.text.DateFormat
+import java.text.ParseException
 import java.text.SimpleDateFormat
-import java.util.*
+import java.util.Locale
 
 class ScansAdapter(context: Context, cursor: Cursor) :
 	CursorAdapter(context, cursor, false) {
-	var selectedScanId = 0L
-	var selectedScanPosition = -1
-
 	private val idIndex = cursor.getColumnIndex(Database.SCANS_ID)
 	private val timeIndex = cursor.getColumnIndex(Database.SCANS_DATETIME)
 	private val nameIndex = cursor.getColumnIndex(Database.SCANS_NAME)
 	private val contentIndex = cursor.getColumnIndex(Database.SCANS_CONTENT)
 	private val formatIndex = cursor.getColumnIndex(Database.SCANS_FORMAT)
+	private val selections = mutableMapOf<Long, Int>()
+	private val selectedColor = ContextCompat.getColor(
+		context, R.color.selected_row
+	)
 
-	fun select(id: Long, position: Int) {
-		selectedScanId = id
-		selectedScanPosition = position
+	fun select(view: View, id: Long, position: Int) {
+		view.select(
+			if (selections[id] == null) {
+				selections[id] = position
+				true
+			} else {
+				selections.remove(id)
+				false
+			}
+		)
 	}
 
 	fun clearSelection() {
-		selectedScanId = 0L
-		selectedScanPosition = -1
+		selections.clear()
 	}
 
-	fun getSelectedContent() = if (selectedScanPosition < 0) {
-		null
-	} else {
-		val cursor = getItem(selectedScanPosition)
-		if (cursor is Cursor) {
-			cursor.getString(contentIndex)
-		} else {
-			null
+	fun forSelection(callback: (Long, Int) -> Unit) {
+		selections.forEach {
+			callback.invoke(it.key, it.value)
 		}
 	}
 
+	fun getSelectedIds(): List<Long> = mutableListOf<Long>().apply {
+		forSelection { id, _ ->
+			add(id)
+		}
+	}
+
+	fun getSelectedContent(separator: String): String {
+		val sb = StringBuilder()
+		forSelection { _, position ->
+			getContent(position)?.let {
+				if (sb.isNotEmpty()) {
+					sb.append(separator)
+				}
+				sb.append(it)
+			}
+		}
+		return sb.toString()
+	}
+
+	fun getName(
+		position: Int
+	) = (getItem(position) as Cursor?)?.getString(nameIndex)
+
+	fun getContent(
+		position: Int
+	) = (getItem(position) as Cursor?)?.getString(contentIndex)
+
 	override fun newView(
 		context: Context,
 		cursor: Cursor,
@@ -68,9 +99,11 @@ class ScansAdapter(context: Context, cursor: Cursor) :
 					icon = R.drawable.ic_label
 					name
 				}
-				content?.isEmpty() == true -> context.getString(
+
+				content.isNullOrEmpty() -> context.getString(
 					R.string.binary_data
 				)
+
 				else -> content
 			}
 			contentView.setCompoundDrawablesWithIntrinsicBounds(
@@ -78,13 +111,17 @@ class ScansAdapter(context: Context, cursor: Cursor) :
 			)
 			formatView.text = prettifyFormatName(cursor.getString(formatIndex))
 		}
-		// view.isSelected needs to be put on the queue to work.
-		val selected = cursor.getLong(idIndex) == selectedScanId
+		val selected = selections[cursor.getLong(idIndex)] != null
 		view.post {
-			view.isSelected = selected
+			// Needs to be put on the queue to work.
+			view.select(selected)
 		}
 	}
 
+	private fun View.select(selected: Boolean) {
+		setBackgroundColor(if (selected) selectedColor else 0)
+	}
+
 	private fun getViewHolder(
 		view: View
 	): ViewHolder = view.tag as ViewHolder? ?: ViewHolder(
@@ -105,11 +142,15 @@ class ScansAdapter(context: Context, cursor: Cursor) :
 fun prettifyFormatName(format: String) = format.replace("_", " ")
 
 private fun formatDateTime(rfc: String): String {
-	SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US).parse(rfc)?.let {
-		return DateFormat.getDateTimeInstance(
-			DateFormat.LONG,
-			DateFormat.SHORT
-		).format(it)
+	try {
+		SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.US).parse(rfc)?.let {
+			return DateFormat.getDateTimeInstance(
+				DateFormat.LONG,
+				DateFormat.SHORT
+			).format(it)
+		}
+	} catch (e: ParseException) {
+		// Ignore and fall through.
 	}
 	return rfc
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/AlertDialog.kt

@@ -1,7 +1,7 @@
 package de.markusfisch.android.binaryeye.app
 
-import android.content.Context
 import android.app.AlertDialog
+import android.content.Context
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import kotlin.coroutines.resume

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/BinaryEyeApp.kt

@@ -1,21 +1,16 @@
 package de.markusfisch.android.binaryeye.app
 
-import android.support.multidex.MultiDexApplication;
-import android.support.v8.renderscript.RenderScript
+import android.app.Application
 import de.markusfisch.android.binaryeye.database.Database
 import de.markusfisch.android.binaryeye.preference.Preferences
 
 val db = Database()
 val prefs = Preferences()
 
-class BinaryEyeApp : MultiDexApplication() {
+class BinaryEyeApp : Application() {
 	override fun onCreate() {
 		super.onCreate()
 		db.open(this)
 		prefs.init(this)
-
-		if (prefs.forceCompat) {
-			RenderScript.forceCompat()
-		}
 	}
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/Data.kt

@@ -1,30 +0,0 @@
-package de.markusfisch.android.binaryeye.app
-
-import android.net.Uri
-import android.os.Build
-import java.io.UnsupportedEncodingException
-import java.net.URLEncoder
-
-private val nonPrintable = "[\\x00-\\x08\\x0e-\\x1f]".toRegex()
-fun String.hasNonPrintableCharacters() = nonPrintable.containsMatchIn(this)
-
-private val nonAlNum = "[^a-zA-Z0-9]".toRegex()
-private val multipleDots = "[…]+".toRegex()
-fun String.foldNonAlNum() = replace(nonAlNum, "…")
-	.replace(multipleDots, "…")
-
-fun String.urlEncode(): String = try {
-	URLEncoder.encode(this, "UTF-8")
-} catch (e: UnsupportedEncodingException) {
-	this
-}
-
-fun String.parseAndNormalizeUri(): Uri = Uri.parse(this).let {
-	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-		it.normalizeScheme()
-	} else {
-		it
-	}
-}
-
-fun ByteArray.toHexString() = joinToString("") { "%02X".format(it) }

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/Links.kt

@@ -1,29 +0,0 @@
-package de.markusfisch.android.binaryeye.app
-
-import java.util.regex.Pattern
-
-private val urlPattern: Pattern = Pattern.compile(
-	"(?:^|[\\W])((ht|f)tp(s?):\\/\\/|www\\.)" +
-			"(([\\w\\-]+\\.){1,}?([\\w\\-.~]+\\/?)*" +
-			"[\\p{Alnum}.,%_=?&#\\-+()\\[\\]\\*$~@!:/{};']*)",
-	Pattern.CASE_INSENSITIVE or Pattern.MULTILINE or Pattern.DOTALL
-)
-
-fun getLinks(text: String): List<String> {
-	val matcher = urlPattern.matcher(text)
-	val urls = mutableListOf<String>()
-
-	while (matcher.find()) {
-		val matchStart = matcher.start(1)
-		val matchEnd = matcher.end()
-
-		var url = text.substring(matchStart, matchEnd)
-		if (!url.startsWith("http://") && !url.startsWith("https://")) {
-			url = "https://$url"
-		}
-
-		urls.add(url)
-	}
-
-	return urls
-}

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/Locale.kt

@@ -2,7 +2,7 @@ package de.markusfisch.android.binaryeye.app
 
 import android.content.Context
 import android.os.Build
-import java.util.*
+import java.util.Locale
 
 fun Context.applyLocale(localeName: String) {
 	if (localeName.isEmpty()) {

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/Permissions.kt

@@ -3,15 +3,16 @@ package de.markusfisch.android.binaryeye.app
 import android.Manifest
 import android.app.Activity
 import android.content.pm.PackageManager
+import android.os.Build
 import android.support.v4.app.ActivityCompat
 import android.support.v4.content.ContextCompat
 
 var permissionGrantedCallback: (() -> Any)? = null
 
 const val PERMISSION_CAMERA = 1
-fun Activity.hasCameraPermission() = hasPermission(
+fun Activity.hasCameraPermission(request: Boolean = true) = hasPermission(
 	Manifest.permission.CAMERA,
-	PERMISSION_CAMERA
+	if (request) PERMISSION_CAMERA else 0
 )
 
 const val PERMISSION_WRITE = 2
@@ -32,6 +33,18 @@ fun Activity.hasLocationPermission(callback: () -> Any): Boolean {
 	)
 }
 
+const val PERMISSION_BLUETOOTH = 4
+fun Activity.hasBluetoothPermission() = if (
+	Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+) {
+	hasPermission(
+		Manifest.permission.BLUETOOTH_CONNECT,
+		PERMISSION_BLUETOOTH
+	)
+} else {
+	false
+}
+
 private fun Activity.hasPermission(
 	permission: String,
 	requestCode: Int
@@ -40,11 +53,13 @@ private fun Activity.hasPermission(
 		permission
 	) != PackageManager.PERMISSION_GRANTED
 ) {
-	ActivityCompat.requestPermissions(
-		this,
-		arrayOf(permission),
-		requestCode
-	)
+	if (requestCode > 0) {
+		ActivityCompat.requestPermissions(
+			this,
+			arrayOf(permission),
+			requestCode
+		)
+	}
 	false
 } else {
 	true

app/src/main/kotlin/de/markusfisch/android/binaryeye/app/Process.kt

@@ -1,24 +0,0 @@
-package de.markusfisch.android.binaryeye.app
-
-import android.app.Activity
-import android.content.Intent
-import de.markusfisch.android.binaryeye.activity.SplashActivity
-
-private const val RESTART_COUNT = "restart_count"
-
-private var restartCount = 0
-
-fun Intent.setRestartCount() {
-	restartCount = getIntExtra(RESTART_COUNT, restartCount)
-}
-
-fun Activity.restartApp() {
-	if (restartCount < 3) {
-		startActivity(Intent(this, SplashActivity::class.java).apply {
-			addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-			putExtra(RESTART_COUNT, ++restartCount)
-		})
-		finish()
-	}
-	Runtime.getRuntime().exit(0)
-}

app/src/main/kotlin/de/markusfisch/android/binaryeye/bluetooth/BluetoothSender.kt

@@ -0,0 +1,123 @@
+package de.markusfisch.android.binaryeye.bluetooth
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothSocket
+import android.support.v7.preference.ListPreference
+import de.markusfisch.android.binaryeye.database.Scan
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.io.IOException
+import java.io.OutputStreamWriter
+import java.util.UUID
+
+fun Scan.sendBluetoothAsync(
+	host: String,
+	callback: (Boolean, Boolean) -> Unit
+) {
+	CoroutineScope(Dispatchers.IO).launch(Dispatchers.IO) {
+		val connected = if (isConnected) {
+			true
+		} else {
+			connect(host, true)
+		}
+		val sent = if (connected) {
+			send(text, host, true)
+		} else {
+			false
+		}
+		withContext(Dispatchers.Main) {
+			callback(connected, sent)
+		}
+	}
+}
+
+fun setBluetoothHosts(listPref: ListPreference) {
+	val devices = try {
+		BluetoothAdapter.getDefaultAdapter().bondedDevices
+	} catch (e: SecurityException) {
+		// Do nothing, either the user has denied Bluetooth access
+		// or the permission was removed by the system. We're catching
+		// the exception to keep the app from crashing.
+		null
+	} ?: return
+	listPref.entries = devices.map {
+		it.name
+	}.toTypedArray()
+	listPref.entryValues = devices.map {
+		it.address
+	}.toTypedArray()
+	listPref.callChangeListener(listPref.value)
+}
+
+private var socket: BluetoothSocket? = null
+private var writer: OutputStreamWriter? = null
+
+private val blue = BluetoothAdapter.getDefaultAdapter()
+private val uuid = UUID.fromString(
+	"8a8478c9-2ca8-404b-a0de-101f34ab71ae"
+)
+
+private var isConnected = false
+
+private fun connect(deviceName: String, onceMore: Boolean): Boolean = try {
+	val device = findByName(deviceName) ?: throw RuntimeException(
+		"Bluetooth device not found"
+	)
+	socket = device.createRfcommSocketToServiceRecord(uuid)
+	socket?.connect()
+	writer = socket?.outputStream?.writer()
+	isConnected = true
+	true
+} catch (e: Exception) {
+	if (onceMore)
+		connect(deviceName, false)
+	else
+		close()
+	false
+}
+
+private fun send(message: String, host: String, onceMore: Boolean): Boolean = try {
+	writer?.apply {
+		write(message)
+		write("\n")
+		flush()
+	}
+	true
+} catch (e: Exception) {
+	close()
+
+	if (connect(host, false))
+		send(message, host, false)
+	else
+		false
+}
+
+private fun close() {
+	try {
+		writer?.close()
+	} catch (e: IOException) {
+		// Catch exception if writer wasn't initialized.
+	}
+	try {
+		socket?.close()
+	} catch (e: IOException) {
+		// Nothing we can do about this but keep
+		// the app from crashing.
+	}
+	writer = null
+	socket = null
+	isConnected = false
+}
+
+private fun findByName(findableName: String): BluetoothDevice? {
+	val deviceList = blue.bondedDevices
+	for (device in deviceList) {
+		if (device.address == findableName) {
+			return device
+		}
+	}
+	return null
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/content/Barcode.kt

@@ -0,0 +1,179 @@
+package de.markusfisch.android.binaryeye.content
+
+import android.graphics.Bitmap
+import de.markusfisch.android.binaryeye.database.Scan
+import de.markusfisch.android.binaryeye.graphics.COLOR_BLACK
+import de.markusfisch.android.binaryeye.graphics.COLOR_WHITE
+import de.markusfisch.android.zxingcpp.ZxingCpp
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
+import de.markusfisch.android.zxingcpp.ZxingCpp.BitMatrix
+import de.markusfisch.android.zxingcpp.ZxingCpp.toBitmap
+import de.markusfisch.android.zxingcpp.ZxingCpp.toSvg
+import de.markusfisch.android.zxingcpp.ZxingCpp.toText
+import java.util.Arrays
+
+enum class BarcodeColors {
+	BLACK_ON_WHITE,
+	WHITE_ON_BLACK,
+	BLACK_ON_TRANSPARENT,
+	WHITE_ON_TRANSPARENT;
+
+	fun foregroundColor(): Int = when (this) {
+		BLACK_ON_WHITE,
+		BLACK_ON_TRANSPARENT -> COLOR_BLACK
+
+		WHITE_ON_BLACK,
+		WHITE_ON_TRANSPARENT -> COLOR_WHITE
+	}
+
+	fun backgroundColor(): Int = when (this) {
+		BLACK_ON_WHITE -> COLOR_WHITE
+		WHITE_ON_BLACK -> COLOR_BLACK
+		BLACK_ON_TRANSPARENT,
+		WHITE_ON_TRANSPARENT -> 0
+	}
+}
+
+fun Scan.toBarcode(): Barcode<*> {
+	val content = text.ifEmpty {
+		raw
+	}
+	return if (symbol != null) {
+		BitMatrixBarcode(
+			symbol,
+			content,
+			format
+		)
+	} else {
+		ContentBarcode(
+			content,
+			format,
+			errorCorrectionLevel.toErrorCorrectionInt()
+		)
+	}
+}
+
+fun String?.toErrorCorrectionInt() = when (this) {
+	"L" -> 0
+	"M" -> 4
+	"Q" -> 6
+	"H" -> 8
+	else -> -1
+}
+
+abstract class Barcode<T>(
+	val content: T,
+	val format: BarcodeFormat,
+	val colors: BarcodeColors
+) {
+	private var _bitmap: Bitmap? = null
+	fun bitmap(): Bitmap {
+		val b = _bitmap ?: bitmap(512)
+		_bitmap = b
+		return b
+	}
+
+	fun bitmap(size: Int): Bitmap {
+		return toBitmap(size)
+	}
+
+	protected abstract fun toBitmap(size: Int): Bitmap
+
+	private var _svg: String? = null
+	fun svg(): String {
+		val s = _svg ?: toSvg()
+		_svg = s
+		return s
+	}
+
+	protected abstract fun toSvg(): String
+
+	private var _text: String? = null
+	fun text(): String {
+		val t = _text ?: toText()
+		_text = t
+		return t
+	}
+
+	protected abstract fun toText(): String
+}
+
+class ContentBarcode<T>(
+	content: T,
+	format: BarcodeFormat,
+	val ecLevel: Int = -1,
+	val margin: Int = -1,
+	colors: BarcodeColors = BarcodeColors.BLACK_ON_WHITE
+) : Barcode<T>(content, format, colors) {
+	override fun toBitmap(size: Int) = ZxingCpp.encodeAsBitmap(
+		content, format, size, size, margin, ecLevel,
+		setColor = colors.foregroundColor(),
+		unsetColor = colors.backgroundColor()
+	)
+
+	override fun toSvg() = ZxingCpp.encodeAsSvg(
+		content, format, margin, ecLevel
+	)
+
+	override fun toText() = ZxingCpp.encodeAsText(
+		content, format, margin, ecLevel,
+		inverted = colors == BarcodeColors.BLACK_ON_WHITE
+	)
+}
+
+class BitMatrixBarcode<T>(
+	val bitMatrix: BitMatrix,
+	content: T,
+	format: BarcodeFormat,
+	colors: BarcodeColors = BarcodeColors.BLACK_ON_WHITE
+) : Barcode<T>(content, format, colors) {
+	override fun toBitmap(size: Int) = bitMatrix.inflate(size).toBitmap(
+		setColor = colors.foregroundColor(),
+		unsetColor = colors.backgroundColor()
+	)
+
+	override fun toSvg() = bitMatrix.inflate().toSvg()
+
+	override fun toText() = bitMatrix.inflate().toText(
+		inverted = colors == BarcodeColors.BLACK_ON_WHITE
+	)
+}
+
+private fun BitMatrix.inflate(
+	size: Int = 0,
+	quietZone: Boolean = true
+): BitMatrix {
+	val extraModules = if (quietZone) 2 else 0
+	val codeWidth = width + extraModules
+	val codeHeight = height + extraModules
+	var scale = size / codeWidth
+	if (scale < 1) {
+		if (size > 0 && !quietZone) {
+			return this
+		}
+		scale = 1
+	}
+	val outWidth = codeWidth * scale
+	val outHeight = codeHeight * scale
+	val scaled = BitMatrix(
+		outWidth,
+		outHeight,
+		ByteArray(outWidth * outHeight)
+	)
+	Arrays.fill(scaled.data, 1)
+	val padding = extraModules / 2
+	val left = padding * scale
+	val top = padding * scale
+	val right = outWidth - left
+	val bottom = outHeight - top
+	for (y in top until bottom) {
+		var dst = y * outWidth + left
+		val offset = (y - top) / scale * width
+		for (x in left until right) {
+			scaled.data[dst++] = data[
+				offset + (x - left) / scale
+			]
+		}
+	}
+	return scaled
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/content/Clipboard.kt

@@ -1,17 +1,37 @@
 package de.markusfisch.android.binaryeye.content
 
 import android.content.ClipData
+import android.content.ClipDescription
 import android.content.Context
 import android.os.Build
+import android.os.PersistableBundle
 
-fun Context.copyToClipboard(text: String) {
+fun Context.copyToClipboard(text: String, isSensitive: Boolean = false) {
 	val service = getSystemService(Context.CLIPBOARD_SERVICE)
 	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
 		@Suppress("DEPRECATION")
 		(service as android.text.ClipboardManager).text = text
 	} else {
 		(service as android.content.ClipboardManager).setPrimaryClip(
-			ClipData.newPlainText("plain text", text)
+			ClipData.newPlainText("plain text", text).apply {
+				setSensitive(isSensitive)
+			}
 		)
 	}
-}
+}
+
+private fun ClipData.setSensitive(isSensitive: Boolean) {
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+		description.extras = PersistableBundle().apply {
+			putBoolean(EXTRA_IS_SENSITIVE, isSensitive)
+		}
+	}
+}
+
+private val EXTRA_IS_SENSITIVE = if (
+	Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+) {
+	ClipDescription.EXTRA_IS_SENSITIVE
+} else {
+	"android.content.extra.IS_SENSITIVE"
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/content/Hex.kt

@@ -0,0 +1,3 @@
+package de.markusfisch.android.binaryeye.content
+
+fun ByteArray.toHexString() = joinToString("") { "%02X".format(it) }

app/src/main/kotlin/de/markusfisch/android/binaryeye/content/Share.kt

@@ -8,9 +8,10 @@ import android.os.Build
 import android.support.v4.content.FileProvider
 import de.markusfisch.android.binaryeye.BuildConfig
 import de.markusfisch.android.binaryeye.R
-import de.markusfisch.android.binaryeye.app.parseAndNormalizeUri
 import de.markusfisch.android.binaryeye.widget.toast
 import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
 
 fun Context.execShareIntent(intent: Intent): Boolean = if (
 	!startIntent(intent)
@@ -36,11 +37,22 @@ fun Context.startIntent(intent: Intent): Boolean = try {
 	false
 }
 
-fun Context.openUrl(url: String): Boolean = openUri(url.parseAndNormalizeUri())
+fun Context.openUrl(url: String, silent: Boolean = false): Boolean {
+	val intent = Intent(Intent.ACTION_VIEW, url.parseAndNormalizeUri())
+	return if (silent) {
+		startIntent(intent)
+	} else {
+		execShareIntent(intent)
+	}
+}
 
-fun Context.openUri(uri: Uri): Boolean = execShareIntent(
-	Intent(Intent.ACTION_VIEW, uri)
-)
+fun String.parseAndNormalizeUri(): Uri = Uri.parse(this).let {
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
+		it.normalizeScheme()
+	} else {
+		it
+	}
+}
 
 fun Context.shareText(text: String, mimeType: String = "text/plain") {
 	execShareIntent(Intent(Intent.ACTION_SEND).apply {
@@ -49,6 +61,44 @@ fun Context.shareText(text: String, mimeType: String = "text/plain") {
 	})
 }
 
+private var lastShareFile: File? = null
+fun wipeLastShareFile() {
+	lastShareFile?.let {
+		it.delete()
+		lastShareFile = null
+	}
+}
+
+fun <T> Context.shareAsFile(content: T, fileName: String) {
+	val (bytes, mimeType) = when (content) {
+		is ByteArray -> Pair(
+			content,
+			"text/plain"
+		)
+
+		is String -> Pair(
+			content.toByteArray(),
+			"application/octet-stream"
+		)
+
+		else -> throw IllegalArgumentException(
+			"Unsupported content text for shareAsFile()"
+		)
+	}
+	wipeLastShareFile()
+	val file = File(externalCacheDir, fileName)
+	try {
+		FileOutputStream(file).use {
+			it.write(bytes)
+		}
+	} catch (e: IOException) {
+		toast(R.string.error_saving_file)
+		return
+	}
+	lastShareFile = file
+	shareFile(file, mimeType)
+}
+
 fun Context.shareFile(file: File, mimeType: String) {
 	getUriForFile(file)?.let {
 		shareUri(it, mimeType)

app/src/main/kotlin/de/markusfisch/android/binaryeye/database/CsvExport.kt

@@ -2,7 +2,7 @@ package de.markusfisch.android.binaryeye.database
 
 import android.content.Context
 import android.database.Cursor
-import de.markusfisch.android.binaryeye.app.toHexString
+import de.markusfisch.android.binaryeye.content.toHexString
 import de.markusfisch.android.binaryeye.io.writeExternalFile
 import java.io.ByteArrayOutputStream
 import java.io.OutputStream
@@ -32,15 +32,17 @@ private fun exportCsv(
 	val columns = arrayOf(
 		Database.SCANS_DATETIME,
 		Database.SCANS_FORMAT,
+		Database.SCANS_NAME,
 		Database.SCANS_CONTENT,
 		Database.SCANS_ERROR_CORRECTION_LEVEL,
-		Database.SCANS_ISSUE_NUMBER,
-		Database.SCANS_ORIENTATION,
-		Database.SCANS_OTHER_META_DATA,
-		Database.SCANS_PDF417_EXTRA_METADATA,
-		Database.SCANS_POSSIBLE_COUNTRY,
-		Database.SCANS_SUGGESTED_PRICE,
-		Database.SCANS_UPC_EAN_EXTENSION
+		Database.SCANS_VERSION,
+		Database.SCANS_SEQUENCE_SIZE,
+		Database.SCANS_SEQUENCE_INDEX,
+		Database.SCANS_SEQUENCE_ID,
+		Database.SCANS_GTIN_COUNTRY,
+		Database.SCANS_GTIN_ADD_ON,
+		Database.SCANS_GTIN_PRICE,
+		Database.SCANS_GTIN_ISSUE_NUMBER
 	)
 	val indices = columns.map {
 		cursor.getColumnIndex(it)

app/src/main/kotlin/de/markusfisch/android/binaryeye/database/Cursor.kt

@@ -1,6 +1,26 @@
 package de.markusfisch.android.binaryeye.database
 
 import android.database.Cursor
+import de.markusfisch.android.zxingcpp.ZxingCpp
+
+// Overwrite Kotlin's ".use" function for Cursor because Cursor cannot
+// be cast to Closeable below API level 16. This should be removed when
+// the minSDK is increased to at least JELLY_BEAN (16).
+inline fun <R> Cursor.use(block: (Cursor) -> R): R = try {
+	block.invoke(this)
+} finally {
+	close()
+}
+
+fun Cursor.getInt(name: String): Int {
+	val idx = getColumnIndex(name)
+	return if (idx < 0) 0 else getInt(idx)
+}
+
+fun Cursor.getLong(name: String): Long {
+	val idx = getColumnIndex(name)
+	return if (idx < 0) 0L else getLong(idx)
+}
 
 fun Cursor.getString(name: String): String {
 	val idx = getColumnIndex(name)
@@ -12,7 +32,17 @@ fun Cursor.getBlob(name: String): ByteArray? {
 	return if (idx < 0) null else getBlob(idx)
 }
 
-fun Cursor.getLong(name: String): Long {
-	val idx = getColumnIndex(name)
-	return if (idx < 0) 0L else getLong(idx)
+fun Cursor.getBitMatrix(
+	widthName: String,
+	heightName: String,
+	dataName: String
+): ZxingCpp.BitMatrix? {
+	val width = getInt(widthName)
+	val height = getInt(heightName)
+	val data = getBlob(dataName)
+	return if (width > 0 && height > 0 && data != null) {
+		ZxingCpp.BitMatrix(width, height, data)
+	} else {
+		null
+	}
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/database/Database.kt

@@ -6,6 +6,8 @@ import android.database.Cursor
 import android.database.sqlite.SQLiteDatabase
 import android.database.sqlite.SQLiteOpenHelper
 import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.preference.Preferences
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
 
 class Database {
 	private lateinit var db: SQLiteDatabase
@@ -14,7 +16,7 @@ class Database {
 		db = OpenHelper(context).writableDatabase
 	}
 
-	fun getScans(query: String? = null): Cursor? = db.rawQuery(
+	fun getScans(query: String? = null): Cursor = db.rawQuery(
 		"""SELECT
 			$SCANS_ID,
 			$SCANS_DATETIME,
@@ -27,7 +29,7 @@ class Database {
 		""".trimMargin(), getWhereArguments(query)
 	)
 
-	fun getScansDetailed(query: String? = null): Cursor? = db.rawQuery(
+	fun getScansDetailed(query: String? = null): Cursor = db.rawQuery(
 		"""SELECT
 			$SCANS_ID,
 			$SCANS_DATETIME,
@@ -36,13 +38,14 @@ class Database {
 			$SCANS_RAW,
 			$SCANS_FORMAT,
 			$SCANS_ERROR_CORRECTION_LEVEL,
-			$SCANS_ISSUE_NUMBER,
-			$SCANS_ORIENTATION,
-			$SCANS_OTHER_META_DATA,
-			$SCANS_PDF417_EXTRA_METADATA,
-			$SCANS_POSSIBLE_COUNTRY,
-			$SCANS_SUGGESTED_PRICE,
-			$SCANS_UPC_EAN_EXTENSION
+			$SCANS_VERSION,
+			$SCANS_SEQUENCE_SIZE,
+			$SCANS_SEQUENCE_INDEX,
+			$SCANS_SEQUENCE_ID,
+			$SCANS_GTIN_COUNTRY,
+			$SCANS_GTIN_ADD_ON,
+			$SCANS_GTIN_PRICE,
+			$SCANS_GTIN_ISSUE_NUMBER
 			FROM $SCANS
 			${getWhereClause(query)}
 			ORDER BY $SCANS_DATETIME DESC
@@ -68,6 +71,29 @@ class Database {
 		null
 	}
 
+	fun getScansDetailed(ids: LongArray): Cursor = db.rawQuery(
+		"""SELECT
+			$SCANS_ID,
+			$SCANS_DATETIME,
+			$SCANS_NAME,
+			$SCANS_CONTENT,
+			$SCANS_RAW,
+			$SCANS_FORMAT,
+			$SCANS_ERROR_CORRECTION_LEVEL,
+			$SCANS_VERSION,
+			$SCANS_SEQUENCE_SIZE,
+			$SCANS_SEQUENCE_INDEX,
+			$SCANS_SEQUENCE_ID,
+			$SCANS_GTIN_COUNTRY,
+			$SCANS_GTIN_ADD_ON,
+			$SCANS_GTIN_PRICE,
+			$SCANS_GTIN_ISSUE_NUMBER
+			FROM $SCANS
+			WHERE $SCANS_ID IN (${ids.joinToString(",")})
+			ORDER BY $SCANS_DATETIME DESC
+		""".trimMargin(), null
+	)
+
 	fun getScan(id: Long): Scan? = db.rawQuery(
 		"""SELECT
 			$SCANS_ID,
@@ -77,78 +103,108 @@ class Database {
 			$SCANS_RAW,
 			$SCANS_FORMAT,
 			$SCANS_ERROR_CORRECTION_LEVEL,
-			$SCANS_ISSUE_NUMBER,
-			$SCANS_ORIENTATION,
-			$SCANS_OTHER_META_DATA,
-			$SCANS_PDF417_EXTRA_METADATA,
-			$SCANS_POSSIBLE_COUNTRY,
-			$SCANS_SUGGESTED_PRICE,
-			$SCANS_UPC_EAN_EXTENSION
+			$SCANS_VERSION,
+			$SCANS_DATA_MASK,
+			$SCANS_SYMBOL_WIDTH,
+			$SCANS_SYMBOL_HEIGHT,
+			$SCANS_SYMBOL_DATA,
+			$SCANS_SEQUENCE_SIZE,
+			$SCANS_SEQUENCE_INDEX,
+			$SCANS_SEQUENCE_ID,
+			$SCANS_GTIN_COUNTRY,
+			$SCANS_GTIN_ADD_ON,
+			$SCANS_GTIN_PRICE,
+			$SCANS_GTIN_ISSUE_NUMBER
 			FROM $SCANS
 			WHERE $SCANS_ID = ?
 		""".trimMargin(), arrayOf("$id")
-	)?.use {
+	).use {
 		if (it.moveToFirst()) {
 			Scan(
 				it.getString(SCANS_CONTENT),
 				it.getBlob(SCANS_RAW),
-				it.getString(SCANS_FORMAT),
+				BarcodeFormat.valueOf(it.getString(SCANS_FORMAT)),
 				it.getString(SCANS_ERROR_CORRECTION_LEVEL),
-				it.getString(SCANS_ISSUE_NUMBER),
-				it.getString(SCANS_ORIENTATION),
-				it.getString(SCANS_OTHER_META_DATA),
-				it.getString(SCANS_PDF417_EXTRA_METADATA),
-				it.getString(SCANS_POSSIBLE_COUNTRY),
-				it.getString(SCANS_SUGGESTED_PRICE),
-				it.getString(SCANS_UPC_EAN_EXTENSION),
+				it.getString(SCANS_VERSION),
+				it.getInt(SCANS_DATA_MASK),
+				it.getBitMatrix(
+					SCANS_SYMBOL_WIDTH,
+					SCANS_SYMBOL_HEIGHT,
+					SCANS_SYMBOL_DATA
+				),
+				it.getInt(SCANS_SEQUENCE_SIZE),
+				it.getInt(SCANS_SEQUENCE_INDEX),
+				it.getString(SCANS_SEQUENCE_ID),
+				it.getString(SCANS_GTIN_COUNTRY),
+				it.getString(SCANS_GTIN_ADD_ON),
+				it.getString(SCANS_GTIN_PRICE),
+				it.getString(SCANS_GTIN_ISSUE_NUMBER),
 				it.getString(SCANS_DATETIME),
-				it.getLong(SCANS_ID)
+				it.getLong(SCANS_ID),
+				it.getString(SCANS_NAME),
 			)
 		} else {
 			null
 		}
 	}
 
-	fun insertScan(scan: Scan): Long = db.insert(
-		SCANS,
-		null,
-		ContentValues().apply {
-			put(SCANS_DATETIME, scan.dateTime)
-			val isRaw = scan.raw != null
-			if (isRaw) {
-				put(SCANS_CONTENT, "")
-				put(SCANS_RAW, scan.raw)
-			} else {
-				put(SCANS_CONTENT, scan.content)
-			}
-			put(SCANS_FORMAT, scan.format)
-			scan.errorCorrectionLevel?.let {
-				put(SCANS_ERROR_CORRECTION_LEVEL, it)
-			}
-			scan.issueNumber?.let { put(SCANS_ISSUE_NUMBER, it) }
-			scan.orientation?.let { put(SCANS_ORIENTATION, it) }
-			scan.otherMetaData?.let { put(SCANS_OTHER_META_DATA, it) }
-			scan.pdf417ExtraMetaData?.let { put(SCANS_PDF417_EXTRA_METADATA, it) }
-			scan.possibleCountry?.let { put(SCANS_POSSIBLE_COUNTRY, it) }
-			scan.suggestedPrice?.let { put(SCANS_SUGGESTED_PRICE, it) }
-			scan.upcEanExtension?.let { put(SCANS_UPC_EAN_EXTENSION, it) }
-			if (prefs.ignoreConsecutiveDuplicates) {
+	fun insertScan(scan: Scan): Long {
+		when (prefs.ignoreDuplicates()) {
+			Preferences.Companion.IgnoreDuplicates.Consecutive -> {
 				val id = getIdOfLastScan(
-					get(SCANS_CONTENT) as String,
-					if (isRaw) get(SCANS_RAW) as ByteArray else null,
+					scan.text,
+					scan.raw,
 					scan.format
 				)
 				if (id > 0L) {
 					return id
 				}
 			}
+
+			Preferences.Companion.IgnoreDuplicates.Any -> {
+				val id = getIdOfScanByContent(scan.text, scan.format)
+				if (id > 0L) {
+					return id
+				}
+			}
+
+			else -> Unit
 		}
-	)
+		return db.insert(
+			SCANS,
+			null,
+			ContentValues().apply {
+				put(SCANS_DATETIME, scan.dateTime)
+				put(SCANS_CONTENT, scan.text)
+				if (scan.raw != null) {
+					put(SCANS_RAW, scan.raw)
+				}
+				put(SCANS_FORMAT, scan.format.name)
+				scan.errorCorrectionLevel?.let {
+					put(SCANS_ERROR_CORRECTION_LEVEL, it)
+				}
+				put(SCANS_VERSION, scan.version)
+				put(SCANS_DATA_MASK, scan.dataMask)
+				if (scan.symbol != null) {
+					put(SCANS_SYMBOL_WIDTH, scan.symbol.width)
+					put(SCANS_SYMBOL_HEIGHT, scan.symbol.height)
+					put(SCANS_SYMBOL_DATA, scan.symbol.data)
+				}
+				put(SCANS_SEQUENCE_SIZE, scan.sequenceSize)
+				put(SCANS_SEQUENCE_INDEX, scan.sequenceIndex)
+				put(SCANS_SEQUENCE_ID, scan.sequenceId)
+				scan.country?.let { put(SCANS_GTIN_COUNTRY, it) }
+				scan.addOn?.let { put(SCANS_GTIN_ADD_ON, it) }
+				scan.price?.let { put(SCANS_GTIN_PRICE, it) }
+				scan.issueNumber?.let { put(SCANS_GTIN_ISSUE_NUMBER, it) }
+			}
+		)
+	}
 
 	private fun getIdOfLastScan(
 		content: String,
 		raw: ByteArray?,
-		format: String
+		format: BarcodeFormat
 	): Long = db.rawQuery(
 		"""SELECT
 				$SCANS_ID,
@@ -159,19 +215,38 @@ class Database {
 				ORDER BY $SCANS_ID DESC
 				LIMIT 1
 			""".trimMargin(), null
-	)?.use {
+	).use {
 		if (it.count > 0 &&
 			it.moveToFirst() &&
 			it.getString(SCANS_CONTENT) == content &&
 			(raw == null || it.getBlob(SCANS_RAW)
 				?.contentEquals(raw) == true) &&
-			it.getString(SCANS_FORMAT) == format
+			it.getString(SCANS_FORMAT) == format.name
 		) {
 			it.getLong(SCANS_ID)
 		} else {
 			0L
 		}
-	} ?: 0L
+	}
+
+	private fun getIdOfScanByContent(
+		content: String,
+		format: BarcodeFormat
+	): Long = db.rawQuery(
+		"""SELECT
+				$SCANS_ID
+				FROM $SCANS
+				WHERE $SCANS_CONTENT = ?
+					AND $SCANS_FORMAT = ?
+				LIMIT 1
+			""".trimMargin(), arrayOf(content, format.name)
+	).use {
+		if (it.moveToFirst()) {
+			it.getLong(SCANS_ID)
+		} else {
+			0L
+		}
+	}
 
 	fun removeScan(id: Long) {
 		db.delete(SCANS, "$SCANS_ID = ?", arrayOf("$id"))
@@ -188,9 +263,9 @@ class Database {
 	}
 
 	private class OpenHelper(context: Context) :
-		SQLiteOpenHelper(context, FILE_NAME, null, 4) {
+		SQLiteOpenHelper(context, FILE_NAME, null, 8) {
 		override fun onCreate(db: SQLiteDatabase) {
-			createScans(db)
+			db.createScans()
 		}
 
 		override fun onUpgrade(
@@ -199,13 +274,25 @@ class Database {
 			newVersion: Int
 		) {
 			if (oldVersion < 2) {
-				addRawColumn(db)
+				db.addRawColumn()
 			}
 			if (oldVersion < 3) {
-				addMetaDataColumns(db)
+				db.addMetaDataColumns()
 			}
 			if (oldVersion < 4) {
-				addNameColumn(db)
+				db.addNameColumn()
+			}
+			if (oldVersion < 5) {
+				db.migrateToZxingCpp()
+			}
+			if (oldVersion < 6) {
+				db.migrateToVersionString()
+			}
+			if (oldVersion < 7) {
+				db.addDataMaskColumn()
+			}
+			if (oldVersion < 8) {
+				db.addSymbolColumns()
 			}
 		}
 	}
@@ -220,6 +307,12 @@ class Database {
 		const val SCANS_RAW = "raw"
 		const val SCANS_FORMAT = "format"
 		const val SCANS_ERROR_CORRECTION_LEVEL = "error_correction_level"
+		const val SCANS_VERSION_NUMBER = "version_number"
+		const val SCANS_VERSION = "version"
+		const val SCANS_DATA_MASK = "data_mask"
+		const val SCANS_SYMBOL_WIDTH = "symbol_width"
+		const val SCANS_SYMBOL_HEIGHT = "symbol_height"
+		const val SCANS_SYMBOL_DATA = "symbol_data"
 		const val SCANS_ISSUE_NUMBER = "issue_number"
 		const val SCANS_ORIENTATION = "orientation"
 		const val SCANS_OTHER_META_DATA = "other_meta_data"
@@ -227,10 +320,17 @@ class Database {
 		const val SCANS_POSSIBLE_COUNTRY = "possible_country"
 		const val SCANS_SUGGESTED_PRICE = "suggested_price"
 		const val SCANS_UPC_EAN_EXTENSION = "upc_ean_extension"
+		const val SCANS_SEQUENCE_SIZE = "sequence_size"
+		const val SCANS_SEQUENCE_INDEX = "sequence_index"
+		const val SCANS_SEQUENCE_ID = "sequence_id"
+		const val SCANS_GTIN_COUNTRY = "gtin_country"
+		const val SCANS_GTIN_ADD_ON = "gtin_add_on"
+		const val SCANS_GTIN_PRICE = "gtin_price"
+		const val SCANS_GTIN_ISSUE_NUMBER = "gtin_issue_number"
 
-		private fun createScans(db: SQLiteDatabase) {
-			db.execSQL("DROP TABLE IF EXISTS $SCANS".trimMargin())
-			db.execSQL(
+		private fun SQLiteDatabase.createScans() {
+			execSQL("DROP TABLE IF EXISTS $SCANS".trimMargin())
+			execSQL(
 				"""CREATE TABLE $SCANS (
 					$SCANS_ID INTEGER PRIMARY KEY AUTOINCREMENT,
 					$SCANS_DATETIME DATETIME NOT NULL,
@@ -239,36 +339,72 @@ class Database {
 					$SCANS_RAW BLOB,
 					$SCANS_FORMAT TEXT NOT NULL,
 					$SCANS_ERROR_CORRECTION_LEVEL TEXT,
-					$SCANS_ISSUE_NUMBER INT,
-					$SCANS_ORIENTATION INT,
-					$SCANS_OTHER_META_DATA TEXT,
-					$SCANS_PDF417_EXTRA_METADATA TEXT,
-					$SCANS_POSSIBLE_COUNTRY TEXT,
-					$SCANS_SUGGESTED_PRICE TEXT,
-					$SCANS_UPC_EAN_EXTENSION TEXT
+					$SCANS_VERSION TEXT,
+					$SCANS_DATA_MASK INTEGER,
+					$SCANS_SYMBOL_WIDTH INTEGER,
+					$SCANS_SYMBOL_HEIGHT INTEGER,
+					$SCANS_SYMBOL_DATA BLOB,
+					$SCANS_SEQUENCE_SIZE INTEGER,
+					$SCANS_SEQUENCE_INDEX INTEGER,
+					$SCANS_SEQUENCE_ID TEXT,
+					$SCANS_GTIN_COUNTRY TEXT,
+					$SCANS_GTIN_ADD_ON TEXT,
+					$SCANS_GTIN_PRICE TEXT,
+					$SCANS_GTIN_ISSUE_NUMBER TEXT
 				)""".trimMargin()
 			)
 		}
 
-		private fun addRawColumn(db: SQLiteDatabase) {
-			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_RAW BLOB".trimMargin())
+		private fun SQLiteDatabase.addRawColumn() {
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_RAW BLOB".trimMargin())
 		}
 
-		private fun addMetaDataColumns(db: SQLiteDatabase) {
-			db.apply {
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ERROR_CORRECTION_LEVEL TEXT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ISSUE_NUMBER INT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ORIENTATION INT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_OTHER_META_DATA TEXT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_PDF417_EXTRA_METADATA TEXT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_POSSIBLE_COUNTRY TEXT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_SUGGESTED_PRICE TEXT".trimMargin())
-				execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_UPC_EAN_EXTENSION TEXT".trimMargin())
-			}
+		private fun SQLiteDatabase.addMetaDataColumns() {
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ERROR_CORRECTION_LEVEL TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ISSUE_NUMBER INT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ORIENTATION INT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_OTHER_META_DATA TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_PDF417_EXTRA_METADATA TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_POSSIBLE_COUNTRY TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_SUGGESTED_PRICE TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_UPC_EAN_EXTENSION TEXT".trimMargin())
 		}
 
-		private fun addNameColumn(db: SQLiteDatabase) {
-			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_NAME TEXT".trimMargin())
+		private fun SQLiteDatabase.addNameColumn() {
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_NAME TEXT")
+		}
+
+		private fun SQLiteDatabase.migrateToZxingCpp() {
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_VERSION_NUMBER INTEGER".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_SEQUENCE_SIZE INTEGER".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_SEQUENCE_INDEX INTEGER".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_SEQUENCE_ID TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_GTIN_COUNTRY TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_GTIN_ADD_ON TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_GTIN_PRICE TEXT".trimMargin())
+			execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_GTIN_ISSUE_NUMBER TEXT".trimMargin())
+			execSQL("UPDATE $SCANS SET $SCANS_SEQUENCE_SIZE = -1")
+			execSQL("UPDATE $SCANS SET $SCANS_SEQUENCE_INDEX = -1")
+			execSQL("UPDATE $SCANS SET $SCANS_GTIN_COUNTRY = $SCANS_POSSIBLE_COUNTRY")
+			execSQL("UPDATE $SCANS SET $SCANS_GTIN_ADD_ON = $SCANS_UPC_EAN_EXTENSION")
+			execSQL("UPDATE $SCANS SET $SCANS_GTIN_PRICE = $SCANS_SUGGESTED_PRICE")
+			execSQL("UPDATE $SCANS SET $SCANS_GTIN_ISSUE_NUMBER = $SCANS_ISSUE_NUMBER")
+		}
+
+		private fun SQLiteDatabase.migrateToVersionString() {
+			execSQL("ALTER TABLE $SCANS ADD $SCANS_VERSION TEXT")
+			execSQL("UPDATE $SCANS SET $SCANS_VERSION = $SCANS_VERSION_NUMBER")
+		}
+
+		private fun SQLiteDatabase.addDataMaskColumn() {
+			execSQL("ALTER TABLE $SCANS ADD $SCANS_DATA_MASK INTEGER")
+			execSQL("UPDATE $SCANS SET $SCANS_DATA_MASK = -1")
+		}
+
+		private fun SQLiteDatabase.addSymbolColumns() {
+			execSQL("ALTER TABLE $SCANS ADD $SCANS_SYMBOL_WIDTH INTEGER")
+			execSQL("ALTER TABLE $SCANS ADD $SCANS_SYMBOL_HEIGHT INTEGER")
+			execSQL("ALTER TABLE $SCANS ADD $SCANS_SYMBOL_DATA BLOB")
 		}
 	}
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/database/JsonExport.kt

@@ -2,7 +2,7 @@ package de.markusfisch.android.binaryeye.database
 
 import android.content.Context
 import android.database.Cursor
-import de.markusfisch.android.binaryeye.app.toHexString
+import de.markusfisch.android.binaryeye.content.toHexString
 import de.markusfisch.android.binaryeye.io.writeExternalFile
 import org.json.JSONArray
 import org.json.JSONException
@@ -24,15 +24,17 @@ fun Cursor.exportJson(): String? {
 	val columns = arrayOf(
 		Database.SCANS_DATETIME,
 		Database.SCANS_FORMAT,
+		Database.SCANS_NAME,
 		Database.SCANS_CONTENT,
 		Database.SCANS_ERROR_CORRECTION_LEVEL,
-		Database.SCANS_ISSUE_NUMBER,
-		Database.SCANS_ORIENTATION,
-		Database.SCANS_OTHER_META_DATA,
-		Database.SCANS_PDF417_EXTRA_METADATA,
-		Database.SCANS_POSSIBLE_COUNTRY,
-		Database.SCANS_SUGGESTED_PRICE,
-		Database.SCANS_UPC_EAN_EXTENSION
+		Database.SCANS_VERSION,
+		Database.SCANS_SEQUENCE_SIZE,
+		Database.SCANS_SEQUENCE_INDEX,
+		Database.SCANS_SEQUENCE_ID,
+		Database.SCANS_GTIN_COUNTRY,
+		Database.SCANS_GTIN_ADD_ON,
+		Database.SCANS_GTIN_PRICE,
+		Database.SCANS_GTIN_ISSUE_NUMBER
 	)
 	val indices = columns.map {
 		Pair(getColumnIndex(it), it)

app/src/main/kotlin/de/markusfisch/android/binaryeye/database/Scan.kt

@@ -1,29 +1,36 @@
 package de.markusfisch.android.binaryeye.database
 
+import android.os.Build
 import android.os.Parcel
 import android.os.Parcelable
 import android.text.format.DateFormat
-import com.google.zxing.Result
-import com.google.zxing.ResultMetadataType
-import de.markusfisch.android.binaryeye.app.hasNonPrintableCharacters
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
+import de.markusfisch.android.zxingcpp.ZxingCpp.BitMatrix
+import de.markusfisch.android.zxingcpp.ZxingCpp.ContentType
+import de.markusfisch.android.zxingcpp.ZxingCpp.Result
+import java.util.Locale
 
 data class Scan(
-	val content: String,
+	val text: String,
 	val raw: ByteArray?,
-	val format: String,
-	val errorCorrectionLevel: String?,
-	val issueNumber: String?,
-	val orientation: String?,
-	val otherMetaData: String?,
-	val pdf417ExtraMetaData: String?,
-	val possibleCountry: String?,
-	val suggestedPrice: String?,
-	val upcEanExtension: String?,
+	val format: BarcodeFormat,
+	val errorCorrectionLevel: String? = null,
+	val version: String? = null,
+	val dataMask: Int = -1,
+	val symbol: BitMatrix? = null,
+	val sequenceSize: Int = -1,
+	val sequenceIndex: Int = -1,
+	val sequenceId: String = "",
+	val country: String? = null,
+	val addOn: String? = null,
+	val price: String? = null,
+	val issueNumber: String? = null,
 	val dateTime: String = getDateTime(),
-	var id: Long = 0L
+	var id: Long = 0L,
+	val label: String? = null
 ) : Parcelable {
 	// Needs to be overwritten manually, as ByteArray is an array and
-	// this isn't handled well by Kotlin
+	// this isn't handled well by Kotlin.
 	override fun equals(other: Any?): Boolean {
 		if (this === other) {
 			return true
@@ -36,70 +43,82 @@ data class Scan(
 
 		return id == other.id &&
 				dateTime == other.dateTime &&
-				content == other.content &&
+				text == other.text &&
 				((raw == null && other.raw == null) ||
 						(raw != null && other.raw != null && raw.contentEquals(other.raw))) &&
 				format == other.format &&
 				errorCorrectionLevel == other.errorCorrectionLevel &&
-				issueNumber == other.issueNumber &&
-				orientation == other.orientation &&
-				otherMetaData == other.otherMetaData &&
-				pdf417ExtraMetaData == other.pdf417ExtraMetaData &&
-				possibleCountry == other.possibleCountry &&
-				suggestedPrice == other.suggestedPrice &&
-				upcEanExtension == other.upcEanExtension
+				version == other.version &&
+				dataMask == other.dataMask &&
+				sequenceSize == other.sequenceSize &&
+				sequenceIndex == other.sequenceIndex &&
+				sequenceId == other.sequenceId &&
+				country == other.country &&
+				addOn == other.addOn &&
+				price == other.price &&
+				issueNumber == other.issueNumber
 	}
 
 	// Needs to be overwritten manually, as ByteArray is an array and
-	// this isn't handled well by Kotlin
+	// this isn't handled well by Kotlin.
 	override fun hashCode(): Int {
 		var result = id.hashCode()
 		result = 31 * result + dateTime.hashCode()
-		result = 31 * result + content.hashCode()
+		result = 31 * result + text.hashCode()
 		result = 31 * result + (raw?.contentHashCode() ?: 0)
 		result = 31 * result + format.hashCode()
 		result = 31 * result + (errorCorrectionLevel?.hashCode() ?: 0)
+		result = 31 * result + version.hashCode()
+		result = 31 * result + dataMask
+		result = 31 * result + sequenceSize
+		result = 31 * result + sequenceIndex
+		result = 31 * result + sequenceId.hashCode()
+		result = 31 * result + (country?.hashCode() ?: 0)
+		result = 31 * result + (addOn?.hashCode() ?: 0)
+		result = 31 * result + (price?.hashCode() ?: 0)
 		result = 31 * result + (issueNumber?.hashCode() ?: 0)
-		result = 31 * result + (orientation?.hashCode() ?: 0)
-		result = 31 * result + (otherMetaData?.hashCode() ?: 0)
-		result = 31 * result + (pdf417ExtraMetaData?.hashCode() ?: 0)
-		result = 31 * result + (possibleCountry?.hashCode() ?: 0)
-		result = 31 * result + (suggestedPrice?.hashCode() ?: 0)
-		result = 31 * result + (upcEanExtension?.hashCode() ?: 0)
 		return result
 	}
 
 	private constructor(parcel: Parcel) : this(
-		content = parcel.readString() ?: "",
+		text = parcel.readString() ?: "",
 		raw = parcel.readSizedByteArray(),
-		format = parcel.readString() ?: "",
+		format = BarcodeFormat.valueOf(parcel.readString() ?: ""),
 		errorCorrectionLevel = parcel.readString(),
+		version = parcel.readString(),
+		dataMask = parcel.readInt(),
+		symbol = parcel.readBitMatrix(),
+		sequenceSize = parcel.readInt(),
+		sequenceIndex = parcel.readInt(),
+		sequenceId = parcel.readString() ?: "",
+		country = parcel.readString(),
+		addOn = parcel.readString(),
+		price = parcel.readString(),
 		issueNumber = parcel.readString(),
-		orientation = parcel.readString(),
-		otherMetaData = parcel.readString(),
-		pdf417ExtraMetaData = parcel.readString(),
-		possibleCountry = parcel.readString(),
-		suggestedPrice = parcel.readString(),
-		upcEanExtension = parcel.readString(),
 		dateTime = parcel.readString() ?: "",
-		id = parcel.readLong()
+		id = parcel.readLong(),
+		label = parcel.readString()
 	)
 
 	override fun writeToParcel(parcel: Parcel, flags: Int) {
 		parcel.apply {
-			writeString(content)
+			writeString(text)
 			writeSizedByteArray(raw)
-			writeString(format)
+			writeString(format.name)
 			writeString(errorCorrectionLevel)
+			writeString(version)
+			writeInt(dataMask)
+			writeBitMatrix(symbol)
+			writeInt(sequenceSize)
+			writeInt(sequenceIndex)
+			writeString(sequenceId)
+			writeString(country)
+			writeString(addOn)
+			writeString(price)
 			writeString(issueNumber)
-			writeString(orientation)
-			writeString(otherMetaData)
-			writeString(pdf417ExtraMetaData)
-			writeString(possibleCountry)
-			writeString(suggestedPrice)
-			writeString(upcEanExtension)
 			writeString(dateTime)
 			writeLong(id)
+			writeString(label)
 		}
 	}
 
@@ -114,10 +133,47 @@ data class Scan(
 	}
 }
 
-private fun getDateTime(time: Long = System.currentTimeMillis()) = DateFormat.format(
-	"yyyy-MM-dd HH:mm:ss",
+fun Result.toScan(): Scan {
+	return Scan(
+		when (contentType) {
+			ContentType.GS1,
+			ContentType.ISO15434,
+			ContentType.TEXT -> text
+
+			else -> ""
+		},
+		rawBytes,
+		format,
+		ecLevel,
+		version,
+		dataMask,
+		symbol,
+		sequenceSize,
+		sequenceIndex,
+		sequenceId,
+		gtin?.country,
+		gtin?.addOn,
+		gtin?.price,
+		gtin?.issueNumber
+	)
+}
+
+private fun getDateTime(
+	time: Long = System.currentTimeMillis()
+) = DateFormat.format(
+	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
+		// Up to API level 17, 'k' was interpreted as 'H', which wasn't
+		// implemented until API level 18.
+		"yyyy-MM-dd kk:mm:ss"
+	} else {
+		"yyyy-MM-dd HH:mm:ss"
+	},
 	time
-).toString()
+).toString() + String.format(
+	Locale.getDefault(),
+	":%03d",
+	time % 1000
+)
 
 private fun Parcel.writeSizedByteArray(array: ByteArray?) {
 	val size = array?.size ?: 0
@@ -138,50 +194,20 @@ private fun Parcel.readSizedByteArray(): ByteArray? {
 	}
 }
 
-fun Result.toScan(): Scan {
-	val content: String
-	val raw: ByteArray?
-	if (text.hasNonPrintableCharacters()) {
-		content = ""
-		raw = getRawData() ?: text.toByteArray()
-	} else {
-		content = text
-		raw = null
+private fun Parcel.writeBitMatrix(bm: BitMatrix?) {
+	writeInt(bm?.width ?: 0)
+	bm?.let {
+		writeInt(bm.height)
+		writeSizedByteArray(bm.data)
 	}
-	return Scan(
-		content,
-		raw,
-		barcodeFormat.toString(),
-		getMetaString(ResultMetadataType.ERROR_CORRECTION_LEVEL),
-		getMetaString(ResultMetadataType.ISSUE_NUMBER),
-		getMetaString(ResultMetadataType.ORIENTATION),
-		getMetaString(ResultMetadataType.OTHER),
-		getMetaString(ResultMetadataType.PDF417_EXTRA_METADATA),
-		getMetaString(ResultMetadataType.POSSIBLE_COUNTRY),
-		getMetaString(ResultMetadataType.SUGGESTED_PRICE),
-		getMetaString(ResultMetadataType.UPC_EAN_EXTENSION)
-	)
 }
 
-private fun Result.getRawData(): ByteArray? {
-	val metadata = resultMetadata ?: return null
-	val segments = metadata[ResultMetadataType.BYTE_SEGMENTS] ?: return null
-	var bytes = ByteArray(0)
-	@Suppress("UNCHECKED_CAST")
-	for (seg in segments as Iterable<ByteArray>) {
-		bytes += seg
+private fun Parcel.readBitMatrix(): BitMatrix? {
+	val width = readInt()
+	if (width < 1) {
+		return null
 	}
-	// If the byte segments are shorter than the converted string, the
-	// content of the QR Code has been encoded with different encoding
-	// modes (e.g. some parts in alphanumeric, some in byte encoding).
-	// This is because Zxing only records byte segments for byte encoded
-	// parts. Please note the byte segments can actually be longer than
-	// the string because Zxing cuts off prefixes like "WIFI:".
-	return if (bytes.size >= text.length) bytes else null
-}
-
-private fun Result.getMetaString(
-	key: ResultMetadataType
-): String? = this.resultMetadata?.let {
-	it[key]?.toString()
+	val height = readInt()
+	val data = readSizedByteArray() ?: return null
+	return BitMatrix(width, height, data)
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/BarcodeFragment.kt

@@ -7,45 +7,64 @@ import android.graphics.Bitmap
 import android.os.Build
 import android.os.Bundle
 import android.support.v4.app.Fragment
-import android.view.*
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import android.widget.EditText
-import com.google.zxing.BarcodeFormat
-import com.google.zxing.EncodeHintType
+import android.widget.SeekBar
+import android.widget.TextView
 import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.app.db
 import de.markusfisch.android.binaryeye.app.hasWritePermission
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.content.Barcode
+import de.markusfisch.android.binaryeye.content.BitMatrixBarcode
+import de.markusfisch.android.binaryeye.content.BarcodeColors
+import de.markusfisch.android.binaryeye.content.ContentBarcode
 import de.markusfisch.android.binaryeye.content.copyToClipboard
 import de.markusfisch.android.binaryeye.content.shareFile
 import de.markusfisch.android.binaryeye.content.shareText
+import de.markusfisch.android.binaryeye.database.toScan
 import de.markusfisch.android.binaryeye.io.addSuffixIfNotGiven
 import de.markusfisch.android.binaryeye.io.toSaveResult
 import de.markusfisch.android.binaryeye.io.writeExternalFile
+import de.markusfisch.android.binaryeye.os.getScreenBrightness
+import de.markusfisch.android.binaryeye.os.setScreenBrightness
 import de.markusfisch.android.binaryeye.view.doOnApplyWindowInsets
 import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
 import de.markusfisch.android.binaryeye.widget.ConfinedScalingImageView
 import de.markusfisch.android.binaryeye.widget.toast
-import de.markusfisch.android.binaryeye.zxing.encodeAsBitmap
-import de.markusfisch.android.binaryeye.zxing.encodeAsSvg
-import de.markusfisch.android.binaryeye.zxing.encodeAsText
-import kotlinx.coroutines.*
+import de.markusfisch.android.zxingcpp.ZxingCpp
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
 import java.io.OutputStream
-import java.util.*
+import java.util.Locale
+import kotlin.math.max
+import kotlin.math.min
 
 class BarcodeFragment : Fragment() {
 	private enum class FileType {
-		PNG, SVG, TXT
+		PNG, JPG, SVG, TXT
 	}
 
 	private val parentJob = Job()
 	private val scope = CoroutineScope(Dispatchers.IO + parentJob)
 
-	private var barcodeBitmap: Bitmap? = null
-	private var barcodeSvg: String? = null
-	private var barcodeTxt: String? = null
-	private var content: String = ""
-	private var format: BarcodeFormat? = null
+	private lateinit var barcode: Barcode<*>
+	private lateinit var addToHistoryItem: MenuItem
+	private lateinit var brightenScreenItem: MenuItem
+
+	private var currentBrightness = -1f
 
 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
@@ -66,18 +85,16 @@ class BarcodeFragment : Fragment() {
 			false
 		)
 
-		val args = arguments ?: return view
-		val content = args.getString(CONTENT) ?: return view
-		val format = args.getSerializable(FORMAT) as BarcodeFormat? ?: return view
-		val hints = args.getSerializable(HINTS) as EnumMap<EncodeHintType, Any>?
-		val size = args.getInt(SIZE)
+		val bitmap: Bitmap
 		try {
-			barcodeBitmap = encodeAsBitmap(content, format, size, size, hints)
-			barcodeSvg = encodeAsSvg(content, format, hints)
-			barcodeTxt = encodeAsText(content, format, hints)
+			barcode = arguments?.toBarcode() ?: throw IllegalArgumentException(
+				"Illegal arguments"
+			)
+			// Catch exceptions from encoding.
+			bitmap = barcode.bitmap()
 		} catch (e: Exception) {
 			var message = e.message
-			if (message == null || message.isEmpty()) {
+			if (message.isNullOrEmpty()) {
 				message = getString(R.string.error_encoding_barcode)
 			}
 			message?.let {
@@ -86,16 +103,17 @@ class BarcodeFragment : Fragment() {
 			fragmentManager.popBackStack()
 			return null
 		}
-		this.content = content
-		this.format = format
 
 		val imageView = view.findViewById<ConfinedScalingImageView>(
 			R.id.barcode
 		)
-		imageView.setImageBitmap(barcodeBitmap)
+		imageView.setImageBitmap(bitmap)
 		imageView.post {
 			// Make sure to invoke this after ScalingImageView.onLayout().
-			imageView.minWidth /= 2f
+			imageView.minWidth = min(
+				imageView.minWidth / 2f,
+				max(bitmap.width, bitmap.height).toFloat()
+			)
 		}
 
 		view.findViewById<View>(R.id.share).setOnClickListener {
@@ -106,7 +124,7 @@ class BarcodeFragment : Fragment() {
 			}
 		}
 
-		(view.findViewById(R.id.inset_layout) as View).setPaddingFromWindowInsets()
+		view.findViewById<View>(R.id.inset_layout).setPaddingFromWindowInsets()
 		imageView.doOnApplyWindowInsets { v, insets ->
 			(v as ConfinedScalingImageView).insets.set(insets)
 		}
@@ -114,6 +132,57 @@ class BarcodeFragment : Fragment() {
 		return view
 	}
 
+	private fun Bundle.toBarcode(): Barcode<*> {
+		val content =
+			getString(CONTENT_TEXT) ?: getByteArray(CONTENT_RAW) ?: throw IllegalArgumentException(
+				"content cannot be null"
+			)
+		val barcodeFormat = BarcodeFormat.valueOf(
+			getString(FORMAT) ?: throw IllegalArgumentException(
+				"format cannot be null"
+			)
+		)
+		val colors = BarcodeColors.entries[getInt(COLORS)]
+		val data = getByteArray(BIT_MATRIX_DATA)
+		return if (data != null) {
+			BitMatrixBarcode(
+				ZxingCpp.BitMatrix(
+					getInt(BIT_MATRIX_WIDTH),
+					getInt(BIT_MATRIX_HEIGHT),
+					data
+				),
+				content,
+				barcodeFormat,
+				colors
+			)
+		} else {
+			ContentBarcode(
+				content,
+				barcodeFormat,
+				getInt(EC_LEVEL),
+				getInt(MARGIN),
+				colors
+			)
+		}
+	}
+
+	override fun onResume() {
+		super.onResume()
+		if (prefs.brightenScreen) {
+			// Post to make sure brightenScreenItem is initialized.
+			view?.post {
+				brightenScreen()
+			}
+		}
+	}
+
+	override fun onPause() {
+		super.onPause()
+		if (currentBrightness > -1f) {
+			restoreScreenBrightness()
+		}
+	}
+
 	override fun onDestroyView() {
 		super.onDestroyView()
 		parentJob.cancel()
@@ -121,23 +190,55 @@ class BarcodeFragment : Fragment() {
 
 	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
 		inflater.inflate(R.menu.fragment_barcode, menu)
+		addToHistoryItem = menu.findItem(R.id.add_to_history)
+		brightenScreenItem = menu.findItem(R.id.brighten_screen)
 	}
 
 	override fun onOptionsItemSelected(item: MenuItem): Boolean {
 		return when (item.itemId) {
+			R.id.add_to_history -> {
+				readAndAddToHistory(
+					barcode.bitmap(),
+					barcode.format
+				)
+				addToHistoryItem.isVisible = false
+				context.toast(R.string.added_to_history)
+				true
+			}
+
 			R.id.copy_to_clipboard -> {
-				barcodeTxt?.let {
-					context.copyToClipboard(it)
-					context.toast(R.string.copied_to_clipboard)
+				context.apply {
+					copyToClipboard(barcode.text())
+					toast(R.string.copied_to_clipboard)
 				}
 				true
 			}
+
 			R.id.export_to_file -> {
-				context.pickFileType(R.string.export_as) {
-					askForFileNameAndSave(it)
+				context.pickFileType(R.string.export_as) { fileType ->
+					when (fileType) {
+						FileType.PNG,
+						FileType.JPG -> askForSize { size ->
+							askForFileNameAndSave(fileType, size)
+						}
+
+						else -> askForFileNameAndSave(fileType, 0)
+					}
 				}
 				true
 			}
+
+			R.id.brighten_screen -> {
+				prefs.brightenScreen = if (currentBrightness > -1f) {
+					restoreScreenBrightness()
+					false
+				} else {
+					brightenScreen()
+					true
+				}
+				true
+			}
+
 			else -> super.onOptionsItemSelected(item)
 		}
 	}
@@ -146,7 +247,7 @@ class BarcodeFragment : Fragment() {
 		title: Int,
 		action: (FileType) -> Unit
 	) {
-		val fileTypes = FileType.values()
+		val fileTypes = FileType.entries.toTypedArray()
 		AlertDialog.Builder(this)
 			.setTitle(title)
 			.setItems(fileTypes.map { it.name }.toTypedArray()) { _, which ->
@@ -157,17 +258,21 @@ class BarcodeFragment : Fragment() {
 
 	// Dialogs do not have a parent view.
 	@SuppressLint("InflateParams")
-	private fun askForFileNameAndSave(fileType: FileType) {
+	private fun askForFileNameAndSave(fileType: FileType, bitmapSize: Int) {
 		val ac = activity ?: return
 		// Write permission is only required before Android Q.
 		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q &&
-			!ac.hasWritePermission { askForFileNameAndSave(fileType) }
+			!ac.hasWritePermission {
+				askForFileNameAndSave(fileType, bitmapSize)
+			}
 		) {
 			return
 		}
 		val view = ac.layoutInflater.inflate(R.layout.dialog_save_file, null)
 		val editText = view.findViewById<EditText>(R.id.file_name)
-		editText.setText(encodeFileName("${format.toString()}_$content"))
+		editText.setText(
+			encodeFileName("${barcode.format}_${barcode.content}")
+		)
 		AlertDialog.Builder(ac)
 			.setView(view)
 			.setPositiveButton(android.R.string.ok) { _, _ ->
@@ -177,23 +282,28 @@ class BarcodeFragment : Fragment() {
 						addSuffixIfNotGiven(fileName, ".png"),
 						MIME_PNG
 					) {
-						barcodeBitmap?.saveAsPng(it)
+						barcode.bitmap(bitmapSize).saveAsPng(it)
 					}
+
+					FileType.JPG -> saveAs(
+						addSuffixIfNotGiven(fileName, ".jpg"),
+						MIME_JPG
+					) {
+						barcode.bitmap(bitmapSize).saveAsJpg(it)
+					}
+
 					FileType.SVG -> saveAs(
 						addSuffixIfNotGiven(fileName, ".svg"),
 						MIME_SVG
-					) { outputStream ->
-						barcodeSvg?.let {
-							outputStream.write(it.toByteArray())
-						}
+					) {
+						it.write(barcode.svg().toByteArray())
 					}
+
 					FileType.TXT -> saveAs(
 						addSuffixIfNotGiven(fileName, ".txt"),
 						MIME_TXT
-					) { outputStream ->
-						barcodeTxt?.let {
-							outputStream.write(it.toByteArray())
-						}
+					) {
+						it.write(barcode.text().toByteArray())
 					}
 				}
 			}
@@ -202,6 +312,52 @@ class BarcodeFragment : Fragment() {
 			.show()
 	}
 
+	// Dialogs do not have a parent view.
+	@SuppressLint("InflateParams")
+	private fun askForSize(write: (size: Int) -> Unit) {
+		val ac = activity ?: return
+		val view = ac.layoutInflater.inflate(R.layout.dialog_size, null)
+		val sizeView = view.findViewById<TextView>(R.id.size_display)
+		val sizeBarView = view.findViewById<SeekBar>(R.id.size_bar)
+		sizeBarView.initSizeBar(sizeView)
+		AlertDialog.Builder(ac)
+			.setView(view)
+			.setPositiveButton(android.R.string.ok) { _, _ ->
+				write(getSize(sizeBarView.progress))
+			}
+			.setNegativeButton(android.R.string.cancel) { _, _ ->
+			}
+			.show()
+	}
+
+	private fun SeekBar.initSizeBar(sizeView: TextView) {
+		sizeView.updateSize(progress)
+		setOnSeekBarChangeListener(
+			object : SeekBar.OnSeekBarChangeListener {
+				override fun onProgressChanged(
+					seekBar: SeekBar,
+					progressValue: Int,
+					fromUser: Boolean
+				) {
+					sizeView.updateSize(progressValue)
+				}
+
+				override fun onStartTrackingTouch(seekBar: SeekBar) {}
+
+				override fun onStopTrackingTouch(seekBar: SeekBar) {}
+			}
+		)
+	}
+
+	private fun TextView.updateSize(power: Int) {
+		val size = getSize(power)
+		text = if (size > 0) {
+			getString(R.string.size_width_by_height, size, size)
+		} else {
+			getString(R.string.size_no_magnification)
+		}
+	}
+
 	private fun saveAs(
 		fileName: String,
 		mimeType: String,
@@ -218,21 +374,34 @@ class BarcodeFragment : Fragment() {
 
 	private fun Context.shareAs(fileType: FileType) {
 		when (fileType) {
-			FileType.PNG -> barcodeBitmap?.let { share(it) }
-			FileType.SVG -> barcodeSvg?.let { shareText(it, MIME_SVG) }
-			FileType.TXT -> barcodeTxt?.let { shareText(it) }
+			FileType.PNG -> askForSize {
+				share(barcode.bitmap(it), MIME_PNG, "png")
+			}
+
+			FileType.JPG -> askForSize {
+				share(barcode.bitmap(it), MIME_JPG, "jpg")
+			}
+
+			FileType.SVG -> shareText(barcode.svg(), MIME_SVG)
+			FileType.TXT -> shareText(barcode.text())
 		}
 	}
 
-	private fun Context.share(bitmap: Bitmap) {
+	private fun Context.share(bitmap: Bitmap, mimeType: String, ext: String) {
 		scope.launch(Dispatchers.IO) {
 			val file = File(
 				externalCacheDir,
-				"shared_barcode.png"
+				"shared_barcode.$ext"
 			)
 			val success = try {
 				FileOutputStream(file).use {
-					bitmap.saveAsPng(it)
+					when (mimeType) {
+						MIME_PNG -> bitmap.saveAsPng(it)
+						MIME_JPG -> bitmap.saveAsJpg(it)
+						else -> throw IllegalArgumentException(
+							"Invalid mime type"
+						)
+					}
 				}
 				true
 			} catch (e: IOException) {
@@ -240,7 +409,7 @@ class BarcodeFragment : Fragment() {
 			}
 			withContext(Dispatchers.Main) {
 				if (success) {
-					shareFile(file, "image/png")
+					shareFile(file, mimeType)
 				} else {
 					toast(R.string.error_saving_file)
 				}
@@ -248,38 +417,152 @@ class BarcodeFragment : Fragment() {
 		}
 	}
 
+	private fun brightenScreen() {
+		activity?.let {
+			currentBrightness = it.getScreenBrightness()
+			it.setScreenBrightness(1f)
+			brightenScreenItem.isChecked = true
+		}
+	}
+
+	private fun restoreScreenBrightness() {
+		if (currentBrightness > -1f) {
+			activity?.setScreenBrightness(currentBrightness)
+			currentBrightness = -1f
+			brightenScreenItem.isChecked = false
+		}
+	}
+
 	companion object {
-		private const val CONTENT = "content"
+		private const val BIT_MATRIX_WIDTH = "bit_matrix_width"
+		private const val BIT_MATRIX_HEIGHT = "bit_matrix_height"
+		private const val BIT_MATRIX_DATA = "bit_matrix_data"
+		private const val CONTENT_TEXT = "content_text"
+		private const val CONTENT_RAW = "content_raw"
 		private const val FORMAT = "format"
-		private const val HINTS = "hints"
-		private const val SIZE = "size"
+		private const val EC_LEVEL = "ec_level"
+		private const val MARGIN = "margin"
+		private const val COLORS = "colors"
 		private const val MIME_PNG = "image/png"
+		private const val MIME_JPG = "image/jpeg"
 		private const val MIME_SVG = "image/svg+xmg"
 		private const val MIME_TXT = "text/plain"
 
 		fun newInstance(
-			content: String,
-			format: BarcodeFormat,
-			size: Int,
-			hints: EnumMap<EncodeHintType, Any>? = null
+			barcode: Barcode<*>,
+			colors: Int = 0
 		): Fragment {
 			val args = Bundle()
-			args.putString(CONTENT, content)
-			args.putSerializable(FORMAT, format)
-			hints?.let {
-				args.putSerializable(HINTS, it)
+			when (barcode) {
+				is ContentBarcode -> args.putEcLevelMargin(
+					barcode.ecLevel,
+					barcode.margin
+				)
+
+				is BitMatrixBarcode -> {
+					args.putInt(BIT_MATRIX_WIDTH, barcode.bitMatrix.width)
+					args.putInt(BIT_MATRIX_HEIGHT, barcode.bitMatrix.height)
+					args.putByteArray(BIT_MATRIX_DATA, barcode.bitMatrix.data)
+				}
+
+				else -> throw IllegalArgumentException("unknown barcode")
 			}
-			args.putInt(SIZE, size)
+			args.putContentFormatColors(
+				barcode.content,
+				barcode.format,
+				colors
+			)
 			val fragment = BarcodeFragment()
 			fragment.arguments = args
 			return fragment
 		}
+
+		fun <T> newInstance(
+			content: T,
+			format: BarcodeFormat,
+			ecLevel: Int = -1,
+			margin: Int = -1,
+			colors: Int = 0
+		): Fragment {
+			val args = Bundle()
+			args.putContentFormatColors(content, format, colors)
+			args.putEcLevelMargin(ecLevel, margin)
+			val fragment = BarcodeFragment()
+			fragment.arguments = args
+			return fragment
+		}
+
+		private fun <T> Bundle.putContentFormatColors(
+			content: T,
+			format: BarcodeFormat,
+			colors: Int
+		) {
+			when (content) {
+				is String -> {
+					putString(CONTENT_TEXT, content)
+				}
+
+				is ByteArray -> {
+					putByteArray(CONTENT_RAW, content)
+				}
+
+				else -> {
+					throw IllegalArgumentException(
+						"content must be a String of a ByteArray"
+					)
+				}
+			}
+			putString(FORMAT, format.name)
+			putInt(COLORS, colors)
+		}
+
+		private fun Bundle.putEcLevelMargin(
+			ecLevel: Int,
+			margin: Int
+		) {
+			putInt(EC_LEVEL, ecLevel)
+			putInt(MARGIN, margin)
+		}
 	}
 }
 
 private fun Bitmap.saveAsPng(outputStream: OutputStream, quality: Int = 90) =
 	compress(Bitmap.CompressFormat.PNG, quality, outputStream)
 
+private fun Bitmap.saveAsJpg(outputStream: OutputStream, quality: Int = 90) =
+	compress(Bitmap.CompressFormat.JPEG, quality, outputStream)
+
 private val fileNameCharacters = "[^A-Za-z0-9]".toRegex()
-private fun encodeFileName(name: String): String =
-	fileNameCharacters.replace(name, "_").take(16).trim('_').lowercase(Locale.getDefault())
+private fun encodeFileName(name: String): String = fileNameCharacters
+	.replace(name, "_")
+	.take(16)
+	.trim('_')
+	.lowercase(Locale.getDefault())
+
+private fun getSize(step: Int) = when (step) {
+	0 -> 0
+	else -> 128 shl (step - 1)
+}
+
+private fun readAndAddToHistory(
+	bitmap: Bitmap,
+	format: BarcodeFormat
+) {
+	ZxingCpp.readBitmap(
+		bitmap,
+		0, 0,
+		bitmap.width, bitmap.height,
+		0,
+		ZxingCpp.ReaderOptions(
+			tryHarder = true,
+			tryRotate = true,
+			tryInvert = true,
+			tryDownscale = true,
+			maxNumberOfSymbols = 1,
+			formats = setOf(format)
+		)
+	)?.first {
+		db.insertScan(it.toScan())
+		true
+	}
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/DecodeFragment.kt

@@ -5,9 +5,20 @@ import android.os.Bundle
 import android.support.design.widget.FloatingActionButton
 import android.support.v4.app.Fragment
 import android.text.Editable
+import android.text.Html
+import android.text.Spannable
+import android.text.SpannableString
 import android.text.TextWatcher
-import android.view.*
+import android.text.method.LinkMovementMethod
+import android.text.style.TypefaceSpan
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import android.widget.EditText
+import android.widget.ImageView
 import android.widget.TableLayout
 import android.widget.TableRow
 import android.widget.TextView
@@ -17,19 +28,33 @@ import de.markusfisch.android.binaryeye.actions.wifi.WifiAction
 import de.markusfisch.android.binaryeye.actions.wifi.WifiConnector
 import de.markusfisch.android.binaryeye.activity.MainActivity
 import de.markusfisch.android.binaryeye.adapter.prettifyFormatName
-import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.app.addFragment
+import de.markusfisch.android.binaryeye.app.db
+import de.markusfisch.android.binaryeye.app.hasLocationPermission
+import de.markusfisch.android.binaryeye.app.hasWritePermission
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.content.ContentBarcode
 import de.markusfisch.android.binaryeye.content.copyToClipboard
+import de.markusfisch.android.binaryeye.content.shareAsFile
 import de.markusfisch.android.binaryeye.content.shareText
+import de.markusfisch.android.binaryeye.content.toBarcode
+import de.markusfisch.android.binaryeye.content.toErrorCorrectionInt
+import de.markusfisch.android.binaryeye.content.toHexString
+import de.markusfisch.android.binaryeye.content.wipeLastShareFile
 import de.markusfisch.android.binaryeye.database.Scan
 import de.markusfisch.android.binaryeye.io.askForFileName
 import de.markusfisch.android.binaryeye.io.toSaveResult
 import de.markusfisch.android.binaryeye.io.writeExternalFile
 import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
 import de.markusfisch.android.binaryeye.widget.toast
+import de.markusfisch.android.zxingcpp.ZxingCpp
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import java.security.MessageDigest
+import kotlin.math.roundToInt
 
 class DecodeFragment : Fragment() {
 	private lateinit var contentView: EditText
@@ -37,19 +62,27 @@ class DecodeFragment : Fragment() {
 	private lateinit var dataView: TableLayout
 	private lateinit var metaView: TableLayout
 	private lateinit var hexView: TextView
-	private lateinit var format: String
+	private lateinit var stampView: TextView
+	private lateinit var recreationView: ImageView
+	private lateinit var labelView: EditText
 	private lateinit var fab: FloatingActionButton
+	private lateinit var scan: Scan
+	private lateinit var format: String
 
 	private val parentJob = Job()
 	private val scope: CoroutineScope = CoroutineScope(Dispatchers.Main + parentJob)
+	private val dp: Float
+		get() = resources.displayMetrics.density
 	private val content: String
 		get() = contentView.text.toString()
 
 	private var closeAutomatically = false
 	private var action = ActionRegistry.DEFAULT_ACTION
 	private var isBinary = false
-	private var raw: ByteArray = ByteArray(0)
+	private var originalBytes: ByteArray = ByteArray(0)
 	private var id = 0L
+	private var label: String? = null
+	private var recreationSize = 0
 
 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
@@ -72,23 +105,83 @@ class DecodeFragment : Fragment() {
 		closeAutomatically = prefs.closeAutomatically &&
 				activity?.intent?.hasExtra(MainActivity.DECODED) == true
 
-		val scan = arguments?.getParcelable(SCAN) as Scan?
-			?: throw IllegalArgumentException("DecodeFragment needs a Scan")
-		id = scan.id
+		scan = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+			arguments?.getParcelable(SCAN, Scan::class.java)
+		} else {
+			@Suppress("DEPRECATION")
+			arguments?.getParcelable(SCAN) as Scan?
+		} ?: throw IllegalArgumentException("DecodeFragment needs a Scan")
 
-		val inputContent = scan.content
-		isBinary = scan.raw != null
-		raw = scan.raw ?: inputContent.toByteArray()
-		format = scan.format
+		isBinary = scan.text.isEmpty()
+		originalBytes = scan.raw ?: scan.text.toByteArray()
+		format = scan.format.name
+		id = scan.id
+		recreationSize = (200f * dp).roundToInt()
 
 		contentView = view.findViewById(R.id.content)
+		formatView = view.findViewById(R.id.format)
+		dataView = view.findViewById(R.id.data)
+		metaView = view.findViewById(R.id.meta)
+		hexView = view.findViewById(R.id.hex)
+		stampView = view.findViewById(R.id.stamp)
+		recreationView = view.findViewById(R.id.recreation)
+		labelView = view.findViewById(R.id.label)
 		fab = view.findViewById(R.id.open)
 
-		if (!isBinary) {
-			contentView.setText(inputContent)
+		initContentAndFab()
+
+		if (prefs.showMetaData) {
+			metaView.fillMetaView(scan)
+		} else {
+			metaView.visibility = View.GONE
+		}
+		if (id > 0) {
+			scan.label?.let {
+				labelView.setText(it)
+				label = it
+			}
+		} else {
+			labelView.visibility = View.GONE
+		}
+
+		updateViewsAndFab(scan.text, originalBytes)
+
+		view.findViewById<View>(R.id.inset_layout).setPaddingFromWindowInsets()
+		view.findViewById<View>(R.id.scroll_view).setPaddingFromWindowInsets()
+
+		return view
+	}
+
+	override fun onPause() {
+		super.onPause()
+		if (id > 0) {
+			val newLabel = labelView.text.toString().trim()
+			if (newLabel != (label ?: "")) {
+				db.renameScan(id, newLabel)
+				label = newLabel
+			}
+		}
+	}
+
+	override fun onDestroy() {
+		super.onDestroy()
+		parentJob.cancel()
+		wipeLastShareFile()
+	}
+
+	private fun initContentAndFab() {
+		if (isBinary) {
+			contentView.setText(String(originalBytes).foldNonAlNum())
+			contentView.isEnabled = false
+			fab.setImageResource(R.drawable.ic_action_save)
+			fab.setOnClickListener {
+				askForFileNameAndSave(originalBytes)
+			}
+		} else {
+			contentView.setText(scan.text)
 			contentView.addTextChangedListener(object : TextWatcher {
 				override fun afterTextChanged(s: Editable?) {
-					updateViewsAndAction(content.toByteArray())
+					updateViewsAndFab(s?.toString() ?: "")
 				}
 
 				override fun beforeTextChanged(
@@ -96,87 +189,118 @@ class DecodeFragment : Fragment() {
 					start: Int,
 					count: Int,
 					after: Int
-				) {
-				}
+				) = Unit
 
 				override fun onTextChanged(
 					s: CharSequence?,
 					start: Int,
 					before: Int,
 					count: Int
-				) {
-				}
+				) = Unit
 			})
 			fab.setOnClickListener {
-				executeAction(content.toByteArray())
+				executeAction(this.content)
 			}
 			if (prefs.openImmediately) {
-				executeAction(content.toByteArray())
-			}
-		} else {
-			contentView.setText(String(raw).foldNonAlNum())
-			contentView.isEnabled = false
-			fab.setImageResource(R.drawable.ic_action_save)
-			fab.setOnClickListener {
-				askForFileNameAndSave(raw)
+				executeAction(this.content)
 			}
 		}
-
-		formatView = view.findViewById(R.id.format)
-		dataView = view.findViewById(R.id.data)
-		metaView = view.findViewById(R.id.meta)
-		hexView = view.findViewById(R.id.hex)
-
-		updateViewsAndAction(raw)
-
-		if (!isBinary) {
-			fillDataView(dataView, inputContent)
-		}
-
-		if (prefs.showMetaData) {
-			fillMetaView(metaView, scan)
-		}
-
-		(view.findViewById(R.id.inset_layout) as View).setPaddingFromWindowInsets()
-		(view.findViewById(R.id.scroll_view) as View).setPaddingFromWindowInsets()
-
-		return view
 	}
 
-	override fun onDestroy() {
-		super.onDestroy()
-		parentJob.cancel()
+	private fun updateViewsAndFab(text: String, bytes: ByteArray? = null) {
+		val b = bytes ?: text.toByteArray()
+		resolveActionAndUpdateFab(b)
+		updateViews(text, b)
 	}
 
-	private fun updateViewsAndAction(bytes: ByteArray) {
+	private fun resolveActionAndUpdateFab(bytes: ByteArray) {
 		val prevAction = action
 		if (!prevAction.canExecuteOn(bytes)) {
 			action = ActionRegistry.getAction(bytes)
 		}
+		if (prevAction !== action) {
+			fab.setImageResource(action.iconResId)
+		}
+		// Run this for the initial action too.
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+			fab.setOnLongClickListener { v ->
+				v.context.toast(action.titleResId)
+				true
+			}
+		} else {
+			fab.tooltipText = getString(action.titleResId)
+		}
+	}
+
+	private fun updateViews(text: String, bytes: ByteArray) {
 		formatView.text = resources.getQuantityString(
 			R.plurals.barcode_info,
 			bytes.size,
 			prettifyFormatName(format),
 			bytes.size
 		)
-		hexView.text = if (prefs.showHexDump) hexDump(bytes) else ""
-		if (prevAction !== action) {
-			fab.setImageResource(action.iconResId)
-			if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-				fab.setOnLongClickListener { v ->
-					v.context.toast(action.titleResId)
-					true
+		hexView.showIf(prefs.showHexDump) { v ->
+			v.text = hexDump(bytes)
+		}
+		recreationView.showIf(prefs.showRecreation) { v ->
+			val unmodified: Boolean
+			val content = if (isBinary) {
+				if (bytes.isEmpty()) {
+					clearRecreation()
+					return@showIf
 				}
+				unmodified = bytes.contentEquals(originalBytes)
+				bytes
 			} else {
-				fab.tooltipText = getString(action.titleResId)
+				if (text.isEmpty()) {
+					clearRecreation()
+					return@showIf
+				}
+				unmodified = text == scan.text
+				text
 			}
+			val barcode = if (unmodified) {
+				scan.toBarcode()
+			} else {
+				ContentBarcode(
+					content,
+					scan.format,
+					scan.errorCorrectionLevel.toErrorCorrectionInt()
+				)
+			}
+			try {
+				v.setImageBitmap(barcode.bitmap(recreationSize))
+				v.setOnClickListener {
+					fragmentManager?.addFragment(
+						BarcodeFragment.newInstance(barcode)
+					)
+				}
+			} catch (e: RuntimeException) {
+				clearRecreation()
+			}
+		}
+		dataView.fillDataView(text, bytes)
+		stampView.setTrackingLink(bytes, format)
+	}
+
+	private fun clearRecreation() {
+		recreationView.apply {
+			setImageBitmap(null)
+			setOnClickListener(null)
 		}
 	}
 
-	private fun fillDataView(tableLayout: TableLayout, content: String) {
-		val items = LinkedHashMap<Int, String?>()
+	private fun TableLayout.fillDataView(text: String, bytes: ByteArray) {
+		val items = LinkedHashMap<Int, CharSequence?>()
+		when (prefs.showChecksum) {
+			"CRC4" -> items[R.string.crc4] = String.format("%X", crc4(bytes))
+			"MD5" -> items[R.string.md5] = bytes.md5().toHexString().fold()
+			"SHA1" -> items[R.string.sha1] = bytes.sha1().toHexString().fold()
+			"SHA256" -> items[R.string.sha256] = bytes.sha256().toHexString().fold()
+			else -> Unit
+		}
 		if (action is WifiAction) {
-			WifiConnector.parseMap(content)?.let { wifiData ->
+			WifiConnector.parseMap(text)?.let { wifiData ->
 				items.putAll(
 					linkedMapOf(
 						R.string.entry_type to getString(R.string.wifi_network),
@@ -192,55 +316,75 @@ class DecodeFragment : Fragment() {
 				)
 			}
 		}
-		fillDataTable(tableLayout, items)
+		fill(items)
 	}
 
-	private fun fillMetaView(tableLayout: TableLayout, scan: Scan) {
-		fillDataTable(
-			tableLayout, linkedMapOf(
-				R.string.error_correction_level to scan.errorCorrectionLevel,
-				R.string.issue_number to scan.issueNumber,
-				R.string.orientation to scan.orientation,
-				R.string.other_meta_data to scan.otherMetaData,
-				R.string.pdf417_extra_metadata to scan.pdf417ExtraMetaData,
-				R.string.possible_country to scan.possibleCountry,
-				R.string.suggested_price to scan.suggestedPrice,
-				R.string.upc_ean_extension to scan.upcEanExtension
-			)
+	private fun TableLayout.fillMetaView(scan: Scan) {
+		val items = linkedMapOf<Int, CharSequence?>(
+			R.string.error_correction_level to scan.errorCorrectionLevel,
+			R.string.sequence_size to scan.sequenceSize.positiveToString(),
+			R.string.sequence_index to scan.sequenceIndex.positiveToString(),
+			R.string.sequence_id to scan.sequenceId,
+			R.string.gtin_country to scan.country,
+			R.string.gtin_add_on to scan.addOn,
+			R.string.gtin_price to scan.price,
+			R.string.gtin_issue_number to scan.issueNumber,
 		)
+		if (!scan.version.isNullOrBlank()) {
+			val versionString = if (scan.format.name == "QR_CODE") {
+				getString(
+					R.string.qr_version_and_modules,
+					scan.version,
+					(scan.version.toIntOrNull() ?: 0) * 4 + 17
+				)
+			} else {
+				scan.version
+			}
+			items.putAll(
+				linkedMapOf(
+					R.string.barcode_version_number to versionString
+				)
+			)
+		}
+		if (scan.format == ZxingCpp.BarcodeFormat.QR_CODE &&
+			scan.dataMask > -1
+		) {
+			items.putAll(
+				linkedMapOf(
+					R.string.qr_data_mask to scan.dataMask.toString()
+				)
+			)
+		}
+		fill(items)
 	}
 
-	private fun fillDataTable(
-		tableLayout: TableLayout,
-		items: LinkedHashMap<Int, String?>
+	private fun TableLayout.fill(
+		items: LinkedHashMap<Int, CharSequence?>
 	) {
-		val ctx = tableLayout.context
-		val spaceBetween = (16f * ctx.resources.displayMetrics.density).toInt()
-		items.forEach { item ->
-			val text = item.value
-			if (!text.isNullOrBlank()) {
-				val tr = TableRow(ctx)
-				val keyView = TextView(ctx)
-				keyView.setText(item.key)
-				val valueView = TextView(ctx)
-				valueView.setPadding(spaceBetween, 0, 0, 0)
-				valueView.text = text
-				tr.addView(keyView)
-				tr.addView(valueView)
-				tableLayout.addView(tr)
+		removeAllViews()
+		visibility = if (items.isEmpty()) View.GONE else {
+			val ctx = context
+			val spaceBetween = (16f * dp).roundToInt()
+			items.forEach { item ->
+				val text = item.value
+				if (!text.isNullOrBlank()) {
+					val tr = TableRow(ctx)
+					val keyView = TextView(ctx)
+					keyView.setText(item.key)
+					val valueView = TextView(ctx)
+					valueView.setPadding(spaceBetween, 0, 0, 0)
+					valueView.text = text
+					tr.addView(keyView)
+					tr.addView(valueView)
+					addView(tr)
+				}
 			}
-		}
-		if (tableLayout.childCount > 0) {
-			tableLayout.setPadding(0, 0, 0, spaceBetween)
+			View.VISIBLE
 		}
 	}
 
 	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
 		inflater.inflate(R.menu.fragment_decode, menu)
-		if (isBinary) {
-			menu.findItem(R.id.copy_to_clipboard).isVisible = false
-			menu.findItem(R.id.create).isVisible = false
-		}
 		if (id > 0L) {
 			menu.findItem(R.id.remove).isVisible = true
 		}
@@ -256,11 +400,13 @@ class DecodeFragment : Fragment() {
 				maybeBackOrFinish()
 				true
 			}
+
 			R.id.copy_to_clipboard -> {
 				copyToClipboard(textOrHex())
 				maybeBackOrFinish()
 				true
 			}
+
 			R.id.share -> {
 				context?.apply {
 					shareText(textOrHex())
@@ -268,23 +414,42 @@ class DecodeFragment : Fragment() {
 				}
 				true
 			}
+
+			R.id.share_file -> {
+				context?.apply {
+					val (data, name) = if (isBinary) {
+						Pair(originalBytes, "barcode_content.bin")
+					} else {
+						Pair(content, "barcode_content.txt")
+					}
+					shareAsFile(data, name)
+					maybeBackOrFinish()
+				}
+				true
+			}
+
 			R.id.create -> {
 				fragmentManager?.addFragment(
-					EncodeFragment.newInstance(content, format)
+					EncodeFragment.newInstance(
+						if (isBinary) originalBytes else content,
+						format
+					)
 				)
 				true
 			}
+
 			R.id.remove -> {
 				db.removeScan(id)
 				backOrFinish()
 				true
 			}
+
 			else -> super.onOptionsItemSelected(item)
 		}
 	}
 
 	private fun textOrHex() = if (isBinary) {
-		raw.toHexString()
+		originalBytes.toHexString()
 	} else {
 		content
 	}
@@ -294,16 +459,16 @@ class DecodeFragment : Fragment() {
 		if (ac is WifiAction) {
 			ac.password?.let { password ->
 				activity?.apply {
-					copyToClipboard(password)
+					copyToClipboard(password, isSensitive = true)
 					toast(R.string.copied_password_to_clipboard)
 				}
 			}
 		}
 	}
 
-	private fun copyToClipboard(text: String) {
+	private fun copyToClipboard(text: String, isSensitive: Boolean = false) {
 		activity?.apply {
-			copyToClipboard(text)
+			copyToClipboard(text, isSensitive)
 			toast(R.string.copied_to_clipboard)
 		}
 	}
@@ -323,7 +488,7 @@ class DecodeFragment : Fragment() {
 		}
 	}
 
-	private fun executeAction(content: ByteArray) {
+	private fun executeAction(content: String) {
 		val ac = activity ?: return
 		if (content.isNotEmpty()) {
 			if (action is WifiAction &&
@@ -333,7 +498,7 @@ class DecodeFragment : Fragment() {
 				return
 			}
 			scope.launch {
-				action.execute(ac, content)
+				action.execute(ac, content.toByteArray())
 				maybeBackOrFinish()
 			}
 		}
@@ -349,13 +514,17 @@ class DecodeFragment : Fragment() {
 		}
 		scope.launch(Dispatchers.Main) {
 			val name = ac.askForFileName() ?: return@launch
-			val message = ac.writeExternalFile(
-				name,
-				"application/octet-stream"
-			) {
-				it.write(raw)
-			}.toSaveResult()
-			ac.toast(message)
+			withContext(Dispatchers.IO) {
+				val message = ac.writeExternalFile(
+					name,
+					"application/octet-stream"
+				) {
+					it.write(raw)
+				}.toSaveResult()
+				withContext(Dispatchers.Main) {
+					ac.toast(message)
+				}
+			}
 		}
 	}
 
@@ -372,6 +541,23 @@ class DecodeFragment : Fragment() {
 	}
 }
 
+private inline fun <T : View> T.showIf(
+	visible: Boolean,
+	block: (T) -> Unit
+) {
+	visibility = if (visible) {
+		block.invoke(this)
+		View.VISIBLE
+	} else {
+		View.GONE
+	}
+}
+
+private val nonAlNum = "[^a-zA-Z0-9]".toRegex()
+private val multipleDots = "…+".toRegex()
+private fun String.foldNonAlNum() = replace(nonAlNum, "…")
+	.replace(multipleDots, "…")
+
 private fun hexDump(bytes: ByteArray, charsPerLine: Int = 33): String {
 	if (charsPerLine < 4 || bytes.isEmpty()) {
 		return ""
@@ -410,3 +596,124 @@ private fun hexDump(bytes: ByteArray, charsPerLine: Int = 33): String {
 	}
 	return dump.toString()
 }
+
+private fun Int.positiveToString() = if (this > -1) this.toString() else ""
+
+private fun TextView.setTrackingLink(bytes: ByteArray, format: String) {
+	val trackingLink = generateDpTrackingLink(bytes, format)
+	if (trackingLink != null) {
+		text = trackingLink.fromHtml()
+		isClickable = true
+		movementMethod = LinkMovementMethod.getInstance()
+	} else {
+		visibility = View.GONE
+	}
+}
+
+private fun generateDpTrackingLink(bytes: ByteArray, format: String): String? {
+	// Check for Deutsche Post Matrixcode stamp.
+	var isStamp = false
+	var rawData = bytes
+	if (format == "DATA_MATRIX" &&
+		bytes.toString(Charsets.ISO_8859_1).startsWith("DEA5")
+	) {
+		if (bytes.size == 47) {
+			isStamp = true
+		} else if (bytes.size > 47) {
+			// Transform back to original data.
+			rawData = bytes.toString(Charsets.UTF_8).toByteArray(
+				Charsets.ISO_8859_1
+			)
+			if (rawData.size == 47) {
+				isStamp = true
+			}
+		}
+	}
+
+	if (!isStamp) {
+		return null
+	}
+
+	val hex = StringBuilder()
+	hex.append(String.format("%02X", rawData[9]))
+	hex.append(String.format("%02X", rawData[10]))
+	hex.append(String.format("%02X", rawData[11]))
+	hex.append(String.format("%02X", rawData[12]))
+	hex.append(String.format("%02X", rawData[13]))
+	hex.append(String.format("%X", (rawData[4].toInt() and 0x0f).toByte()))
+	hex.append(String.format("%02X", rawData[5]))
+	hex.append(String.format("%02X", rawData[6]))
+	hex.append(String.format("%02X", rawData[7]))
+	hex.append(String.format("%02X", rawData[8]))
+	val hexString = hex.toString()
+	val trackingNumber = hexString + String.format(
+		"%X",
+		crc4(hexString.toByteArray(Charsets.ISO_8859_1))
+	)
+	return "<a href=\"https://www.deutschepost.de/de/s/sendungsverfolgung.html?piececode=$trackingNumber\">Deutsche Post: $trackingNumber</a>"
+}
+
+// CRC-4 with polynomial x^4 + x + 1.
+private fun crc4(input: ByteArray): Int {
+	var crc = 0
+	var i = 0
+	while (i < input.size) {
+		val c = input[i].toInt()
+		var j = 0x80
+		while (j != 0) {
+			var bit = crc and 0x8
+			crc = crc shl 1
+			if (c and j != 0) {
+				bit = bit xor 0x8
+			}
+			if (bit != 0) {
+				crc = crc xor 0x3
+			}
+			j = j ushr 1
+		}
+		++i
+	}
+	crc = crc and 0xF
+	return crc
+}
+
+private fun String.fromHtml() = if (
+	Build.VERSION.SDK_INT >= Build.VERSION_CODES.N
+) {
+	Html.fromHtml(this, Html.FROM_HTML_MODE_LEGACY)
+} else {
+	@Suppress("DEPRECATION")
+	Html.fromHtml(this)
+}
+
+private fun ByteArray.md5(): ByteArray = MessageDigest.getInstance("MD5").run {
+	update(this@md5)
+	digest()
+}
+
+private fun ByteArray.sha1(): ByteArray = MessageDigest.getInstance("SHA-1").run {
+	update(this@sha1)
+	digest()
+}
+
+private fun ByteArray.sha256(): ByteArray = MessageDigest.getInstance("SHA-256").run {
+	update(this@sha256)
+	digest()
+}
+
+private fun String.fold(): CharSequence {
+	val l = length
+	return if (l > 10) {
+		val half = l / 2
+		val s = substring(0, half) + "\n" + substring(half)
+		SpannableString(s).apply {
+			setSpan(
+				TypefaceSpan("monospace"),
+				0, s.length,
+				Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
+			)
+		}
+	} else {
+		this
+	}
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/EncodeFragment.kt

@@ -1,31 +1,46 @@
 package de.markusfisch.android.binaryeye.fragment
 
+import android.app.Activity
+import android.content.Context
+import android.content.Intent
 import android.os.Bundle
 import android.support.v4.app.Fragment
+import android.support.v7.widget.SwitchCompat
 import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
 import android.view.View
 import android.view.ViewGroup
-import android.widget.*
-import com.google.zxing.BarcodeFormat
-import com.google.zxing.EncodeHintType
-import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.CheckBox
+import android.widget.EditText
+import android.widget.Spinner
+import android.widget.TextView
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.adapter.prettifyFormatName
 import de.markusfisch.android.binaryeye.app.addFragment
 import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.text.unescape
 import de.markusfisch.android.binaryeye.view.hideSoftKeyboard
 import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
-import java.util.*
+import de.markusfisch.android.binaryeye.widget.toast
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
+import java.io.InputStream
+import kotlin.math.min
 
 class EncodeFragment : Fragment() {
 	private lateinit var formatView: Spinner
-	private lateinit var errorCorrectionLabel: TextView
-	private lateinit var errorCorrectionLevel: Spinner
-	private lateinit var sizeView: TextView
-	private lateinit var sizeBarView: SeekBar
+	private lateinit var ecLabel: TextView
+	private lateinit var ecSpinner: Spinner
+	private lateinit var colorsLabel: TextView
+	private lateinit var colorsSpinner: Spinner
+	private lateinit var addQuietZoneSwitch: SwitchCompat
 	private lateinit var contentView: EditText
+	private lateinit var unescapeCheckBox: CheckBox
 
-	private val writers = arrayListOf(
+	private val formats = arrayListOf(
 		BarcodeFormat.AZTEC,
 		BarcodeFormat.CODABAR,
 		BarcodeFormat.CODE_39,
@@ -39,6 +54,37 @@ class EncodeFragment : Fragment() {
 		BarcodeFormat.UPC_A
 	)
 
+	private var minMargin = 0
+	private var bytes: ByteArray? = null
+
+	override fun onActivityResult(
+		requestCode: Int,
+		resultCode: Int,
+		resultData: Intent?
+	) {
+		when (requestCode) {
+			PICK_FILE_RESULT_CODE -> {
+				if (resultCode == Activity.RESULT_OK &&
+					resultData != null &&
+					resultData.data != null
+				) {
+					val ac = activity ?: return
+					ac.hideSoftKeyboard(contentView)
+					val uri = resultData.data ?: return
+					bytes = ac.contentResolver?.openInputStream(uri)?.use {
+						it.readBytesMax(4096)
+					} ?: return
+					setEncodeByteArray()
+				}
+			}
+		}
+	}
+
+	override fun onCreate(state: Bundle?) {
+		super.onCreate(state)
+		setHasOptionsMenu(true)
+	}
+
 	override fun onCreateView(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
@@ -57,7 +103,7 @@ class EncodeFragment : Fragment() {
 		val formatAdapter = ArrayAdapter(
 			ac,
 			android.R.layout.simple_spinner_item,
-			writers.map { prettifyFormatName(it.name) }
+			formats.map { prettifyFormatName(it.name) }
 		)
 		formatAdapter.setDropDownViewResource(
 			android.R.layout.simple_spinner_dropdown_item
@@ -70,38 +116,81 @@ class EncodeFragment : Fragment() {
 				position: Int,
 				id: Long
 			) {
-				val visibility = if (
-					writers[position] == BarcodeFormat.QR_CODE
-				) {
-					View.VISIBLE
-				} else {
-					View.GONE
+				val format = formats[position]
+				val arrayId = when (format) {
+					BarcodeFormat.AZTEC -> R.array.aztec_error_correction_levels
+					BarcodeFormat.QR_CODE -> R.array.qr_error_correction_levels
+					BarcodeFormat.PDF_417 -> R.array.pdf417_error_correction_levels
+					else -> 0
 				}
-				errorCorrectionLabel.visibility = visibility
-				errorCorrectionLevel.visibility = visibility
+				if (arrayId > 0) {
+					ecSpinner.setEntries(arrayId)
+					val idx = format.unpackEcLevel(
+						prefs.indexOfLastSelectedEcLevel
+					)
+					if (idx < ecSpinner.adapter.count) {
+						ecSpinner.setSelection(idx)
+					}
+					true
+				} else {
+					false
+				}.setVisibilityFor(ecLabel, ecSpinner)
+				format.canBeInverted().setVisibilityFor(
+					colorsLabel, colorsSpinner
+				)
+				when (format) {
+					BarcodeFormat.AZTEC,
+					BarcodeFormat.DATA_MATRIX,
+					BarcodeFormat.QR_CODE,
+					BarcodeFormat.PDF_417 -> true
+
+					else -> false
+				}.setVisibilityFor(addQuietZoneSwitch)
 			}
 
 			override fun onNothingSelected(parentView: AdapterView<*>?) {}
 		}
 
-		errorCorrectionLabel = view.findViewById(R.id.error_correction_label)
-		errorCorrectionLevel = view.findViewById(R.id.error_correction_level)
+		ecLabel = view.findViewById(R.id.error_correction_label)
+		ecSpinner = view.findViewById(R.id.error_correction_level)
+		ecSpinner.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+			override fun onItemSelected(
+				parentView: AdapterView<*>?,
+				selectedItemView: View?,
+				position: Int,
+				id: Long
+			) {
+				val format = formats[formatView.selectedItemPosition]
+				prefs.indexOfLastSelectedEcLevel = format.packEcLevel(
+					prefs.indexOfLastSelectedEcLevel,
+					position
+				)
+			}
 
-		sizeView = view.findViewById(R.id.size_display)
-		sizeBarView = view.findViewById(R.id.size_bar)
-		initSizeBar()
+			override fun onNothingSelected(parentView: AdapterView<*>?) {}
+		}
+
+		colorsLabel = view.findViewById(R.id.colors_label)
+		colorsSpinner = view.findViewById(R.id.colors)
+		addQuietZoneSwitch = view.findViewById(R.id.add_quiet_zone)
 
 		contentView = view.findViewById(R.id.content)
+		unescapeCheckBox = view.findViewById(R.id.unescape)
+		unescapeCheckBox.isChecked = prefs.expandEscapeSequences
 
 		val args = arguments
-		args?.also {
-			contentView.setText(it.getString(CONTENT))
+		args?.getString(CONTENT_TEXT)?.let {
+			contentView.setText(it)
+		}
+		args?.getByteArray(CONTENT_RAW)?.let {
+			bytes = it
+			setEncodeByteArray()
 		}
 
 		val barcodeFormat = args?.getString(FORMAT)
 		if (barcodeFormat != null) {
 			formatView.setSelection(
-				writers.indexOf(resolveFormat(barcodeFormat))
+				formats.indexOf(barcodeFormat.toFormat())
 			)
 		} else if (state == null) {
 			formatView.post {
@@ -110,82 +199,125 @@ class EncodeFragment : Fragment() {
 		}
 
 		view.findViewById<View>(R.id.encode).setOnClickListener {
-			encode()
+			it.context.encode()
 		}
 
-		(view.findViewById(R.id.inset_layout) as View).setPaddingFromWindowInsets()
-		(view.findViewById(R.id.scroll_view) as View).setPaddingFromWindowInsets()
+		view.findViewById<View>(R.id.inset_layout).setPaddingFromWindowInsets()
+		view.findViewById<View>(R.id.scroll_view).setPaddingFromWindowInsets()
 
 		return view
 	}
 
+	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+		inflater.inflate(R.menu.fragment_encode, menu)
+	}
+
+	override fun onOptionsItemSelected(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.pick_file -> {
+				startActivityForResult(
+					Intent.createChooser(
+						Intent(Intent.ACTION_GET_CONTENT).apply {
+							type = "*/*"
+						},
+						getString(R.string.pick_file)
+					),
+					PICK_FILE_RESULT_CODE
+				)
+				true
+			}
+
+			else -> super.onOptionsItemSelected(item)
+		}
+	}
+
 	override fun onPause() {
 		super.onPause()
 		prefs.indexOfLastSelectedFormat = formatView.selectedItemPosition
+		prefs.expandEscapeSequences = unescapeCheckBox.isChecked
 	}
 
-	private fun encode() {
-		val hints = EnumMap<EncodeHintType, Any>(EncodeHintType::class.java)
-		val format = writers[formatView.selectedItemPosition]
-		if (format == BarcodeFormat.QR_CODE) {
-			hints[EncodeHintType.ERROR_CORRECTION] = arrayListOf(
-				ErrorCorrectionLevel.L,
-				ErrorCorrectionLevel.M,
-				ErrorCorrectionLevel.Q,
-				ErrorCorrectionLevel.H
-			)[errorCorrectionLevel.selectedItemPosition]
-		}
-		val size = getSize(sizeBarView.progress)
-		val content = contentView.text.toString()
-		if (content.isEmpty()) {
-			Toast.makeText(
-				context,
-				R.string.error_no_content,
-				Toast.LENGTH_SHORT
-			).show()
-		} else {
-			activity?.hideSoftKeyboard(contentView)
-			fragmentManager?.addFragment(
-				BarcodeFragment.newInstance(content, format, size, hints)
+	private fun Context.encode() {
+		hideSoftKeyboard(contentView)
+		val content = getContent() ?: return
+		val format = formats[formatView.selectedItemPosition]
+		fragmentManager?.addFragment(
+			BarcodeFragment.newInstance(
+				content,
+				format,
+				format.getErrorCorrectionLevel(ecSpinner.selectedItemPosition),
+				when (format) {
+					BarcodeFormat.AZTEC,
+					BarcodeFormat.DATA_MATRIX,
+					BarcodeFormat.QR_CODE,
+					BarcodeFormat.PDF_417 -> if (
+						addQuietZoneSwitch.isChecked
+					) 1 else 0
+
+					else -> -1
+				},
+				if (format.canBeInverted()) {
+					colorsSpinner.selectedItemPosition
+				} else 0
 			)
+		)
+	}
+
+	private fun Context.getContent(): Any? {
+		if (bytes != null) {
+			return bytes
+		}
+		var text = contentView.text.toString()
+		if (text.isEmpty()) {
+			toast(R.string.error_no_content)
+			return null
+		}
+		if (!unescapeCheckBox.isChecked) {
+			return text
+		}
+		try {
+			text = text.unescape()
+		} catch (e: IllegalArgumentException) {
+			toast(e.message ?: "Invalid escape sequence")
+			return null
+		}
+		// Return a ByteArray if there were escape sequences for
+		// non-printable characters.
+		return if (text.any { it.code < 32 && it.code !in setOf(9, 10, 13) }) {
+			// Do not expand UTF-8 sequences in binary data.
+			text.toByteArray(Charsets.ISO_8859_1)
+		} else {
+			text
 		}
 	}
 
-	private fun initSizeBar() {
-		updateSize(sizeBarView.progress)
-		sizeBarView.setOnSeekBarChangeListener(
-			object : SeekBar.OnSeekBarChangeListener {
-				override fun onProgressChanged(
-					seekBar: SeekBar,
-					progressValue: Int,
-					fromUser: Boolean
-				) {
-					updateSize(progressValue)
-				}
-
-				override fun onStartTrackingTouch(seekBar: SeekBar) {}
-
-				override fun onStopTrackingTouch(seekBar: SeekBar) {}
-			})
+	private fun setEncodeByteArray() {
+		contentView.text = null
+		contentView.hint = getString(R.string.binary_data)
+		contentView.isEnabled = false
+		unescapeCheckBox.isEnabled = false
 	}
 
-	private fun updateSize(power: Int) {
-		val size = getSize(power)
-		sizeView.text = getString(R.string.width_by_height, size, size)
-	}
-
-	private fun getSize(power: Int) = 128 * (power + 1)
-
 	companion object {
-		private const val CONTENT = "content"
+		private const val CONTENT_TEXT = "content_text"
+		private const val CONTENT_RAW = "content_raw"
 		private const val FORMAT = "format"
+		private const val PICK_FILE_RESULT_CODE = 1
 
-		fun newInstance(
-			content: String,
+		fun <T> newInstance(
+			content: T? = null,
 			format: String? = null
 		): Fragment {
 			val args = Bundle()
-			args.putString(CONTENT, content)
+			content?.let {
+				when (content) {
+					is String -> args.putString(CONTENT_TEXT, content)
+					is ByteArray -> args.putByteArray(CONTENT_RAW, content)
+					else -> throw IllegalArgumentException(
+						"content must be a String or a ByteArray"
+					)
+				}
+			}
 			format?.let { args.putString(FORMAT, it) }
 			val fragment = EncodeFragment()
 			fragment.arguments = args
@@ -194,8 +326,71 @@ class EncodeFragment : Fragment() {
 	}
 }
 
-private fun resolveFormat(name: String): BarcodeFormat = try {
-	BarcodeFormat.valueOf(name)
-} catch (_: IllegalArgumentException) {
-	BarcodeFormat.QR_CODE
+private fun Boolean.setVisibilityFor(vararg views: View) {
+	val visibility = if (this) View.VISIBLE else View.GONE
+	for (view in views) {
+		view.visibility = visibility
+	}
+}
+
+private fun BarcodeFormat.packEcLevel(packed: Int, level: Int): Int {
+	val s = ecLevelShift()
+	return (level shl s) or (packed and (15 shl s).inv())
+}
+
+private fun BarcodeFormat.unpackEcLevel(packed: Int) =
+	(packed shr ecLevelShift()) and 15
+
+private fun BarcodeFormat.ecLevelShift() = when (this) {
+	BarcodeFormat.AZTEC -> 0
+	BarcodeFormat.QR_CODE -> 4
+	BarcodeFormat.PDF_417 -> 8
+	else -> throw IllegalArgumentException("$this does not have error levels")
+}
+
+private fun BarcodeFormat.canBeInverted() = when (this) {
+	BarcodeFormat.AZTEC,
+	BarcodeFormat.DATA_MATRIX,
+	BarcodeFormat.QR_CODE -> true
+
+	else -> false
+}
+
+private fun String.toFormat(default: BarcodeFormat = BarcodeFormat.QR_CODE): BarcodeFormat = try {
+	BarcodeFormat.valueOf(this)
+} catch (_: IllegalArgumentException) {
+	default
+}
+
+private fun BarcodeFormat.getErrorCorrectionLevel(position: Int) = when (this) {
+	BarcodeFormat.AZTEC -> position
+	BarcodeFormat.QR_CODE -> (position + 1) * 2
+	BarcodeFormat.PDF_417 -> position
+	else -> 0
+}.coerceIn(0, 8)
+
+private fun Spinner.setEntries(resId: Int) = ArrayAdapter.createFromResource(
+	this.context,
+	resId,
+	android.R.layout.simple_spinner_item
+).also { aa ->
+	aa.setDropDownViewResource(
+		android.R.layout.simple_spinner_dropdown_item
+	)
+	adapter = aa
+}
+
+private fun InputStream.readBytesMax(max: Int): ByteArray {
+	var offset = 0
+	var remaining = min(available(), max)
+	val result = ByteArray(remaining)
+	while (remaining > 0) {
+		val read = read(result, offset, remaining)
+		if (read < 0) {
+			break
+		}
+		remaining -= read
+		offset += read
+	}
+	return result
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/HistoryFragment.kt

@@ -15,24 +15,43 @@ import android.support.v7.app.AppCompatActivity
 import android.support.v7.view.ActionMode
 import android.support.v7.widget.SearchView
 import android.support.v7.widget.SwitchCompat
-import android.view.*
+import android.view.LayoutInflater
+import android.view.Menu
+import android.view.MenuInflater
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
 import android.widget.EditText
 import android.widget.ListView
 import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.adapter.ScansAdapter
-import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.app.addFragment
+import de.markusfisch.android.binaryeye.app.alertDialog
+import de.markusfisch.android.binaryeye.app.db
+import de.markusfisch.android.binaryeye.app.hasWritePermission
+import de.markusfisch.android.binaryeye.app.prefs
 import de.markusfisch.android.binaryeye.content.copyToClipboard
+import de.markusfisch.android.binaryeye.content.shareAsFile
 import de.markusfisch.android.binaryeye.content.shareText
+import de.markusfisch.android.binaryeye.content.wipeLastShareFile
 import de.markusfisch.android.binaryeye.database.Database
-import de.markusfisch.android.binaryeye.database.getString
 import de.markusfisch.android.binaryeye.database.exportCsv
 import de.markusfisch.android.binaryeye.database.exportDatabase
 import de.markusfisch.android.binaryeye.database.exportJson
+import de.markusfisch.android.binaryeye.database.use
 import de.markusfisch.android.binaryeye.io.askForFileName
 import de.markusfisch.android.binaryeye.io.toSaveResult
-import de.markusfisch.android.binaryeye.view.*
+import de.markusfisch.android.binaryeye.view.lockStatusBarColor
+import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
+import de.markusfisch.android.binaryeye.view.systemBarListViewScrollListener
+import de.markusfisch.android.binaryeye.view.unlockStatusBarColor
+import de.markusfisch.android.binaryeye.view.useVisibility
 import de.markusfisch.android.binaryeye.widget.toast
-import kotlinx.coroutines.*
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 
 class HistoryFragment : Fragment() {
 	private lateinit var useHistorySwitch: SwitchCompat
@@ -51,9 +70,13 @@ class HistoryFragment : Fragment() {
 				R.menu.fragment_history_edit,
 				menu
 			)
-			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP &&
+				// SDK35+ doesn't draw a status bar background anymore.
+				Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM
+			) {
 				lockStatusBarColor()
 				val ac = activity ?: return false
+				@Suppress("DEPRECATION")
 				ac.window.statusBarColor = ContextCompat.getColor(
 					ac,
 					R.color.accent_dark
@@ -76,31 +99,36 @@ class HistoryFragment : Fragment() {
 			val ac = activity ?: return false
 			return when (item.itemId) {
 				R.id.copy_scan -> {
-					scansAdapter?.getSelectedContent()?.let {
+					scansAdapter?.getSelectedContent("\n")?.let {
 						ac.copyToClipboard(it)
 						ac.toast(R.string.copied_to_clipboard)
 					}
 					closeActionMode()
 					true
 				}
-				R.id.edit_scan -> {
-					scansAdapter?.let {
-						askForName(
-							ac,
-							it.selectedScanId,
-							getScanName(it.selectedScanPosition)
+
+				R.id.edit_label -> {
+					scansAdapter?.forSelection { id, position ->
+						ac.askForName(
+							id,
+							scansAdapter?.getName(position),
+							scansAdapter?.getContent(position)
 						)
 					}
 					closeActionMode()
 					true
 				}
+
 				R.id.remove_scan -> {
-					scansAdapter?.let {
-						askToRemoveScan(ac, it.selectedScanId)
+					scansAdapter?.getSelectedIds()?.let {
+						if (it.isNotEmpty()) {
+							ac.askToRemoveScans(it)
+						}
 					}
 					closeActionMode()
 					true
 				}
+
 				else -> false
 			}
 		}
@@ -116,6 +144,7 @@ class HistoryFragment : Fragment() {
 	private var filter: String? = null
 	private var clearListMenuItem: MenuItem? = null
 	private var exportHistoryMenuItem: MenuItem? = null
+	private var shareAsFileMenuItem: MenuItem? = null
 
 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
@@ -138,16 +167,19 @@ class HistoryFragment : Fragment() {
 
 		useHistorySwitch = view.findViewById(
 			R.id.use_history
-		) as SwitchCompat
+		)
 		initHistorySwitch(useHistorySwitch)
 
 		listView = view.findViewById(R.id.scans)
-		listView.setOnItemClickListener { _, _, _, id ->
-			showScan(id)
+		listView.setOnItemClickListener { _, v, position, id ->
+			if (actionMode != null) {
+				scansAdapter?.select(v, id, position)
+			} else {
+				showScan(id)
+			}
 		}
 		listView.setOnItemLongClickListener { _, v, position, id ->
-			v.isSelected = true
-			scansAdapter?.select(id, position)
+			scansAdapter?.select(v, id, position)
 			if (actionMode == null && ac is AppCompatActivity) {
 				actionMode = ac.delegate.startSupportActionMode(
 					actionModeCallback
@@ -159,12 +191,12 @@ class HistoryFragment : Fragment() {
 
 		fab = view.findViewById(R.id.share)
 		fab.setOnClickListener { v ->
-			pickListSeparatorAndShare(v.context)
+			v.context.pickListSeparatorAndShare(false)
 		}
 
 		progressView = view.findViewById(R.id.progress_view)
 
-		(view.findViewById(R.id.inset_layout) as View).setPaddingFromWindowInsets()
+		view.findViewById<View>(R.id.inset_layout).setPaddingFromWindowInsets()
 		listView.setPaddingFromWindowInsets()
 
 		update()
@@ -176,6 +208,7 @@ class HistoryFragment : Fragment() {
 		super.onDestroy()
 		scansAdapter?.changeCursor(null)
 		parentJob.cancel()
+		wipeLastShareFile()
 	}
 
 	override fun onPause() {
@@ -185,10 +218,19 @@ class HistoryFragment : Fragment() {
 
 	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
 		inflater.inflate(R.menu.fragment_history, menu)
-		initSearchView(menu.findItem(R.id.search))
-		menu.setGroupVisible(R.id.scans_available, scansAdapter?.count != 0)
-		clearListMenuItem = menu.findItem(R.id.clear)
-		exportHistoryMenuItem = menu.findItem(R.id.export_history)
+		val searchMenuItem = menu.findItem(R.id.search)
+		initSearchView(searchMenuItem)
+		val visible = scansAdapter?.count != 0
+		searchMenuItem?.isVisible = visible
+		exportHistoryMenuItem = menu.findItem(R.id.export_history)?.apply {
+			isVisible = visible
+		}
+		shareAsFileMenuItem = menu.findItem(R.id.share_as_file)?.apply {
+			isVisible = visible
+		}
+		clearListMenuItem = menu.findItem(R.id.clear)?.apply {
+			isVisible = visible
+		}
 	}
 
 	private fun initSearchView(item: MenuItem?) {
@@ -221,13 +263,20 @@ class HistoryFragment : Fragment() {
 	override fun onOptionsItemSelected(item: MenuItem): Boolean {
 		return when (item.itemId) {
 			R.id.clear -> {
-				askToRemoveScans(context)
+				context.askToRemoveScans()
 				true
 			}
+
 			R.id.export_history -> {
 				askToExportToFile()
 				true
 			}
+
+			R.id.share_as_file -> {
+				context.pickListSeparatorAndShare(true)
+				true
+			}
+
 			else -> super.onOptionsItemSelected(item)
 		}
 	}
@@ -252,7 +301,7 @@ class HistoryFragment : Fragment() {
 			val cursor = db.getScans(filter)
 			withContext(Dispatchers.Main) {
 				val ac = activity ?: return@withContext
-				val hasScans = cursor != null && cursor.count > 0
+				val hasScans = cursor.count > 0
 				if (filter == null) {
 					if (!hasScans) {
 						listView.emptyView = useHistorySwitch
@@ -265,7 +314,7 @@ class HistoryFragment : Fragment() {
 				} else {
 					View.GONE
 				}
-				cursor?.let { cursor ->
+				cursor.let { cursor ->
 					// Close previous cursor.
 					scansAdapter?.also { it.changeCursor(null) }
 					scansAdapter = ScansAdapter(ac, cursor)
@@ -281,6 +330,7 @@ class HistoryFragment : Fragment() {
 	private fun enableMenuItems(enabled: Boolean) {
 		clearListMenuItem?.isEnabled = enabled
 		exportHistoryMenuItem?.isEnabled = enabled
+		shareAsFileMenuItem?.isEnabled = enabled
 	}
 
 	private fun closeActionMode() {
@@ -300,20 +350,22 @@ class HistoryFragment : Fragment() {
 		}
 	}
 
-	private fun getScanName(position: Int): String? {
-		val cursor = scansAdapter?.getItem(position) as Cursor?
-		return cursor?.getString(Database.SCANS_NAME)
-	}
-
 	// Dialogs don't have a parent layout.
 	@SuppressLint("InflateParams")
-	private fun askForName(context: Context, id: Long, text: String?) {
-		val view = LayoutInflater.from(context).inflate(
+	private fun Context.askForName(id: Long, text: String?, content: String?) {
+		val view = LayoutInflater.from(this).inflate(
 			R.layout.dialog_enter_name, null
 		)
 		val nameView = view.findViewById<EditText>(R.id.name)
 		nameView.setText(text)
-		AlertDialog.Builder(context)
+		AlertDialog.Builder(this)
+			.setTitle(
+				if (content.isNullOrEmpty()) {
+					getString(R.string.binary_data)
+				} else {
+					content
+				}
+			)
 			.setView(view)
 			.setPositiveButton(android.R.string.ok) { _, _ ->
 				val name = nameView.text.toString()
@@ -324,11 +376,17 @@ class HistoryFragment : Fragment() {
 			.show()
 	}
 
-	private fun askToRemoveScan(context: Context, id: Long) {
-		AlertDialog.Builder(context)
-			.setMessage(R.string.really_remove_scan)
+	private fun Context.askToRemoveScans(ids: List<Long>) {
+		AlertDialog.Builder(this)
+			.setMessage(
+				if (ids.size > 1) {
+					R.string.really_remove_selected_scans
+				} else {
+					R.string.really_remove_scan
+				}
+			)
 			.setPositiveButton(android.R.string.ok) { _, _ ->
-				db.removeScan(id)
+				ids.forEach { db.removeScan(it) }
 				if (scansAdapter?.count == 1) {
 					updateAndClearFilter()
 				} else {
@@ -340,8 +398,8 @@ class HistoryFragment : Fragment() {
 			.show()
 	}
 
-	private fun askToRemoveScans(context: Context) {
-		AlertDialog.Builder(context)
+	private fun Context.askToRemoveScans() {
+		AlertDialog.Builder(this)
 			.setMessage(
 				if (filter == null) {
 					R.string.really_remove_all_scans
@@ -388,12 +446,12 @@ class HistoryFragment : Fragment() {
 				} ?: return@useVisibility
 				val message = when (delimiter) {
 					"db" -> ac.exportDatabase(name)
-					else -> db.getScansDetailed(filter)?.use {
+					else -> db.getScansDetailed(filter).use {
 						when (delimiter) {
 							"json" -> ac.exportJson(name, it)
 							else -> ac.exportCsv(name, it, delimiter)
 						}
-					} ?: false
+					}
 				}.toSaveResult()
 				withContext(Dispatchers.Main) {
 					ac.toast(message)
@@ -402,32 +460,44 @@ class HistoryFragment : Fragment() {
 		}
 	}
 
-	private fun pickListSeparatorAndShare(context: Context) {
-		val separators = context.resources.getStringArray(
+	private fun Context.pickListSeparatorAndShare(asFile: Boolean) {
+		val separators = resources.getStringArray(
 			R.array.list_separators_values
 		)
-		AlertDialog.Builder(context)
+		AlertDialog.Builder(this)
 			.setTitle(R.string.pick_list_separator)
 			.setItems(R.array.list_separators_names) { _, which ->
-				shareScans(separators[which])
+				shareScans(separators[which], asFile)
 			}
 			.show()
 	}
 
-	private fun shareScans(format: String) = scope.launch {
+	private fun shareScans(format: String, asFile: Boolean) = scope.launch {
 		progressView.useVisibility {
-			var text: String? = null
-			db.getScansDetailed(filter)?.use { cursor ->
+			val selectedIds = scansAdapter?.getSelectedIds()
+			if (selectedIds?.isNotEmpty() == true) {
+				db.getScansDetailed(selectedIds.toLongArray())
+			} else {
+				db.getScansDetailed(filter)
+			}.use { cursor ->
 				val details = format.split(":")
-				text = when (details[0]) {
-					"text" -> cursor.exportText(details[1])
-					"csv" -> cursor.exportCsv(details[1])
-					else -> cursor.exportJson()
+				when (details[0]) {
+					"text" -> Pair(cursor.exportText(details[1]), "txt")
+					"csv" -> Pair(cursor.exportCsv(details[1]), "csv")
+					else -> Pair(cursor.exportJson(), "json")
 				}
-			}
-			text?.let {
-				withContext(Dispatchers.Main) {
-					context.shareText(it)
+			}.let { (text, ext) ->
+				text?.let {
+					withContext(Dispatchers.Main) {
+						if (asFile) {
+							context.shareAsFile(
+								it,
+								String.format("scans.%s", ext)
+							)
+						} else {
+							context.shareText(it)
+						}
+					}
 				}
 			}
 		}

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/NetworkSuggestionsFragment.kt

@@ -0,0 +1,94 @@
+package de.markusfisch.android.binaryeye.fragment
+
+import android.content.Context
+import android.net.wifi.WifiManager
+import android.net.wifi.WifiNetworkSuggestion
+import android.os.Build
+import android.os.Bundle
+import android.support.annotation.RequiresApi
+import android.support.v4.app.Fragment
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ArrayAdapter
+import android.widget.ListView
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
+import de.markusfisch.android.binaryeye.view.systemBarListViewScrollListener
+import de.markusfisch.android.binaryeye.widget.toast
+
+class NetworkSuggestionsFragment : Fragment() {
+	@RequiresApi(Build.VERSION_CODES.R)
+	override fun onCreateView(
+		inflater: LayoutInflater,
+		container: ViewGroup?,
+		state: Bundle?
+	): View? {
+		val ac = activity ?: return null
+		ac.setTitle(R.string.network_suggestions)
+
+		val view = inflater.inflate(
+			R.layout.fragment_network_suggestions,
+			container,
+			false
+		)
+
+		val wm = ac.applicationContext.getSystemService(
+			Context.WIFI_SERVICE
+		) as WifiManager
+		val suggestionArrayAdapter = ArrayAdapter(
+			ac,
+			android.R.layout.simple_list_item_checked,
+			wm.networkSuggestions.map {
+				Suggestion(
+					it.ssid ?: it.toString(),
+					it
+				)
+			}
+		)
+
+		val listView = view.findViewById<ListView>(R.id.suggestions)
+		listView.emptyView = view.findViewById(R.id.no_suggestions)
+		listView.adapter = suggestionArrayAdapter
+		listView.setOnScrollListener(systemBarListViewScrollListener)
+		view.findViewById<View>(R.id.inset_layout).setPaddingFromWindowInsets()
+		listView.setPaddingFromWindowInsets()
+
+		view.findViewById<View>(R.id.remove).setOnClickListener {
+			val removeList = ArrayList<WifiNetworkSuggestion>()
+			val removeFromAdapter = ArrayList<Suggestion>()
+			val checked = listView.checkedItemPositions
+			val size = checked.size()
+			for (i in 0 until size) {
+				if (checked.valueAt(i)) {
+					val pos = checked.keyAt(i)
+					listView.setItemChecked(pos, false)
+					val suggestion = listView.getItemAtPosition(
+						pos
+					) as Suggestion
+					removeList.add(suggestion.suggestion)
+					removeFromAdapter.add(suggestion)
+				}
+			}
+			if (removeList.isNotEmpty()) {
+				removeFromAdapter.forEach {
+					suggestionArrayAdapter.remove(it)
+				}
+				wm.removeNetworkSuggestions(removeList)
+			} else {
+				ac.toast(
+					R.string.clear_network_suggestions_nothing_to_remove
+				)
+			}
+		}
+
+		return view
+	}
+}
+
+private data class Suggestion(
+	val label: String,
+	val suggestion: WifiNetworkSuggestion
+) {
+	override fun toString() = label
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/PreferencesFragment.kt

@@ -16,9 +16,12 @@ import android.support.v7.preference.Preference
 import android.support.v7.preference.PreferenceFragmentCompat
 import android.support.v7.preference.PreferenceGroup
 import de.markusfisch.android.binaryeye.R
-import de.markusfisch.android.binaryeye.actions.wifi.removeNetworkSuggestions
 import de.markusfisch.android.binaryeye.activity.SplashActivity
+import de.markusfisch.android.binaryeye.app.addFragment
+import de.markusfisch.android.binaryeye.app.hasBluetoothPermission
 import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.bluetooth.setBluetoothHosts
+import de.markusfisch.android.binaryeye.media.beepConfirm
 import de.markusfisch.android.binaryeye.preference.UrlPreference
 import de.markusfisch.android.binaryeye.view.setPaddingFromWindowInsets
 import de.markusfisch.android.binaryeye.view.systemBarRecyclerViewScrollListener
@@ -27,53 +30,90 @@ import de.markusfisch.android.binaryeye.widget.toast
 class PreferencesFragment : PreferenceFragmentCompat() {
 	private val changeListener = object : OnSharedPreferenceChangeListener {
 		override fun onSharedPreferenceChanged(
-			sharedPreferences: SharedPreferences,
-			key: String
+			sharedPreferences: SharedPreferences?,
+			key: String?
 		) {
+			key ?: return
 			val preference = findPreference(key) ?: return
 			prefs.update()
-			if (preference.key == "custom_locale") {
-				activity?.restartApp()
-			} else {
-				setSummary(preference)
+			when (preference.key) {
+				"custom_locale" -> activity?.restartApp()
+				"beep_tone_name" -> {
+					beepConfirm()
+					setSummary(preference)
+				}
+
+				"send_scan_bluetooth" -> {
+					if (prefs.sendScanBluetooth &&
+						activity?.hasBluetoothPermission() == false
+					) {
+						prefs.sendScanBluetooth = false
+					}
+					setSummary(preference)
+				}
+
+				else -> setSummary(preference)
 			}
 		}
 	}
 
 	override fun onCreatePreferences(state: Bundle?, rootKey: String?) {
 		addPreferencesFromResource(R.xml.preferences)
-		activity?.setTitle(R.string.preferences)
+		setBluetoothResources()
 		wireClearNetworkPreferences()
 	}
 
+	private fun setBluetoothResources() {
+		if (prefs.sendScanBluetooth &&
+			activity?.hasBluetoothPermission() == true
+		) {
+			setBluetoothHosts(
+				findPreference("send_scan_bluetooth_host") as ListPreference
+			)
+		}
+	}
+
 	private fun wireClearNetworkPreferences() {
-		val pref = findPreference("clear_network_suggestions") ?: return
-		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-			pref.isVisible = false
-		} else {
-			pref.setOnPreferenceClickListener {
-				askToClearNetworkSuggestions(context)
-				true
+		findPreference("clear_network_suggestions").apply {
+			if (Build.VERSION.SDK_INT > Build.VERSION_CODES.Q) {
+				// From R+ we can query past network suggestions and
+				// make them editable.
+				setOnPreferenceClickListener {
+					fragmentManager.addFragment(NetworkSuggestionsFragment())
+					true
+				}
+			} else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
+				// On Q, we can only clear *all* suggestions.
+				// Note that previous versions of this app allowed
+				// adding network suggestions on Q as well, so we
+				// need to keep this option.
+				setOnPreferenceClickListener {
+					context.askToClearNetworkSuggestions()
+					true
+				}
+			} else {
+				// There are no network suggestions below Q.
+				isVisible = false
 			}
 		}
 	}
 
 	@RequiresApi(Build.VERSION_CODES.Q)
-	private fun askToClearNetworkSuggestions(context: Context) {
-		AlertDialog.Builder(context)
+	private fun Context.askToClearNetworkSuggestions() {
+		AlertDialog.Builder(this)
 			.setMessage(R.string.really_remove_all_networks)
 			.setPositiveButton(android.R.string.ok) { _, _ ->
-				clearNetworkSuggestions(context)
+				clearNetworkSuggestions()
 			}
 			.setNegativeButton(android.R.string.cancel) { _, _ -> }
 			.show()
 	}
 
 	@RequiresApi(Build.VERSION_CODES.Q)
-	private fun clearNetworkSuggestions(context: Context) {
-		context.toast(
-			if (
-				removeNetworkSuggestions(context) == WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS
+	private fun Context.clearNetworkSuggestions() {
+		toast(
+			if (removeAllNetworkSuggestions() ==
+				WifiManager.STATUS_NETWORK_SUGGESTIONS_SUCCESS
 			) {
 				R.string.clear_network_suggestions_success
 			} else {
@@ -84,6 +124,7 @@ class PreferencesFragment : PreferenceFragmentCompat() {
 
 	override fun onResume() {
 		super.onResume()
+		activity?.setTitle(R.string.preferences)
 		listView.setPaddingFromWindowInsets()
 		listView.removeOnScrollListener(systemBarRecyclerViewScrollListener)
 		listView.addOnScrollListener(systemBarRecyclerViewScrollListener)
@@ -105,6 +146,12 @@ class PreferencesFragment : PreferenceFragmentCompat() {
 				setTargetFragment(this@PreferencesFragment, 0)
 				show(fm, null)
 			}
+		} else if (preference.key == "send_scan_bluetooth_host") {
+			val ac = activity ?: return
+			if (ac.hasBluetoothPermission()) {
+				setBluetoothHosts(preference as ListPreference)
+			}
+			super.onDisplayPreferenceDialog(preference)
 		} else {
 			super.onDisplayPreferenceDialog(preference)
 		}
@@ -122,9 +169,11 @@ class PreferencesFragment : PreferenceFragmentCompat() {
 			is UrlPreference -> {
 				preference.setSummary(preference.getUrl())
 			}
+
 			is ListPreference -> {
 				preference.setSummary(preference.entry)
 			}
+
 			is MultiSelectListPreference -> {
 				preference.setSummary(
 					preference.values.joinToString(", ") {
@@ -132,6 +181,7 @@ class PreferencesFragment : PreferenceFragmentCompat() {
 					}
 				)
 			}
+
 			is PreferenceGroup -> {
 				setSummaries(preference)
 			}
@@ -152,3 +202,9 @@ private fun Activity.restartApp() {
 	// Restart to begin with an unmodified Locale to follow system settings.
 	Runtime.getRuntime().exit(0)
 }
+
+@RequiresApi(Build.VERSION_CODES.Q)
+private fun Context.removeAllNetworkSuggestions(): Int =
+	(applicationContext.getSystemService(
+		Context.WIFI_SERVICE
+	) as WifiManager).removeNetworkSuggestions(listOf())

app/src/main/kotlin/de/markusfisch/android/binaryeye/fragment/UrlDialogFragment.kt

@@ -9,6 +9,7 @@ import de.markusfisch.android.binaryeye.app.prefs
 import de.markusfisch.android.binaryeye.database.Scan
 import de.markusfisch.android.binaryeye.net.sendAsync
 import de.markusfisch.android.binaryeye.preference.UrlPreference
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
 
 class UrlDialogFragment : PreferenceDialogFragmentCompat() {
 	private var urlView: TextView? = null
@@ -50,15 +51,7 @@ class UrlDialogFragment : PreferenceDialogFragmentCompat() {
 		Scan(
 			"test",
 			null,
-			"none",
-			null,
-			null,
-			null,
-			null,
-			null,
-			null,
-			null,
-			null
+			BarcodeFormat.NONE
 		).sendAsync(url, prefs.sendScanType) { code, body ->
 			textView.text = when {
 				code != null -> "$code"

app/src/main/kotlin/de/markusfisch/android/binaryeye/graphics/BitmapEditor.kt

@@ -49,18 +49,23 @@ private fun calculateInSampleSize(
 	return inSampleSize
 }
 
-fun Bitmap.crop(rect: RectF, rotation: Float) = try {
-	val erected = erect(rotation)
-	val w = erected.width
-	val h = erected.height
+fun Bitmap.crop(
+	rect: RectF,
+	rotation: Float,
+	pivotX: Float,
+	pivotY: Float
+) = try {
+	val b = rotate(rotation, pivotX, pivotY)
+	val w = b.width
+	val h = b.height
 	val x = max(0, (rect.left * w).roundToInt())
 	val y = max(0, (rect.top * h).roundToInt())
 	Bitmap.createBitmap(
-		erected,
+		b,
 		x,
 		y,
-		min(w - x, (rect.right * w).roundToInt() - x),
-		min(h - y, (rect.bottom * h).roundToInt() - y)
+		min(w, (rect.right * w).roundToInt()) - x,
+		min(h, (rect.bottom * h).roundToInt()) - y
 	)
 } catch (e: OutOfMemoryError) {
 	null
@@ -68,9 +73,11 @@ fun Bitmap.crop(rect: RectF, rotation: Float) = try {
 	null
 }
 
-private fun Bitmap.erect(rotation: Float): Bitmap = if (
-	rotation % 360f != 0f
-) {
+private fun Bitmap.rotate(
+	rotation: Float,
+	pivotX: Float,
+	pivotY: Float
+): Bitmap = if (rotation % 360f != 0f) {
 	Bitmap.createBitmap(
 		this,
 		0,
@@ -78,7 +85,7 @@ private fun Bitmap.erect(rotation: Float): Bitmap = if (
 		width,
 		height,
 		Matrix().apply {
-			setRotate(rotation)
+			setRotate(rotation, pivotX, pivotY)
 		},
 		true
 	)

app/src/main/kotlin/de/markusfisch/android/binaryeye/graphics/Colors.kt

@@ -0,0 +1,4 @@
+package de.markusfisch.android.binaryeye.graphics
+
+const val COLOR_BLACK = 0xff000000.toInt()
+const val COLOR_WHITE = 0xffffffff.toInt()

app/src/main/kotlin/de/markusfisch/android/binaryeye/graphics/Mapping.kt

@@ -2,61 +2,87 @@ package de.markusfisch.android.binaryeye.graphics
 
 import android.graphics.Matrix
 import android.graphics.Rect
-import com.google.zxing.ResultPoint
+import android.graphics.RectF
+import de.markusfisch.android.zxingcpp.ZxingCpp.Position
+import kotlin.math.roundToInt
 
-fun mapResultToView(
-	frameWidth: Int,
-	frameHeight: Int,
-	frameOrientation: Int,
-	viewRect: Rect,
-	resultPoints: Array<ResultPoint?>,
-	targetArray: FloatArray
-): Int = getFrameToViewMatrix(
-	frameWidth,
-	frameHeight,
-	frameOrientation,
-	viewRect
-).map(
-	resultPoints,
-	targetArray
+data class FrameMetrics(
+	var width: Int = 0,
+	var height: Int = 0,
+	var orientation: Int = 0
 )
 
-fun getFrameToViewMatrix(
-	frameWidth: Int,
-	frameHeight: Int,
-	frameOrientation: Int,
-	viewRect: Rect
-) = Matrix().apply {
-	// Normalize to frame dimensions for rotation.
-	postScale(
-		1f / frameWidth,
-		1f / frameHeight
-	)
-	// Rotate around center.
-	postRotate(frameOrientation.toFloat(), 0.5f, 0.5f)
-	// Scale up to view size.
-	postScale(viewRect.width().toFloat(), viewRect.height().toFloat())
-	// Apply view displacement.
-	postTranslate(viewRect.left.toFloat(), viewRect.top.toFloat())
+fun Rect.setFrameRoi(
+	frameMetrics: FrameMetrics,
+	viewRect: Rect,
+	viewRoi: Rect
+) {
+	Matrix().apply {
+		// Map ROI from view coordinates to frame coordinates.
+		setTranslate(-viewRect.left.toFloat(), -viewRect.top.toFloat())
+		postScale(1f / viewRect.width(), 1f / viewRect.height())
+		postRotate(-frameMetrics.orientation.toFloat(), .5f, .5f)
+		postScale(frameMetrics.width.toFloat(), frameMetrics.height.toFloat())
+		val frameRoiF = RectF()
+		val viewRoiF = RectF(
+			viewRoi.left.toFloat(),
+			viewRoi.top.toFloat(),
+			viewRoi.right.toFloat(),
+			viewRoi.bottom.toFloat()
+		)
+		mapRect(frameRoiF, viewRoiF)
+		set(
+			frameRoiF.left.roundToInt(),
+			frameRoiF.top.roundToInt(),
+			frameRoiF.right.roundToInt(),
+			frameRoiF.bottom.roundToInt()
+		)
+	}
 }
 
-fun Matrix.map(
-	resultPoints: Array<ResultPoint?>,
-	targetArray: FloatArray
-): Int {
-	val max = targetArray.size
-	var i = 0
-	for (resultPoint in resultPoints) {
-		// Because ZXing apparently returns null in this array sometimes.
-		if (resultPoint == null) {
-			continue
+fun Matrix.setFrameToView(
+	frameMetrics: FrameMetrics,
+	viewRect: Rect,
+	viewRoi: Rect? = null
+) {
+	// Configure this matrix to map points in frame coordinates to
+	// view coordinates.
+	val uprightWidth: Int
+	val uprightHeight: Int
+	when (frameMetrics.orientation) {
+		90, 270 -> {
+			uprightWidth = frameMetrics.height
+			uprightHeight = frameMetrics.width
 		}
-		targetArray[i++] = resultPoint.x
-		targetArray[i++] = resultPoint.y
-		if (i >= max) {
-			break
+
+		else -> {
+			uprightWidth = frameMetrics.width
+			uprightHeight = frameMetrics.height
 		}
 	}
-	mapPoints(targetArray, 0, targetArray, 0, i)
+	setScale(
+		viewRect.width().toFloat() / uprightWidth,
+		viewRect.height().toFloat() / uprightHeight
+	)
+	viewRoi?.let {
+		postTranslate(viewRoi.left.toFloat(), viewRoi.top.toFloat())
+	}
+}
+
+fun Matrix.mapPosition(
+	position: Position,
+	coords: FloatArray
+): Int {
+	var i = 0
+	setOf(
+		position.topLeft,
+		position.topRight,
+		position.bottomRight,
+		position.bottomLeft
+	).forEach {
+		coords[i++] = it.x.toFloat()
+		coords[i++] = it.y.toFloat()
+	}
+	mapPoints(coords)
 	return i
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/graphics/Transparency.kt

@@ -0,0 +1,58 @@
+package de.markusfisch.android.binaryeye.graphics
+
+import android.graphics.Bitmap
+import android.graphics.Canvas
+
+fun Bitmap.fixTransparency(): Bitmap {
+	val result = analyzeTransparency()
+	val cfg = config
+	return if (cfg != null && result.hasTransparentPixels) {
+		val copy = Bitmap.createBitmap(
+			width,
+			height,
+			cfg
+		)
+		Canvas(copy).apply {
+			drawColor(result.backgroundColor)
+			drawBitmap(this@fixTransparency, 0f, 0f, null)
+		}
+		copy
+	} else {
+		this
+	}
+}
+
+private fun Bitmap.analyzeTransparency(): Result {
+	val pixels = IntArray(width * height)
+	getPixels(pixels, 0, width, 0, 0, width, height)
+	var transparent = 0
+	var visible = 0
+	var bright = 0
+	for (pixel in pixels) {
+		val alpha = (pixel shr 24) and 0xff
+		if (alpha < 0xff) {
+			++transparent
+		}
+		if (alpha > 0) {
+			++visible
+			if (
+				((pixel shr 16) and 0xff) +
+				((pixel shr 8) and 0xff) +
+				(pixel and 0xff) > 128
+			) ++bright
+		}
+	}
+	return Result(
+		transparent > 0,
+		if (bright > 0 && visible / bright < 2) {
+			COLOR_BLACK
+		} else {
+			COLOR_WHITE
+		}
+	)
+}
+
+private data class Result(
+	val hasTransparentPixels: Boolean,
+	val backgroundColor: Int
+)

app/src/main/kotlin/de/markusfisch/android/binaryeye/io/FileSaving.kt

@@ -61,7 +61,6 @@ private fun Context.openExternalOutputStream(
 	fileName: String,
 	mimeType: String
 ): OutputStream = if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
-	@Suppress("DEPRECATION")
 	val file = File(
 		Environment.getExternalStoragePublicDirectory(
 			Environment.DIRECTORY_DOWNLOADS

app/src/main/kotlin/de/markusfisch/android/binaryeye/media/Beeps.kt

@@ -0,0 +1,33 @@
+package de.markusfisch.android.binaryeye.media
+
+import android.media.AudioManager
+import android.media.ToneGenerator
+import de.markusfisch.android.binaryeye.app.prefs
+
+private var confirmToneGenerator: ToneGenerator? = null
+private var errorToneGenerator: ToneGenerator? = null
+
+fun beepConfirm() {
+	val tg = confirmToneGenerator ?: ToneGenerator(
+		AudioManager.STREAM_NOTIFICATION,
+		ToneGenerator.MAX_VOLUME
+	)
+	confirmToneGenerator = tg
+	tg.startTone(prefs.beepTone())
+}
+
+fun beepError() {
+	val tg = errorToneGenerator ?: ToneGenerator(
+		AudioManager.STREAM_ALARM,
+		ToneGenerator.MAX_VOLUME
+	)
+	errorToneGenerator = tg
+	tg.startTone(ToneGenerator.TONE_SUP_ERROR, 1000)
+}
+
+fun releaseToneGenerators() {
+	confirmToneGenerator?.release()
+	confirmToneGenerator = null
+	errorToneGenerator?.release()
+	errorToneGenerator = null
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/net/ScanSender.kt

@@ -1,7 +1,6 @@
 package de.markusfisch.android.binaryeye.net
 
-import de.markusfisch.android.binaryeye.app.toHexString
-import de.markusfisch.android.binaryeye.app.urlEncode
+import de.markusfisch.android.binaryeye.content.toHexString
 import de.markusfisch.android.binaryeye.database.Scan
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -34,6 +33,7 @@ private fun Scan.send(url: String, type: String): Response {
 		"1" -> request(
 			url + "?" + asUrlArguments()
 		)
+
 		"2" -> request(url) { con ->
 			con.requestMethod = "POST"
 			con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded")
@@ -42,6 +42,7 @@ private fun Scan.send(url: String, type: String): Response {
 				close()
 			}
 		}
+
 		"3" -> request(url) { con ->
 			con.requestMethod = "POST"
 			con.setRequestProperty("Content-Type", "application/json")
@@ -50,8 +51,9 @@ private fun Scan.send(url: String, type: String): Response {
 				close()
 			}
 		}
+
 		else -> request(
-			url + content.urlEncode()
+			url + text.urlEncode()
 		)
 	}
 }
@@ -65,17 +67,18 @@ private fun Scan.asJson() = JSONObject().apply {
 }
 
 private fun Scan.getMap(): Map<String, String> = mapOf(
-	"content" to content,
+	"content" to text,
 	"raw" to raw?.toHexString(),
-	"format" to format,
+	"format" to format.name,
 	"errorCorrectionLevel" to errorCorrectionLevel,
+	"version" to version,
+	"sequenceSize" to sequenceSize.toString(),
+	"sequenceIndex" to sequenceIndex.toString(),
+	"sequenceId" to sequenceId,
+	"country" to country,
+	"addOn" to addOn,
+	"price" to price,
 	"issueNumber" to issueNumber,
-	"orientation" to orientation,
-	"otherMetaData" to otherMetaData,
-	"pdf417ExtraMetaData" to pdf417ExtraMetaData,
-	"possibleCountry" to possibleCountry,
-	"suggestedPrice" to suggestedPrice,
-	"upcEanExtension" to upcEanExtension,
 	"timestamp" to dateTime
 ).filterNullValues()
 

app/src/main/kotlin/de/markusfisch/android/binaryeye/net/Url.kt

@@ -0,0 +1,10 @@
+package de.markusfisch.android.binaryeye.net
+
+import java.io.UnsupportedEncodingException
+import java.net.URLEncoder
+
+fun String.urlEncode(): String = try {
+	URLEncoder.encode(this, "UTF-8")
+} catch (e: UnsupportedEncodingException) {
+	this
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/os/ScreenBrightness.kt

@@ -0,0 +1,22 @@
+package de.markusfisch.android.binaryeye.os
+
+import android.app.Activity
+import android.view.WindowManager
+
+fun Activity.getScreenBrightness(): Float {
+	val layoutParams = window.attributes
+	return if (layoutParams.screenBrightness == WindowManager.LayoutParams.BRIGHTNESS_OVERRIDE_NONE) {
+		android.provider.Settings.System.getInt(
+			contentResolver,
+			android.provider.Settings.System.SCREEN_BRIGHTNESS
+		) / 255.0f
+	} else {
+		layoutParams.screenBrightness
+	}
+}
+
+fun Activity.setScreenBrightness(brightness: Float) {
+	val layoutParams = window.attributes
+	layoutParams.screenBrightness = brightness
+	window.attributes = layoutParams
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/os/Vibrator.kt

@@ -4,10 +4,8 @@ import android.content.Context
 import android.os.Build
 import android.os.VibrationEffect
 import android.os.Vibrator
-import android.os.VibratorManager
-import de.markusfisch.android.binaryeye.app.prefs
 
-private const val DURATION_IN_MS = 100L
+private const val DURATION_IN_MS = 250L
 
 private val beforeO = Build.VERSION.SDK_INT < Build.VERSION_CODES.O
 private val errorPatternTimings = longArrayOf(
@@ -17,7 +15,9 @@ private val errorPatternAmplitudes = intArrayOf(
 	255, 0, 255, 0, 255
 )
 
-fun Context.getVibrator(): Vibrator = if (
+// On SDK 31 and better, we should ask the `VIBRATOR_MANAGER_SERVICE`
+// for the default vibrator. This was implemented here before:
+/*fun Context.getVibrator(): Vibrator = if (
 	Build.VERSION.SDK_INT < Build.VERSION_CODES.S
 ) {
 	@Suppress("DEPRECATION")
@@ -26,12 +26,18 @@ fun Context.getVibrator(): Vibrator = if (
 	(getSystemService(
 		Context.VIBRATOR_MANAGER_SERVICE
 	) as VibratorManager).defaultVibrator
-}
+}*/
+// But for reasons beyond my interests, using `VIBRATOR_MANAGER_SERVICE`
+// leads to a very cryptic `java.lang.VerifyError: r0/b` on Android 4.
+// This is probably a Proguard/R8 issue, but I don't want to waste more
+// time just to get rid of the deprecation warning. So let's use the old
+// `VIBRATOR_SERVICE` and wait for Google to fix their stuff.
+fun Context.getVibrator(): Vibrator = getSystemService(
+	Context.VIBRATOR_SERVICE
+) as Vibrator
 
 fun Vibrator.vibrate() {
-	if (!prefs.vibrate) {
-		return
-	} else if (beforeO) {
+	if (beforeO) {
 		@Suppress("DEPRECATION")
 		vibrate(DURATION_IN_MS)
 	} else {
@@ -45,9 +51,7 @@ fun Vibrator.vibrate() {
 }
 
 fun Vibrator.error() {
-	if (!prefs.vibrate) {
-		return
-	} else if (beforeO) {
+	if (beforeO) {
 		@Suppress("DEPRECATION")
 		vibrate(errorPatternTimings, -1)
 	} else {

app/src/main/kotlin/de/markusfisch/android/binaryeye/preference/CropHandle.kt

@@ -0,0 +1,44 @@
+package de.markusfisch.android.binaryeye.preference
+
+import android.content.SharedPreferences
+import org.json.JSONObject
+
+data class CropHandle(
+	val active: Boolean = true,
+	val x: Int = -2, // -2 means set default roi.
+	val y: Int = -2,
+	val orientation: Int = 0
+)
+
+fun SharedPreferences.storeCropHandle(
+	name: String,
+	cropHandle: CropHandle
+) {
+	edit().putString(
+		name,
+		JSONObject().apply {
+			put("active", cropHandle.active)
+			put("x", cropHandle.x)
+			put("y", cropHandle.y)
+			put("orientation", cropHandle.orientation)
+		}.toString()
+	).apply()
+}
+
+fun SharedPreferences.restoreCropHandle(
+	name: String,
+	default: CropHandle = CropHandle()
+): CropHandle {
+	val s = getString(name, null) ?: return default
+	return try {
+		val json = JSONObject(s)
+		CropHandle(
+			json.getBoolean("active"),
+			json.getInt("x"),
+			json.getInt("y"),
+			json.getInt("orientation")
+		)
+	} catch (e: Exception) {
+		return default
+	}
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/preference/Preferences.kt

@@ -1,96 +1,72 @@
 package de.markusfisch.android.binaryeye.preference
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.content.SharedPreferences
+import android.media.ToneGenerator
 import android.os.Build
 import android.preference.PreferenceManager
 import android.support.annotation.RequiresApi
+import de.markusfisch.android.binaryeye.activity.CameraActivity
+import de.markusfisch.android.zxingcpp.ZxingCpp.BarcodeFormat
 
 class Preferences {
 	lateinit var preferences: SharedPreferences
 
 	var barcodeFormats = setOf(
-		"AZTEC",
-		"CODABAR",
-		"CODE_39",
-		"CODE_93",
-		"CODE_128",
-		"DATA_MATRIX",
-		"EAN_8",
-		"EAN_13",
-		"ITF",
-		"MAXICODE",
-		"PDF_417",
-		"QR_CODE",
-		"RSS_14",
-		"RSS_EXPANDED",
-		"UPC_A",
-		"UPC_E",
-		"UPC_EAN_EXTENSION"
+		BarcodeFormat.AZTEC.name,
+		BarcodeFormat.CODABAR.name,
+		BarcodeFormat.CODE_39.name,
+		BarcodeFormat.CODE_93.name,
+		BarcodeFormat.CODE_128.name,
+		BarcodeFormat.DATA_BAR.name,
+		BarcodeFormat.DATA_BAR_EXPANDED.name,
+		BarcodeFormat.DATA_MATRIX.name,
+		BarcodeFormat.DX_FILM_EDGE.name,
+		BarcodeFormat.EAN_8.name,
+		BarcodeFormat.EAN_13.name,
+		BarcodeFormat.ITF.name,
+		BarcodeFormat.MAXICODE.name,
+		BarcodeFormat.PDF_417.name,
+		BarcodeFormat.QR_CODE.name,
+		BarcodeFormat.MICRO_QR_CODE.name,
+		BarcodeFormat.RMQR_CODE.name,
+		BarcodeFormat.UPC_A.name,
+		BarcodeFormat.UPC_E.name,
 	)
 		@RequiresApi(Build.VERSION_CODES.HONEYCOMB)
 		set(value) {
 			apply(BARCODE_FORMATS, value)
 			field = value
 		}
-	var cropHandleX = -2 // -2 means set default roi.
-		set(value) {
-			apply(CROP_HANDLE_X, value)
-			field = value
-		}
-	var cropHandleY = -2
-		set(value) {
-			apply(CROP_HANDLE_Y, value)
-			field = value
-		}
-	var cropHandleOrientation = 0
-		set(value) {
-			apply(CROP_HANDLE_ORIENTATION, value)
-			field = value
-		}
-	var showCropHandle = true
-		set(value) {
-			apply(SHOW_CROP_HANDLE, value)
-			field = value
-		}
 	var zoomBySwiping = true
 		set(value) {
 			apply(ZOOM_BY_SWIPING, value)
 			field = value
 		}
-	var autoRotate = false
+	var autoRotate = true
 		set(value) {
-			// Immediately save this setting before it shouldn't change
-			// on the fly while scanning.
-			commit(AUTO_ROTATE, value)
+			apply(AUTO_ROTATE, value)
 			field = value
 		}
 	var tryHarder = false
 		set(value) {
-			// Immediately save this setting because it's only ever read
-			// before the camera is opened.
-			commit(TRY_HARDER, value)
+			apply(TRY_HARDER, value)
 			field = value
 		}
 	var bulkMode = false
 		set(value) {
-			// Immediately save this setting because it's only ever read
-			// before the camera is opened.
-			commit(BULK_MODE, value)
+			apply(BULK_MODE, value)
 			field = value
 		}
 	var bulkModeDelay = "500"
 		set(value) {
-			// Immediately save this setting because it's only ever read
-			// before the camera is opened.
-			commit(BULK_MODE_DELAY, value)
+			apply(BULK_MODE_DELAY, value)
 			field = value
 		}
 	var showToastInBulkMode = true
 		set(value) {
-			// Immediately save this setting because it's only ever read
-			// before the camera is opened.
-			commit(SHOW_TOAST_IN_BULK_MODE, value)
+			apply(SHOW_TOAST_IN_BULK_MODE, value)
 			field = value
 		}
 	var vibrate = true
@@ -98,14 +74,24 @@ class Preferences {
 			apply(VIBRATE, value)
 			field = value
 		}
+	var beep = false
+		set(value) {
+			apply(BEEP, value)
+			field = value
+		}
+	var beepToneName = "tone_prop_beep"
+		set(value) {
+			apply(BEEP_TONE_NAME, value)
+			field = value
+		}
 	var useHistory = false
 		set(value) {
 			apply(USE_HISTORY, value)
 			field = value
 		}
-	var ignoreConsecutiveDuplicates = true
+	var ignoreDuplicatesName = "ignore_consecutive_duplicates"
 		set(value) {
-			apply(IGNORE_CONSECUTIVE_DUPLICATES, value)
+			apply(IGNORE_DUPLICATES_NAME, value)
 			field = value
 		}
 	var copyImmediately = false
@@ -128,6 +114,16 @@ class Preferences {
 			apply(SHOW_HEX_DUMP, value)
 			field = value
 		}
+	var showChecksum = ""
+		set(value) {
+			apply(SHOW_CHECKSUM, value)
+			field = value
+		}
+	var showRecreation = true
+		set(value) {
+			apply(SHOW_RECREATION, value)
+			field = value
+		}
 	var closeAutomatically = false
 		set(value) {
 			apply(CLOSE_AUTOMATICALLY, value)
@@ -143,7 +139,7 @@ class Preferences {
 			apply(OPEN_WITH_URL, value)
 			field = value
 		}
-	var sendScanActive = true
+	var sendScanActive = false
 		set(value) {
 			apply(SEND_SCAN_ACTIVE, value)
 			field = value
@@ -158,9 +154,21 @@ class Preferences {
 			apply(SEND_SCAN_TYPE, value)
 			field = value
 		}
+	var sendScanBluetooth = false
+		set(value) {
+			apply(SEND_SCAN_BLUETOOTH, value)
+			field = value
+		}
+	var sendScanBluetoothHost: String = ""
+		set(value) {
+			apply(SEND_SCAN_BLUETOOTH_HOST, value)
+			field = value
+		}
 	var customLocale: String = ""
 		set(value) {
-			apply(CUSTOM_LOCALE, value)
+			// Make sure this setting is written immediately because
+			// the app is about to restart.
+			commit(CUSTOM_LOCALE, value)
 			field = value
 		}
 	var indexOfLastSelectedFormat: Int = 0
@@ -168,11 +176,24 @@ class Preferences {
 			apply(INDEX_OF_LAST_SELECTED_FORMAT, value)
 			field = value
 		}
-	var forceCompat = false
+	var indexOfLastSelectedEcLevel: Int = 0
 		set(value) {
-			// Since the app may be about to crash when forceCompat is set,
-			// it's necessary to `commit()` this synchronously.
-			commit(FORCE_COMPAT, value)
+			apply(INDEX_OF_LAST_SELECTED_EC_LEVEL, value)
+			field = value
+		}
+	var freeRotation = false
+		set(value) {
+			apply(FREE_ROTATION, value)
+			field = value
+		}
+	var expandEscapeSequences = true
+		set(value) {
+			apply(EXPAND_ESCAPE_SEQUENCES, value)
+			field = value
+		}
+	var brightenScreen = false
+		set(value) {
+			apply(BRIGHTEN_SCREEN, value)
 			field = value
 		}
 
@@ -184,19 +205,16 @@ class Preferences {
 	fun update() {
 		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
 			preferences.getStringSet(BARCODE_FORMATS, barcodeFormats)?.let {
-				barcodeFormats = it
+				barcodeFormats = addFormatsOnUpdate(
+					it,
+					BarcodeFormat.RMQR_CODE,
+					BarcodeFormat.DX_FILM_EDGE
+				)
 			}
 		}
-		cropHandleX = preferences.getInt(CROP_HANDLE_X, cropHandleX)
-		cropHandleY = preferences.getInt(CROP_HANDLE_Y, cropHandleY)
-		cropHandleOrientation = preferences.getInt(
-			CROP_HANDLE_ORIENTATION,
-			cropHandleOrientation
-		)
-		showCropHandle = preferences.getBoolean(
-			SHOW_CROP_HANDLE,
-			showCropHandle
-		)
+
+		migrateCropHandle()
+
 		zoomBySwiping = preferences.getBoolean(ZOOM_BY_SWIPING, zoomBySwiping)
 		autoRotate = preferences.getBoolean(AUTO_ROTATE, autoRotate)
 		tryHarder = preferences.getBoolean(TRY_HARDER, tryHarder)
@@ -210,11 +228,22 @@ class Preferences {
 			showToastInBulkMode
 		)
 		vibrate = preferences.getBoolean(VIBRATE, vibrate)
+		beep = preferences.getBoolean(BEEP, beep)
+		preferences.getString(BEEP_TONE_NAME, beepToneName)?.also {
+			beepToneName = it
+		}
 		useHistory = preferences.getBoolean(USE_HISTORY, useHistory)
-		ignoreConsecutiveDuplicates = preferences.getBoolean(
-			IGNORE_CONSECUTIVE_DUPLICATES,
-			ignoreConsecutiveDuplicates
-		)
+
+		// Map old setting to new one if it wasn't on default value.
+		val ignoreConsecutiveDuplicates = "ignore_consecutive_duplicates"
+		if (!preferences.getBoolean(ignoreConsecutiveDuplicates, true)) {
+			preferences.edit().remove(ignoreConsecutiveDuplicates).apply()
+			ignoreDuplicatesName = "accept_duplicates"
+		}
+
+		preferences.getString(IGNORE_DUPLICATES_NAME, ignoreDuplicatesName)?.also {
+			ignoreDuplicatesName = it
+		}
 		copyImmediately = preferences.getBoolean(
 			COPY_IMMEDIATELY,
 			copyImmediately
@@ -225,6 +254,10 @@ class Preferences {
 		)
 		showMetaData = preferences.getBoolean(SHOW_META_DATA, showMetaData)
 		showHexDump = preferences.getBoolean(SHOW_HEX_DUMP, showHexDump)
+		preferences.getString(SHOW_CHECKSUM, showChecksum)?.also {
+			showChecksum = it
+		}
+		showRecreation = preferences.getBoolean(SHOW_RECREATION, showRecreation)
 		closeAutomatically = preferences.getBoolean(
 			CLOSE_AUTOMATICALLY,
 			closeAutomatically
@@ -245,6 +278,16 @@ class Preferences {
 		preferences.getString(SEND_SCAN_TYPE, sendScanType)?.also {
 			sendScanType = it
 		}
+		sendScanBluetooth = preferences.getBoolean(
+			SEND_SCAN_BLUETOOTH,
+			sendScanBluetooth
+		)
+		preferences.getString(
+			SEND_SCAN_BLUETOOTH_HOST,
+			sendScanBluetoothHost
+		)?.also {
+			sendScanBluetoothHost = it
+		}
 		preferences.getString(CUSTOM_LOCALE, customLocale)?.also {
 			customLocale = it
 		}
@@ -252,23 +295,78 @@ class Preferences {
 			INDEX_OF_LAST_SELECTED_FORMAT,
 			indexOfLastSelectedFormat
 		)
-		forceCompat = preferences.getBoolean(FORCE_COMPAT, forceCompat)
+		indexOfLastSelectedEcLevel = preferences.getInt(
+			INDEX_OF_LAST_SELECTED_EC_LEVEL,
+			indexOfLastSelectedEcLevel
+		)
+		freeRotation = preferences.getBoolean(FREE_ROTATION, freeRotation)
+		expandEscapeSequences = preferences.getBoolean(
+			EXPAND_ESCAPE_SEQUENCES,
+			expandEscapeSequences
+		)
+		brightenScreen = preferences.getBoolean(
+			BRIGHTEN_SCREEN,
+			brightenScreen
+		)
+	}
+
+	private fun addFormatsOnUpdate(
+		restored: Set<String>,
+		vararg formats: BarcodeFormat
+	) = restored.toMutableSet().apply {
+		for (format in formats) {
+			val name = "${format.name}_added"
+			if (!preferences.getBoolean(name, false)) {
+				preferences.edit().putBoolean(name, true).apply()
+				add(format.name)
+			}
+		}
+	}
+
+	private fun migrateCropHandle() {
+		val showCropHandleName = "show_crop_handle"
+		if (!preferences.getBoolean(showCropHandleName, false)) {
+			return;
+		}
+		val def = CropHandle()
+		storeCropHandle(
+			CameraActivity.CAMERA_CROP_HANDLE,
+			CropHandle(
+				true,
+				preferences.getInt("crop_handle_x", def.x),
+				preferences.getInt("crop_handle_y", def.y),
+				preferences.getInt("crop_handle_orientation", def.orientation)
+			)
+		)
+		preferences.edit().putBoolean(showCropHandleName, false).apply()
+	}
+
+	fun restoreCropHandle(
+		name: String
+	) = preferences.restoreCropHandle(name)
+
+	fun storeCropHandle(name: String, cropHandle: CropHandle) {
+		preferences.storeCropHandle(name, cropHandle)
+	}
+
+	fun beepTone() = when (beepToneName) {
+		"tone_cdma_confirm" -> ToneGenerator.TONE_CDMA_CONFIRM
+		"tone_sup_radio_ack" -> ToneGenerator.TONE_SUP_RADIO_ACK
+		"tone_prop_ack" -> ToneGenerator.TONE_PROP_ACK
+		"tone_prop_beep" -> ToneGenerator.TONE_PROP_BEEP
+		"tone_prop_beep2" -> ToneGenerator.TONE_PROP_BEEP2
+		else -> ToneGenerator.TONE_PROP_BEEP
+	}
+
+	fun ignoreDuplicates() = when (ignoreDuplicatesName) {
+		"ignore_consecutive_duplicates" -> IgnoreDuplicates.Consecutive
+		"ignore_any_duplicates" -> IgnoreDuplicates.Any
+		else -> IgnoreDuplicates.Never
 	}
 
 	private fun put(label: String, value: Boolean) =
 		preferences.edit().putBoolean(label, value)
 
-	private fun put(label: String, value: String) =
-		preferences.edit().putString(label, value)
-
-	private fun commit(label: String, value: Boolean) {
-		put(label, value).commit()
-	}
-
-	private fun commit(label: String, value: String) {
-		put(label, value).commit()
-	}
-
 	private fun apply(label: String, value: Boolean) {
 		put(label, value).apply()
 	}
@@ -281,17 +379,22 @@ class Preferences {
 		preferences.edit().putInt(label, value).apply()
 	}
 
+	@SuppressLint("ApplySharedPref")
+	private fun commit(label: String, value: String) {
+		preferences.edit().putString(label, value).commit()
+	}
+
 	@RequiresApi(Build.VERSION_CODES.HONEYCOMB)
 	private fun apply(label: String, value: Set<String>) {
 		preferences.edit().putStringSet(label, value).apply()
 	}
 
 	companion object {
-		private const val BARCODE_FORMATS = "barcode_formats"
-		private const val CROP_HANDLE_X = "crop_handle_x"
-		private const val CROP_HANDLE_Y = "crop_handle_y"
-		private const val CROP_HANDLE_ORIENTATION = "crop_handle_orientation"
-		private const val SHOW_CROP_HANDLE = "show_crop_handle"
+		enum class IgnoreDuplicates {
+			Consecutive, Any, Never
+		}
+
+		private const val BARCODE_FORMATS = "formats"
 		private const val ZOOM_BY_SWIPING = "zoom_by_swiping"
 		private const val AUTO_ROTATE = "auto_rotate"
 		private const val TRY_HARDER = "try_harder"
@@ -299,20 +402,29 @@ class Preferences {
 		private const val BULK_MODE_DELAY = "bulk_mode_delay"
 		private const val SHOW_TOAST_IN_BULK_MODE = "show_toast_in_bulk_mode"
 		private const val VIBRATE = "vibrate"
+		private const val BEEP = "beep"
+		private const val BEEP_TONE_NAME = "beep_tone_name"
 		private const val USE_HISTORY = "use_history"
-		private const val IGNORE_CONSECUTIVE_DUPLICATES = "ignore_consecutive_duplicates"
+		private const val IGNORE_DUPLICATES_NAME = "ignore_duplicates_name"
 		private const val OPEN_IMMEDIATELY = "open_immediately"
 		private const val COPY_IMMEDIATELY = "copy_immediately"
 		private const val SHOW_META_DATA = "show_meta_data"
 		private const val SHOW_HEX_DUMP = "show_hex_dump"
+		private const val SHOW_CHECKSUM = "show_checksum"
+		private const val SHOW_RECREATION = "show_recreation"
 		private const val CLOSE_AUTOMATICALLY = "close_automatically"
 		private const val DEFAULT_SEARCH_URL = "default_search_url"
 		private const val OPEN_WITH_URL = "open_with_url"
 		private const val SEND_SCAN_ACTIVE = "send_scan_active"
 		private const val SEND_SCAN_URL = "send_scan_url"
 		private const val SEND_SCAN_TYPE = "send_scan_type"
+		private const val SEND_SCAN_BLUETOOTH = "send_scan_bluetooth"
+		private const val SEND_SCAN_BLUETOOTH_HOST = "send_scan_bluetooth_host"
 		private const val CUSTOM_LOCALE = "custom_locale"
 		private const val INDEX_OF_LAST_SELECTED_FORMAT = "index_of_last_selected_format"
-		private const val FORCE_COMPAT = "force_compat"
+		private const val INDEX_OF_LAST_SELECTED_EC_LEVEL = "index_of_last_selected_ec_level"
+		private const val FREE_ROTATION = "free_rotation"
+		private const val EXPAND_ESCAPE_SEQUENCES = "expand_escape_sequences"
+		private const val BRIGHTEN_SCREEN = "brighten_screen"
 	}
 }

app/src/main/kotlin/de/markusfisch/android/binaryeye/rs/Analyzer.kt

@@ -1,42 +0,0 @@
-package de.markusfisch.android.binaryeye.rs
-
-import android.graphics.Bitmap
-import android.graphics.Canvas
-import android.support.v8.renderscript.Allocation
-import android.support.v8.renderscript.RenderScript
-
-fun fixTransparency(rs: RenderScript, bitmap: Bitmap?): Bitmap? {
-	bitmap ?: return null
-	val result = analyze(rs, bitmap)
-	return if (result.hasTransparentPixels) {
-		val copy = Bitmap.createBitmap(
-			bitmap.width,
-			bitmap.height,
-			bitmap.config
-		)
-		Canvas(copy).apply {
-			drawColor(result.backgroundColor)
-			drawBitmap(bitmap, 0f, 0f, null)
-		}
-		copy
-	} else {
-		bitmap
-	}
-}
-
-private fun analyze(rs: RenderScript, bitmap: Bitmap): Result {
-	val analyzeScript = ScriptC_analyze(rs)
-	val bitmapAllocation = Allocation.createFromBitmap(rs, bitmap)
-	val result = analyzeScript.reduce_analyze(bitmapAllocation).get()
-	bitmapAllocation.destroy()
-	analyzeScript.destroy()
-	return Result(
-		result.x > 0,
-		if (result.y > 0) 0xff000000.toInt() else 0xffffffff.toInt()
-	)
-}
-
-private data class Result(
-	val hasTransparentPixels: Boolean,
-	val backgroundColor: Int
-)

app/src/main/kotlin/de/markusfisch/android/binaryeye/rs/Preprocessor.kt

@@ -1,156 +0,0 @@
-package de.markusfisch.android.binaryeye.rs
-
-import android.graphics.Rect
-import android.support.v8.renderscript.*
-import kotlin.math.max
-import kotlin.math.roundToInt
-
-private const val SCALE_FACTOR = .75f
-
-class Preprocessor(
-	rs: RenderScript,
-	width: Int,
-	height: Int,
-	private val roi: Rect?
-) {
-	var outWidth = 0
-	var outHeight = 0
-
-	private val resizeScript = ScriptIntrinsicResize.create(rs)
-	private val rotateScript = ScriptC_rotate(rs)
-
-	private var yuvType: Type? = null
-	private var yuvAlloc: Allocation? = null
-	private var roiType: Type? = null
-	private var roiAlloc: Allocation? = null
-	private var resizedType: Type? = null
-	private var resizedAlloc: Allocation? = null
-	private var rotatedType: Type? = null
-	private var rotatedAlloc: Allocation? = null
-
-	init {
-		yuvType = Type.createXY(
-			rs,
-			Element.U8(rs),
-			width,
-			height // use only grayscale part
-		)
-		yuvAlloc = Allocation.createTyped(
-			rs,
-			yuvType,
-			Allocation.USAGE_SCRIPT
-		)
-
-		if (roi != null) {
-			val roiWidth = roi.width()
-			val roiHeight = roi.height()
-
-			roiType = Type.createXY(
-				rs,
-				Element.U8(rs),
-				roiWidth,
-				roiHeight
-			)
-			roiAlloc = Allocation.createTyped(
-				rs,
-				roiType,
-				Allocation.USAGE_SCRIPT
-			)
-
-			outWidth = (roiWidth * SCALE_FACTOR).roundToInt()
-			outHeight = (roiHeight * SCALE_FACTOR).roundToInt()
-
-			// Make sure the dimensions are always a multiple of 4.
-			outWidth -= outWidth % 4
-			outHeight -= outHeight % 4
-
-			// Make sure the dimensions are always greater than 4.
-			outWidth = max(4, outWidth)
-			outHeight = max(4, outHeight)
-		} else {
-			outWidth = (width * SCALE_FACTOR).roundToInt()
-			outHeight = (height * SCALE_FACTOR).roundToInt()
-		}
-
-		resizedType = Type.createXY(
-			rs,
-			Element.U8(rs),
-			outWidth,
-			outHeight
-		)
-		resizedAlloc = Allocation.createTyped(
-			rs,
-			resizedType,
-			Allocation.USAGE_SCRIPT
-		)
-
-		rotatedType = Type.createXY(
-			rs,
-			Element.U8(rs),
-			outHeight,
-			outWidth
-		)
-		rotatedAlloc = Allocation.createTyped(
-			rs,
-			rotatedType,
-			Allocation.USAGE_SCRIPT
-		)
-	}
-
-	fun destroy() {
-		yuvType?.destroy()
-		yuvType = null
-		yuvAlloc?.destroy()
-		yuvAlloc = null
-		roiType?.destroy()
-		roiType = null
-		roiAlloc?.destroy()
-		roiAlloc = null
-		resizedType?.destroy()
-		resizedType = null
-		resizedAlloc?.destroy()
-		resizedAlloc = null
-		rotatedType?.destroy()
-		rotatedType = null
-		rotatedAlloc?.destroy()
-		rotatedAlloc = null
-		resizeScript.destroy()
-		rotateScript.destroy()
-	}
-
-	fun resizeOnly(frame: ByteArray) {
-		resize(frame)
-		resizedAlloc?.copyTo(frame)
-	}
-
-	fun resizeAndRotate(frame: ByteArray) {
-		resize(frame)
-		val t = resizedType ?: return
-		rotateScript._inImage = resizedAlloc
-		rotateScript._inWidth = t.x
-		rotateScript._inHeight = t.y
-		rotateScript.forEach_rotate90(
-			rotatedAlloc, // Ignored in kernel, just to satisfy forEach.
-			rotatedAlloc
-		)
-		rotatedAlloc?.copyTo(frame)
-	}
-
-	private fun resize(frame: ByteArray) {
-		yuvAlloc?.copyFrom(frame)
-		resizeScript.setInput(
-			if (roi != null) {
-				roiAlloc?.copy2DRangeFrom(
-					0, 0,
-					roi.width(), roi.height(),
-					yuvAlloc,
-					max(0, roi.left), max(0, roi.top)
-				)
-				roiAlloc
-			} else {
-				yuvAlloc
-			}
-		)
-		resizeScript.forEach_bicubic(resizedAlloc)
-	}
-}

app/src/main/kotlin/de/markusfisch/android/binaryeye/service/ScanTileService.kt

@@ -1,5 +1,7 @@
 package de.markusfisch.android.binaryeye.service
 
+import android.annotation.SuppressLint
+import android.app.PendingIntent
 import android.content.Intent
 import android.os.Build
 import android.service.quicksettings.TileService
@@ -8,11 +10,25 @@ import de.markusfisch.android.binaryeye.activity.CameraActivity
 
 @RequiresApi(Build.VERSION_CODES.N)
 class ScanTileService : TileService() {
-	@RequiresApi(Build.VERSION_CODES.N)
 	override fun onClick() {
 		super.onClick()
 		val intent = Intent(applicationContext, CameraActivity::class.java)
 		intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK
-		startActivityAndCollapse(intent)
+		// TileService#startActivityAndCollapse(Intent) is only ever run
+		// below UpsideDownCake, but Lint doesn't understand this yet.
+		@SuppressLint("StartActivityAndCollapseDeprecated")
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+			@Suppress("DEPRECATION")
+			startActivityAndCollapse(intent)
+		} else {
+			startActivityAndCollapse(
+				PendingIntent.getActivity(
+					this,
+					0,
+					intent,
+					PendingIntent.FLAG_IMMUTABLE
+				)
+			)
+		}
 	}
-}
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/text/Escape.kt

@@ -0,0 +1,82 @@
+package de.markusfisch.android.binaryeye.text
+
+/**
+ * Copyright (c) 2000, Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// This code is based on Google's own implementation:
+// http://www.java2s.com/example/android-utility-method/string-escape/javascriptunescape-string-s-dc359.html
+fun String.unescape(): String {
+	val len = length
+	var i = 0
+	fun String.expand() = when (val ec = get(i++)) {
+		'n' -> '\n'
+		'r' -> '\r'
+		't' -> '\t'
+		'b' -> '\b'
+		'\\', '\"', '\'', '<', '>', '|' -> ec
+		'0', '1', '2', '3', '4', '5', '6', '7' -> {
+			val limit = if (ec < '4') 3 else 2
+			var l = 1
+			--i // Back to index of first digit.
+			while (l < limit &&
+				i + l < len &&
+				get(i + l) in '0'..'7'
+			) {
+				++l
+			}
+			val from = i
+			i += l
+			substring(from, i).toInt(8).toChar()
+		}
+
+		'x', 'u' -> {
+			val l = if (ec == 'u') 4 else 2
+			val hexCode = try {
+				substring(i, i + l)
+			} catch (_: IndexOutOfBoundsException) {
+				throw IllegalArgumentException(
+					"Invalid unicode sequence [${substring(i)}] at index $i"
+				)
+			}
+			val unicodeValue = try {
+				hexCode.toInt(16)
+			} catch (_: NumberFormatException) {
+				throw IllegalArgumentException(
+					"Invalid unicode sequence [$hexCode] at index $i"
+				)
+			}
+			i += l
+			unicodeValue.toChar()
+		}
+
+		else -> throw IllegalArgumentException(
+			"Unknown escape code [$ec] at index $i"
+		)
+	}
+
+	val sb = StringBuilder()
+	while (i < len) {
+		val ch = get(i++)
+		sb.append(
+			if (ch == '\\' && i < len) {
+				expand()
+			} else {
+				ch
+			}
+		)
+	}
+	return sb.toString()
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/view/ScanFeedback.kt

@@ -0,0 +1,38 @@
+package de.markusfisch.android.binaryeye.view
+
+import android.content.Context
+import android.media.AudioManager
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.media.beepConfirm
+import de.markusfisch.android.binaryeye.media.beepError
+import de.markusfisch.android.binaryeye.os.error
+import de.markusfisch.android.binaryeye.os.getVibrator
+import de.markusfisch.android.binaryeye.os.vibrate
+
+fun Context.scanFeedback() {
+	if (prefs.vibrate) {
+		getVibrator().vibrate()
+	}
+	if (prefs.beep && !isSilent()) {
+		beepConfirm()
+	}
+}
+
+fun Context.errorFeedback() {
+	if (prefs.vibrate) {
+		getVibrator().error()
+	}
+	if (prefs.beep && !isSilent()) {
+		beepError()
+	}
+}
+
+private fun Context.isSilent(): Boolean {
+	val am = getSystemService(Context.AUDIO_SERVICE) as AudioManager
+	return when (am.ringerMode) {
+		AudioManager.RINGER_MODE_SILENT,
+		AudioManager.RINGER_MODE_VIBRATE -> true
+
+		else -> false
+	}
+}

app/src/main/kotlin/de/markusfisch/android/binaryeye/view/SystemBars.kt

@@ -8,6 +8,7 @@ import android.support.v4.content.ContextCompat
 import android.support.v7.app.AppCompatActivity
 import android.support.v7.widget.LinearLayoutManager
 import android.support.v7.widget.RecyclerView
+import android.support.v7.widget.Toolbar
 import android.view.View
 import android.view.WindowManager
 import android.widget.AbsListView
@@ -57,10 +58,9 @@ private fun lastChildOutOfView(listView: AbsListView): Boolean {
 	return child != null && child.bottom >= listView.height
 }
 
-fun initSystemBars(activity: AppCompatActivity) {
+fun AppCompatActivity.initBars() {
 	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
 		// Keeps the soft keyboard from repositioning the layout.
-		val window = activity.window
 		window.setSoftInputMode(
 			WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE
 		)
@@ -69,7 +69,16 @@ fun initSystemBars(activity: AppCompatActivity) {
 					View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
 					View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
 	}
-	colorSystemAndToolBars(activity)
+	colorSystemAndToolBars(this)
+	setPaddingFromWindowInsets(
+		findViewById(R.id.main),
+		(findViewById(R.id.toolbar) as Toolbar).apply {
+			setSupportActionBar(this)
+		},
+		findViewById(R.id.navbar)?.apply {
+			setBackgroundColor(translucentPrimaryColor)
+		}
+	)
 }
 
 private var statusBarColorLocked = false
@@ -97,14 +106,27 @@ fun colorSystemAndToolBars(
 	val topColor = if (scrolled) translucentPrimaryColor else 0
 	val activity = getAppCompatActivity(context) ?: return
 	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
-		val window = activity.window
-		if (!statusBarColorLocked) {
-			window.statusBarColor = topColor
-		}
-		window.navigationBarColor = if (scrolled || scrollable) {
-			translucentPrimaryColor
+		// System bars no longer have a background from SDK35+.
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+			val window = activity.window
+			if (!statusBarColorLocked) {
+				@Suppress("DEPRECATION")
+				window.statusBarColor = topColor
+			}
+			@Suppress("DEPRECATION")
+			window.navigationBarColor = if (scrolled || scrollable) {
+				translucentPrimaryColor
+			} else {
+				0
+			}
 		} else {
-			0
+			activity.findViewById(R.id.navbar)?.apply {
+				visibility = if (scrolled || scrollable) {
+					View.VISIBLE
+				} else {
+					View.GONE
+				}
+			}
 		}
 	}
 	activity.supportActionBar?.setBackgroundDrawable(

app/src/main/kotlin/de/markusfisch/android/binaryeye/view/WindowInsets.kt

@@ -7,10 +7,37 @@ import android.support.v4.view.ViewCompat
 import android.support.v4.view.WindowInsetsCompat
 import android.support.v7.widget.Toolbar
 import android.view.View
+import android.view.WindowInsets
 
 private var toolbarHeight = 0
-fun recordToolbarHeight(toolbar: Toolbar) {
+fun setPaddingFromWindowInsets(mainLayout: View, toolbar: Toolbar, navbar: View?) {
 	toolbarHeight = toolbar.layoutParams.height
+	// SDK 35+ is edge-to-edge by default, so the toolbar needs to extend
+	// below the status bar.
+	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.VANILLA_ICE_CREAM) {
+		return
+	}
+	mainLayout.setOnApplyWindowInsetsListener { _, insets ->
+		val systemBarInsets = insets.getInsets(
+			WindowInsets.Type.systemBars()
+		)
+
+		val statusBarTop = systemBarInsets.top
+		if (toolbar.paddingTop == 0 && statusBarTop > 0) {
+			toolbar.setPadding(0, statusBarTop, 0, 0)
+			toolbar.layoutParams.height += statusBarTop
+		}
+
+		val navBarBottom = systemBarInsets.bottom
+		if (navBarBottom > 0) {
+			mainLayout.setPadding(0, 0, 0, navBarBottom);
+			navbar?.apply {
+				layoutParams.height = navBarBottom
+			}
+		}
+
+		insets
+	}
 }
 
 fun View.setPaddingFromWindowInsets() {

app/src/main/kotlin/de/markusfisch/android/binaryeye/widget/DetectorView.kt

@@ -2,7 +2,12 @@ package de.markusfisch.android.binaryeye.widget
 
 import android.annotation.SuppressLint
 import android.content.Context
-import android.graphics.*
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Path
+import android.graphics.Point
+import android.graphics.Rect
+import android.graphics.Region
 import android.os.Build
 import android.os.Parcel
 import android.os.Parcelable
@@ -14,6 +19,7 @@ import de.markusfisch.android.binaryeye.R
 import de.markusfisch.android.binaryeye.app.prefs
 import de.markusfisch.android.binaryeye.graphics.getBitmapFromDrawable
 import de.markusfisch.android.binaryeye.graphics.getDashedBorderPaint
+import de.markusfisch.android.binaryeye.preference.CropHandle
 import kotlin.math.abs
 import kotlin.math.max
 import kotlin.math.min
@@ -53,6 +59,7 @@ class DetectorView : View {
 	private val padding: Int
 
 	private var coordinatesLast = 0
+	private var showCropHandle = true
 	private var handleGrabbed = false
 	private var handleActive = false
 	private var minY = 0
@@ -78,11 +85,17 @@ class DetectorView : View {
 	constructor(context: Context, attrs: AttributeSet, defStyleAttr: Int) :
 			super(context, attrs, defStyleAttr)
 
-	fun saveCropHandlePos() {
+	fun storeCropHandlePos(name: String) {
 		val pos = getCropHandlePos()
-		prefs.cropHandleX = pos.x
-		prefs.cropHandleY = pos.y
-		prefs.cropHandleOrientation = currentOrientation
+		prefs.storeCropHandle(
+			name,
+			CropHandle(
+				showCropHandle,
+				pos.x,
+				pos.y,
+				currentOrientation
+			)
+		)
 	}
 
 	private fun getCropHandlePos() = if (handleActive) {
@@ -91,23 +104,26 @@ class DetectorView : View {
 		Point(-1, -1)
 	}
 
-	fun restoreCropHandlePos() {
+	fun restoreCropHandlePos(name: String) {
+		val cropHandle = prefs.restoreCropHandle(name)
+		showCropHandle = cropHandle.active
 		setCropHandlePos(
-			prefs.cropHandleX,
-			prefs.cropHandleY,
-			prefs.cropHandleOrientation
+			cropHandle.x,
+			cropHandle.y,
+			cropHandle.orientation
 		)
 	}
 
 	private fun setCropHandlePos(x: Int, y: Int, orientation: Int) {
+		// Always set handlePos even if it's invalid because
+		// handlePos.x may be -2 which is a signal to set the
+		// default ROI.
 		if (orientation == currentOrientation) {
 			handlePos.set(x, y)
 		} else {
 			handlePos.set(y, x)
 		}
-		if (x > -1) {
-			handleActive = true
-		}
+		handleActive = handlePos.x > -1
 	}
 
 	fun update(numberOfCoordinates: Int) {
@@ -149,7 +165,7 @@ class DetectorView : View {
 		val y = event.y.roundToInt()
 		return when (event.actionMasked) {
 			MotionEvent.ACTION_DOWN -> {
-				if (prefs.showCropHandle) {
+				if (showCropHandle) {
 					touchDown.set(x, y)
 					handleGrabbed = abs(x - handlePos.x) < handleXRadius &&
 							abs(y - handlePos.y) < handleYRadius
@@ -161,11 +177,12 @@ class DetectorView : View {
 					false
 				}
 			}
+
 			MotionEvent.ACTION_MOVE -> {
 				if (handleGrabbed) {
 					handlePos.set(x, y)
-					handleActive =
-						handleActive or (distSq(handlePos, touchDown) > minMoveThresholdSq)
+					handleActive = handleActive ||
+							distSq(handlePos, touchDown) > minMoveThresholdSq
 					if (handleActive) {
 						updateClipRect()
 						invalidate()
@@ -175,6 +192,7 @@ class DetectorView : View {
 					false
 				}
 			}
+
 			MotionEvent.ACTION_CANCEL -> {
 				if (handleGrabbed) {
 					snap(x, y)
@@ -182,6 +200,7 @@ class DetectorView : View {
 				}
 				false
 			}
+
 			MotionEvent.ACTION_UP -> {
 				if (handleGrabbed) {
 					if (!handleActive) {
@@ -198,6 +217,7 @@ class DetectorView : View {
 				}
 				false
 			}
+
 			else -> super.onTouchEvent(event)
 		}
 	}
@@ -216,10 +236,10 @@ class DetectorView : View {
 		val cy = clampY(y)
 		val dx = abs(cx - center.x)
 		val dy = abs(cy - center.y)
-		// check if handle is close to the vertical or horizontal center line
+		// Check if handle is close to the vertical or horizontal center line.
 		if (dx < distToFull ||
 			dy < distToFull ||
-			// check if handle is close to a screen corner
+			// Check if handle is close to a screen corner.
 			((abs(cy - minY) < distToFull || abs(maxY - cy) < distToFull) &&
 					abs(dx - center.x) < distToFull)
 		) {
@@ -260,23 +280,18 @@ class DetectorView : View {
 
 	override fun onDraw(canvas: Canvas) {
 		if (handleActive) {
-			drawClip(canvas)
+			canvas.drawClip()
 		}
-		drawDots(canvas)
-		if (prefs.showCropHandle) {
-			canvas.drawBitmap(
-				handleBitmap,
-				(handlePos.x - handleXRadius).toFloat(),
-				(handlePos.y - handleYRadius).toFloat(),
-				null
-			)
+		canvas.drawDots()
+		if (showCropHandle) {
+			canvas.drawHandle()
 		}
 	}
 
-	private fun drawDots(canvas: Canvas) {
+	private fun Canvas.drawDots() {
 		var i = 0
 		while (i < coordinatesLast) {
-			canvas.drawCircle(
+			drawCircle(
 				coordinates[i++],
 				coordinates[i++],
 				dotRadius,
@@ -285,15 +300,15 @@ class DetectorView : View {
 		}
 	}
 
-	private fun drawClip(canvas: Canvas) {
+	private fun Canvas.drawClip() {
 		if (minDist < 1) {
 			return
 		}
 		// canvas.clipRect() doesn't work reliably below KITKAT.
 		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
 			val radius = min(minDist / 2, cornerRadius).toFloat()
-			canvas.save()
-			canvas.clipOutPathCompat(
+			save()
+			clipOutPathCompat(
 				calculateRoundedRectPath(
 					roi.left.toFloat(),
 					roi.top.toFloat(),
@@ -303,13 +318,22 @@ class DetectorView : View {
 					radius
 				)
 			)
-			canvas.drawColor(shadeColor)
-			canvas.restore()
+			drawColor(shadeColor)
+			restore()
 		} else {
-			canvas.drawRect(roi, roiPaint)
+			drawRect(roi, roiPaint)
 		}
 	}
 
+	private fun Canvas.drawHandle() {
+		drawBitmap(
+			handleBitmap,
+			(handlePos.x - handleXRadius).toFloat(),
+			(handlePos.y - handleYRadius).toFloat(),
+			null
+		)
+	}
+
 	private fun updateClipRect() {
 		clampHandlePos()
 		val dx = abs(handlePos.x - center.x)

app/src/main/kotlin/de/markusfisch/android/binaryeye/widget/Toast.kt

@@ -3,19 +3,29 @@ package de.markusfisch.android.binaryeye.widget
 import android.content.Context
 import android.widget.Toast
 
-fun Context.toast(message: Int) = Toast.makeText(
-	applicationContext,
-	message,
-	Toast.LENGTH_LONG
-).show()
+private var lastToast: Toast? = null
 
-fun Context.toast(message: String) = Toast.makeText(
-	applicationContext,
-	message.ellipsize(128),
-	Toast.LENGTH_LONG
-).show()
+fun <T> Context.toast(message: T) {
+	lastToast?.cancel()
+	lastToast = when (message) {
+		is String -> Toast.makeText(
+			applicationContext,
+			message.ellipsize(),
+			Toast.LENGTH_LONG
+		)
 
-private fun String.ellipsize(max: Int) = if (length < max) {
+		is Int -> Toast.makeText(
+			applicationContext,
+			message,
+			Toast.LENGTH_LONG
+		)
+
+		else -> return
+	}
+	lastToast?.show()
+}
+
+private fun String.ellipsize(max: Int = 128) = if (length < max) {
 	this
 } else {
 	"${take(max)}…"

app/src/main/kotlin/de/markusfisch/android/binaryeye/zxing/Zxing.kt

@@ -1,201 +0,0 @@
-package de.markusfisch.android.binaryeye.zxing
-
-import android.graphics.Bitmap
-import com.google.zxing.*
-import com.google.zxing.common.BitMatrix
-import com.google.zxing.common.HybridBinarizer
-import java.util.*
-
-class Zxing(possibleResultPoint: ResultPointCallback? = null) {
-	private val hints = EnumMap<DecodeHintType, Any>(DecodeHintType::class.java)
-	private val multiFormatReader = MultiFormatReader()
-
-	init {
-		possibleResultPoint?.let {
-			hints[DecodeHintType.NEED_RESULT_POINT_CALLBACK] = it
-		}
-	}
-
-	fun updateHints(tryHarder: Boolean, formats: Set<String>) {
-		if (tryHarder) {
-			hints[DecodeHintType.TRY_HARDER] = java.lang.Boolean.TRUE
-		} else {
-			hints.remove(DecodeHintType.TRY_HARDER)
-		}
-		setDecodeFormats(formats)
-	}
-
-	private fun setDecodeFormats(formats: Set<String>) {
-		hints[DecodeHintType.POSSIBLE_FORMATS] = EnumSet.noneOf(
-			BarcodeFormat::class.java
-		).apply {
-			addAll(
-				EnumSet.copyOf(
-					formats.map { BarcodeFormat.valueOf(it) }
-				)
-			)
-		}
-	}
-
-	fun decode(
-		yuvData: ByteArray,
-		width: Int,
-		height: Int,
-		invert: Boolean = false
-	): Result? = decodeLuminanceSource(
-		PlanarYUVLuminanceSource(
-			yuvData,
-			width,
-			height,
-			0,
-			0,
-			width,
-			height,
-			false
-		),
-		invert
-	)
-
-	fun decodePositiveNegative(bitmap: Bitmap): Result? =
-		decode(bitmap, false) ?: decode(bitmap, true)
-
-	private fun decode(
-		bitmap: Bitmap,
-		invert: Boolean = false
-	): Result? {
-		val width = bitmap.width
-		val height = bitmap.height
-		val pixels = IntArray(width * height)
-		if (bitmap.config != Bitmap.Config.ARGB_8888) {
-			bitmap.copy(Bitmap.Config.ARGB_8888, true)
-		} else {
-			bitmap
-		}.getPixels(pixels, 0, width, 0, 0, width, height)
-		return decodeLuminanceSource(
-			RGBLuminanceSource(width, height, pixels),
-			invert
-		)
-	}
-
-	private fun decodeLuminanceSource(
-		source: LuminanceSource,
-		invert: Boolean
-	): Result? = decodeLuminanceSource(
-		if (invert) {
-			source.invert()
-		} else {
-			source
-		}
-	)
-
-	private fun decodeLuminanceSource(source: LuminanceSource): Result? = try {
-		multiFormatReader.decode(
-			BinaryBitmap(HybridBinarizer(source)),
-			hints
-		)
-	} catch (e: Exception) {
-		// Usually it's bad practice to blindly catch *all* exceptions
-		// because this can hide problems we want to know about. But
-		// since ZXing has some errors (like all software) and I don't
-		// want this app to break in the hands of my users, which won't
-		// see the stack trace anyway, it's better to just catch all
-		// exceptions here and live on.
-		null
-	} finally {
-		multiFormatReader.reset()
-	}
-}
-
-private const val BLACK = 0xff000000.toInt()
-private const val WHITE = 0xffffffff.toInt()
-
-fun encodeAsBitmap(
-	text: String,
-	format: BarcodeFormat,
-	width: Int,
-	height: Int,
-	hints: EnumMap<EncodeHintType, Any>? = null
-): Bitmap? {
-	val bitMatrix = encode(text, format, hints, width, height)
-	val w = bitMatrix.width
-	val h = bitMatrix.height
-	val pixels = IntArray(w * h)
-	var offset = 0
-	for (y in 0 until h) {
-		for (x in 0 until w) {
-			pixels[offset + x] = if (bitMatrix.get(x, y)) {
-				BLACK
-			} else {
-				WHITE
-			}
-		}
-		offset += w
-	}
-	val bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
-	bitmap.setPixels(pixels, 0, w, 0, 0, w, h)
-	return bitmap
-}
-
-fun encodeAsSvg(
-	text: String,
-	format: BarcodeFormat,
-	hints: EnumMap<EncodeHintType, Any>? = null
-): String {
-	val bitMatrix = encode(text, format, hints)
-	val sb = StringBuilder()
-	val w = bitMatrix.width
-	var h = bitMatrix.height
-	val moduleHeight = if (h == 1) w / 2 else 1
-	for (y in 0 until h) {
-		for (x in 0 until w) {
-			if (bitMatrix.get(x, y)) {
-				sb.append(" M${x},${y}h1v${moduleHeight}h-1z")
-			}
-		}
-	}
-	h *= moduleHeight
-	return """<svg width="$w" height="$h"
-viewBox="0 0 $w $h"
-xmlns="http://www.w3.org/2000/svg">
-<path d="$sb"/>
-</svg>
-"""
-}
-
-fun encodeAsText(
-	text: String,
-	format: BarcodeFormat,
-	hints: EnumMap<EncodeHintType, Any>? = null
-): String {
-	val bitMatrix = encode(text, format, hints)
-	val w = bitMatrix.width
-	val h = bitMatrix.height
-	val sb = StringBuilder()
-	for (y in 0 until h) {
-		for (x in 0 until w) {
-			sb.append(if (bitMatrix.get(x, y)) "█" else " ")
-		}
-		sb.append("\n")
-	}
-	return sb.toString()
-}
-
-private fun encode(
-	text: String,
-	format: BarcodeFormat,
-	encodeHints: EnumMap<EncodeHintType, Any>? = null,
-	width: Int = 0,
-	height: Int = 0
-): BitMatrix {
-	val hints = encodeHints ?: EnumMap<EncodeHintType, Any>(EncodeHintType::class.java)
-	if (!hints.contains(EncodeHintType.CHARACTER_SET)) {
-		hints[EncodeHintType.CHARACTER_SET] = "utf-8"
-	}
-	return MultiFormatWriter().encode(
-		text,
-		format,
-		width,
-		height,
-		hints
-	)
-}

app/src/main/res/drawable-anydpi-v26/ic_shortcut_history.xml

@@ -0,0 +1,4 @@
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+	<background android:drawable="@color/accent"/>
+	<foreground android:drawable="@drawable/ic_shortcut_history_foreground"/>
+</adaptive-icon>