Advance version number to 1.26.0

Add a setting for swipe to zoom feature
Stop calling focusTo() as soon as it returns false
2020-04-26 20:32:44 +02:00 · 2020-04-25 19:37:37 +02:00 · 2020-04-25 19:22:20 +02:00 · 2020-04-24 20:27:04 +02:00 · 2020-04-24 19:02:27 +02:00 · 2020-04-23 14:40:14 +02:00
158 changed files with 5812 additions and 1145 deletions
@@ -1,8 +1,8 @@
+*.DS_Store
 *.swp
 .gradle
 .idea
 build
 local.properties
-gradle.properties
 infer-out
 *.iml
@@ -1,5 +1,167 @@
 # Change Log

+# 1.26.0
+* Zoom in & out by swiping vertically in camera view
+* Add a setting for swipe to zoom feature
+* Optimize vector drawables
+* Update Indonesian translation
+
+# 1.25.1
+* Fix Proguard configuration
+
+# 1.25.0
+* Add giving scans individual names in history listing
+* Add searching the history
+* Add a setting to search harder for barcodes
+* Add a setting to control vibration on detection
+* Add app shortcuts for launchers that support them
+* Remove saving barcodes for intents from other apps
+* Show latest possible result point in camera view
+* Suggest a WiFi network on Android Q+
+* Always put parsed WiFi password into clipboard
+* Use native image processing where available
+* Ignore consecutive duplicates by default
+* Fix saving external files on Android Q+
+* Fix order of metadata items
+
+# 1.24.0
+* Show barcode metadata
+* Add a setting to show/hide metadata
+* Include metadata in CSV export
+* Update italian translation
+* Fix resetting flash button
+* Fix CSV export for Android Q
+
+# 1.23.0
+* Add a setting to not save consecutive double scans
+* Add a setting to show/hide hex dump
+* Limit history items to just one line
+* Fix window insets for consecutive screens
+
+# 1.22.3
+* Fix broken RenderScript built
+
+# 1.22.2
+* Fix getting window insets for Android Lollipop and above
+
+# 1.22.1
+* Ensure non-printable content is saved as raw data
+
+# 1.22.0
+* Highlight detected barcodes in camera view
+* Add bing and yandex search engines
+* Update Chinese Translation
+* Update Italian translation
+* Update Indonesian translation
+
+# 1.21.0
+* Save and restore history list state
+* Improve scanning from large images
+* Fix opening image files by "Open with"
+
+# 1.20.1
+* Fix window insets below Android Lollipop
+
+# 1.20.0
+* Scroll content below tool and system bars
+* Preset file name to save with format and content
+* Add encode menu item to make encoding easier when keyboard is visible
+* Increase font size of barcode contents in history
+* Update Hungarian translation
+* Update Indonesian translation
+* Fix encoding for old Androids
+* Fix returning result for ZXing's SCAN intent again
+* Fix transfering barcode format from history
+
+# 1.19.0
+* Allow scaling a new barcode to half its size
+* Remember last selected barcode format
+
+# 1.18.0
+* Make open URL default action after decoding a barcode
+* Add a setting to open contents without inspection
+* Highlight codes for picking in shared/loaded images
+* Improve visability of crop border
+* Fix returning result for ZXing's SCAN intent
+
+# 1.17.1
+* Fix navigating back without choosing an image
+
+# 1.17.0
+* Pinch/Zoom shared/loaded images to scan just a section
+* Add a load file menu item to load an image file
+* Add a save file menu item to the barcode view
+* Use discrete style for size seek bar
+* Fix bar transparency when zooming/pinching
+
+# 1.16.0
+* Improve displaying scanned barcodes
+* Show a message if a barcode cannot be shared
+* Fix setting system bar transparency when double taping a barcode
+* Update Dutch translation
+* Update Hungarian translation
+* Update Indonesian translation
+* Update Italian translation
+
+# 1.15.0
+* Additionally export history as CSV file
+* Color tool and system bars when a view is scrolled
+* Add an intent filter for opening images
+* Add Russian translation
+
+# 1.14.0
+* Add OTP support
+* Update Indonesian translation
+
+# 1.13.1
+* Fix crash caused by missing support for Regex on Android < 6
+
+# 1.13.0
+* Add missing extras for ZXing result intents
+
+# 1.12.0
+* Add preferences dialog and the option to use a custom URL with read contents
+* Add Brazilian Portuguese translation
+* Add Chinese translation
+* Encode text using UTF-8 encoding when creating a barcode
+
+# 1.11.2
+* Downgrade ZXing version
+* Improve getting system UI metrics
+
+# 1.11.1
+* Fix tap to focus on some devices
+
+# 1.11.0
+* Add support for VCard and VEvent barcodes contents
+* Generated barcodes are now zoomable
+* Fix creating PDF417 barcodes
+
+## 1.10.0
+* Add support for special barcode contents (WiFi, SMS, phone, E-mail)
+* Add Indonesian translation
+* Update Hungarian translation
+* Make system bars completely transparent
+
+## 1.9.1
+* Pick search engine for content that is not an URL
+
+## 1.9.0
+* Try Google when opening content as URL fails
+* Show generic error message if barcode generation fails
+
+## 1.8.1
+* Distribute APK instead of App Bundle
+
+## 1.8.0
+* Save binary data into external file
+* Fix storage of binary data
+* Remove horizontal orientation line from scanner
+
+## 1.7.3
+* Fix crashes on Lineage and remove RenderScript fallback
+* Improve handling of binary data
+
 ## 1.7.2
 * Add a fallback for RenderScript
 * Add italian translation
@@ -0,0 +1,20 @@
+# Contribution Guidelines
+
+Please try to keep things in good shape and comply to what's there.
+
+This project follows Android [best practices][android_best_practices]
+so please have a look if you've never heard of them.
+
+The code is formatted according to Android Studio's standard, with the
+exception of indent being tabs instead of spaces.
+
+Use the feature branch workflow to add new features and make sure
+to squash when merging into master:
+
+	$ git merge cool_feature --squash
+
+Then write a [good commit message][commit_messages] to keep the history
+meaningful and useful. One feature, one commit.
+
+[android_best_practices]: https://developer.android.com/distribute/best-practices/develop/
+[commit_messages]: https://juffalow.com/other/write-good-git-commit-message
@@ -14,14 +14,14 @@ bundle: lint
 lint:
 	./gradlew lintDebug

-sonarqube:
-	./gradlew sonarqube
-
 infer: clean
 	infer -- ./gradlew assembleDebug

 test:
-	./gradlew cAT
+	./gradlew test
+
+cat:
+	./gradlew test cAT

 install:
 	adb $(TARGET) install -r app/build/outputs/apk/debug/app-debug.apk
@@ -36,5 +36,8 @@ uninstall:
 images:
 	svg/update.sh

+avocado:
+	avocado $(shell fgrep -rl '<vector' app/src/main/res)
+
 clean:
 	./gradlew clean
@@ -2,4 +2,5 @@

 Binary Eye does not collect any personal information.

-If you have any questions or suggestions about my Privacy Policy, do not     hesitate to contact me.
+If you have any questions or suggestions about my Privacy Policy, do not
+hesitate to contact me.
@@ -2,18 +2,84 @@

 Yet another barcode scanner for Android. As if there weren't [enough][play].

-This one is totally free, open source and does use the [ZXing][zxing] barcode
-scanning library.
+This one is free, without any ads and open source.

-Unlike many others it works in portrait and landscape orientation, can read
-inverted codes, uses Material Design and doesn't do anything else but decoding
-a barcode.
+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.
+
+## Screenshots
+
+<img
+	src="https://raw.githubusercontent.com/markusfisch/BinaryEye/gh-pages/screencap-scanning.png"
+	alt="Screenshot Scanning" width="160"/>
+<img
+	src="https://raw.githubusercontent.com/markusfisch/BinaryEye/gh-pages/screencap-decoded.png"
+	alt="Screenshot Result" width="160"/>
+<img
+	src="https://raw.githubusercontent.com/markusfisch/BinaryEye/gh-pages/screencap-compose-barcode.png"
+	alt="Screenshot Compose Barcode" width="160"/>
+
+## Download

 <a href="https://f-droid.org/en/packages/de.markusfisch.android.binaryeye/"><img alt="Get it on F-Droid" src="https://fdroid.gitlab.io/artwork/badge/get-it-on.png" height="80"/></a> <a href="https://play.google.com/store/apps/details?id=de.markusfisch.android.binaryeye"><img alt="Get it on Google Play" src="https://play.google.com/intl/en_us/badges/images/generic/en_badge_web_generic.png" height="80"/></a>

-And it's written in [Kotlin][kotlin] because I wanted to explore that a
-bit more.
+## Supported Barcode Formats
+
+### Read
+
+ZXing can read the following barcode formats:
+* [AZTEC][aztec]
+* [CODABAR][codabar]
+* [CODE 39][code_39]
+* [CODE 93][code_93]
+* [CODE 128][code_128]
+* [DATA MATRIX][data_matrix]
+* [EAN 8][ean_8]
+* [EAN 13][ean_13]
+* [ITF][itf]
+* [MAXICODE][maxicode]
+* [PDF417][pdf417]
+* [QR CODE][qr_code]
+* [RSS 14][rss]
+* [RSS EXPANDED][rss]
+* [UPC A][upc_a]
+* [UPC E][upc_e]
+* [UPC EAN EXTENSION][upc_ean]
+
+### Generate
+
+ZXing can generate the following barcode formats:
+* [AZTEC][aztec]
+* [CODABAR][codabar]
+* [CODE 39][code_39]
+* [CODE 128][code_128]
+* [DATA MATRIX][data_matrix]
+* [EAN 8][ean_8]
+* [EAN 13][ean_13]
+* [ITF][itf]
+* [PDF 417][pdf417]
+* [QR CODE][qr_code]
+* [UPC A][upc_a]

 [play]: https://play.google.com/store/search?q=barcode%20scanner&c=apps
 [zxing]: https://github.com/zxing/zxing
 [kotlin]: http://kotlinlang.org/
+[aztec]: https://en.wikipedia.org/wiki/Aztec_Code
+[codabar]: https://en.wikipedia.org/wiki/Codabar
+[code_39]: https://en.wikipedia.org/wiki/Code_39
+[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
+[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
+[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
@@ -9,8 +9,8 @@ android {
 		minSdkVersion 9
 		targetSdkVersion sdk_version

-		versionCode 24
-		versionName '1.7.2'
+		versionCode 60
+		versionName '1.26.0'

 		// it's recommended to set this value to the lowest API level
 		// able to provide all the functionality
@@ -18,6 +18,8 @@ android {
 		renderscriptSupportModeEnabled true

 		testInstrumentationRunner 'android.support.test.runner.AndroidJUnitRunner'
+
+		buildConfigField 'boolean', 'IS_CATALINA', is_catalina.toString()
 	}

 	signingConfigs {
@@ -33,6 +35,7 @@ android {
 	sourceSets {
 		main.java.srcDirs += 'src/main/kotlin'
 		androidTest.java.srcDirs += 'src/androidTest/kotlin'
+		test.java.srcDirs += 'src/test/kotlin'
 	}

 	buildTypes {
@@ -57,18 +60,21 @@ android {
 }

 dependencies {
-	androidTestImplementation ('com.android.support.test:runner:1.0.2') {
+	androidTestImplementation('com.android.support.test:runner:1.0.2') {
 		exclude module: 'support-annotations'
 	}
-	androidTestImplementation ('com.android.support.test:rules:1.0.2') {
+	androidTestImplementation('com.android.support.test:rules:1.0.2') {
 		exclude module: 'support-annotations'
 	}
 	testImplementation 'junit:junit:4.12'

 	implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.0.1"
+	implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.2"
 	implementation "com.android.support:appcompat-v7:$support_version"
 	implementation "com.android.support:design:$support_version"
+	// Do NOT upgrade ZXing because newer versions won't work on API < 24
+	// https://github.com/zxing/zxing/issues/1170
 	implementation 'com.google.zxing:core:3.3.3'
-	implementation 'com.github.markusfisch:CameraView:1.8.3'
+	implementation 'com.github.markusfisch:CameraView:1.9.1'
+	implementation 'com.github.markusfisch:ScalingImageView:1.2.0'
 }
@@ -3,10 +3,10 @@
 	<!-- Lint can't understand Kotlin sources and reports all resources
 		as unused -->
 	<issue id="UnusedResources">
-		<ignore path="src/main/res/"/>
+		<ignore path="src/main/res/" />
 	</issue>
 	<!-- Ignore RenderScript output  -->
 	<issue id="UnusedResources">
-		<ignore path="*/res/rs/debug/raw/bc*"/>
+		<ignore path="*/res/rs/debug/raw/bc*" />
 	</issue>
 </lint>
@@ -1,4 +1,6 @@
 -dontwarn com.google.**
+-dontwarn android.support.v7.**
 -dontwarn android.support.v8.**

+-keep class android.support.v7.widget.SearchView { *; }
 -keep class android.support.v8.renderscript.** { *; }
@@ -21,22 +21,21 @@ class PreprocessorTest {
 		val pattern = Pattern.compile(
 			"[0-9]+-([0-9]+)x([0-9]+)-([0-9]+)deg.yuv"
 		)
-
-		for (file in assets.list("yuv")) {
+		val files = assets.list("yuv") ?: return
+		for (file in files) {
 			val m = pattern.matcher(file)
 			if (!m.find() || m.groupCount() < 3) {
 				continue
 			}
-
-			val frameWidth = m.group(1).toInt()
-			val frameHeight = m.group(2).toInt()
-			val frameOrientation = m.group(3).toInt()
+			val frameWidth = m.group(1) ?: return
+			val frameHeight = m.group(2) ?: return
+			val frameOrientation = m.group(3) ?: return
 			val frameData = assets.open("yuv/$file").readBytes()
 			val preprocessor = Preprocessor(
 				InstrumentationRegistry.getTargetContext(),
-				frameWidth,
-				frameHeight,
-				frameOrientation
+				frameWidth.toInt(),
+				frameHeight.toInt(),
+				frameOrientation.toInt()
 			)
 			preprocessor.process(frameData)
 			val result = zxing.decode(
@@ -5,17 +5,21 @@
 	<supports-screens
 		android:largeScreens="true"
 		android:xlargeScreens="true"/>
+	<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
 	<uses-permission android:name="android.permission.CAMERA"/>
 	<uses-permission android:name="android.permission.VIBRATE"/>
 	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+	<uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
+	<uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
 	<uses-feature android:name="android.hardware.camera"/>
 	<uses-feature android:name="android.hardware.camera.autofocus"/>
 	<application
 		tools:ignore="UnusedAttribute"
 		android:name=".app.BinaryEyeApp"
 		android:allowBackup="true"
-		android:fullBackupContent="true"
+		android:fullBackupContent="@xml/backup_rules"
 		android:supportsRtl="true"
+		android:resizeableActivity="true"
 		android:label="@string/app_name"
 		android:icon="@mipmap/ic_launcher"
 		android:theme="@style/AppTheme">
@@ -27,6 +31,9 @@
 				<action android:name="android.intent.action.MAIN"/>
 				<category android:name="android.intent.category.LAUNCHER"/>
 			</intent-filter>
+			<meta-data
+				android:name="android.app.shortcuts"
+				android:resource="@xml/shortcuts"/>
 		</activity>
 		<activity
 			android:name=".activity.CameraActivity"
@@ -36,11 +43,6 @@
 				<category android:name="android.intent.category.DEFAULT"/>
 				<data android:mimeType="text/plain"/>
 			</intent-filter>
-			<intent-filter android:label="@string/decode_barcode">
-				<action android:name="android.intent.action.SEND"/>
-				<category android:name="android.intent.category.DEFAULT"/>
-				<data android:mimeType="image/*"/>
-			</intent-filter>
 			<intent-filter>
 				<action android:name="com.google.zxing.client.android.SCAN"/>
 				<category android:name="android.intent.category.DEFAULT"/>
@@ -55,9 +57,25 @@
 					android:scheme="http"/>
 			</intent-filter>
 		</activity>
+		<activity
+			android:name=".activity.PickActivity"
+			android:label="@string/pick_code_to_scan"
+			tools:ignore="AppLinkUrlError">
+			<intent-filter android:label="@string/decode_barcode">
+				<action android:name="android.intent.action.SEND"/>
+				<category android:name="android.intent.category.DEFAULT"/>
+				<data android:mimeType="image/*"/>
+			</intent-filter>
+			<intent-filter android:label="@string/decode_barcode">
+				<action android:name="android.intent.action.VIEW"/>
+				<category android:name="android.intent.category.DEFAULT"/>
+				<data android:mimeType="image/*"/>
+			</intent-filter>
+		</activity>
 		<activity
 			android:name=".activity.MainActivity"
-			android:label="@string/app_name"/>
+			android:label="@string/app_name"
+			android:exported="true"/>
 		<provider
 			android:name="android.support.v4.content.FileProvider"
 			android:authorities="${applicationId}.provider"
@@ -67,5 +85,8 @@
 				android:name="android.support.FILE_PROVIDER_PATHS"
 				android:resource="@xml/file_paths"/>
 		</provider>
+		<meta-data
+			android:name="android.app.searchable"
+			android:resource="@xml/searchable"/>
 	</application>
 </manifest>
@@ -0,0 +1,30 @@
+package de.markusfisch.android.binaryeye.actions
+
+import de.markusfisch.android.binaryeye.actions.mail.MailAction
+import de.markusfisch.android.binaryeye.actions.otpauth.OtpauthAction
+import de.markusfisch.android.binaryeye.actions.search.OpenOrSearchAction
+import de.markusfisch.android.binaryeye.actions.sms.SmsAction
+import de.markusfisch.android.binaryeye.actions.tel.TelAction
+import de.markusfisch.android.binaryeye.actions.vtype.vcard.VCardAction
+import de.markusfisch.android.binaryeye.actions.vtype.vevent.VEventAction
+import de.markusfisch.android.binaryeye.actions.web.WebAction
+import de.markusfisch.android.binaryeye.actions.wifi.WifiAction
+
+object ActionRegistry {
+	val DEFAULT_ACTION: IAction = OpenOrSearchAction
+
+	private val REGISTRY: Set<IAction> = setOf(
+		MailAction,
+		OtpauthAction,
+		SmsAction,
+		TelAction,
+		VCardAction,
+		VEventAction,
+		WebAction,
+		WifiAction
+	)
+
+	fun getAction(data: ByteArray): IAction = REGISTRY.find {
+		it.canExecuteOn(data)
+	} ?: DEFAULT_ACTION
+}
@@ -0,0 +1,48 @@
+package de.markusfisch.android.binaryeye.actions
+
+import android.content.Context
+import android.content.Intent
+import de.markusfisch.android.binaryeye.app.execShareIntent
+import de.markusfisch.android.binaryeye.app.parseAndNormalizeUri
+import de.markusfisch.android.binaryeye.widget.toast
+
+interface IAction {
+	val iconResId: Int
+	val titleResId: Int
+
+	fun canExecuteOn(data: ByteArray): Boolean
+	suspend fun execute(context: Context, data: ByteArray)
+}
+
+abstract class IntentAction : IAction {
+	abstract val errorMsg: Int
+
+	final override suspend fun execute(context: Context, data: ByteArray) {
+		val intent = createIntent(context, data) ?: return context.toast(
+			errorMsg
+		)
+		execShareIntent(context, intent)
+	}
+
+	abstract suspend fun createIntent(context: Context, data: ByteArray): Intent?
+}
+
+abstract class SchemeAction : IAction {
+	abstract val scheme: String
+	open val intentAction: String = Intent.ACTION_VIEW
+	open val buildRegex: Boolean = false
+
+	final override fun canExecuteOn(data: ByteArray): Boolean {
+		val content = String(data)
+		return if (buildRegex) {
+			content.matches("""^$scheme://[\w\W]+$""".toRegex(RegexOption.IGNORE_CASE))
+		} else {
+			content.startsWith("$scheme://", ignoreCase = true)
+		}
+	}
+
+	final override suspend fun execute(context: Context, data: ByteArray) {
+		val uri = parseAndNormalizeUri(String(data))
+		execShareIntent(context, Intent(intentAction, uri))
+	}
+}
@@ -0,0 +1,30 @@
+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 MailAction : IntentAction() {
+	private val mailRegex =
+		"""^mail(?:to)?:([\w.%+-]+@[A-Za-z\d.-]+\.[A-Za-z]{2,6}(?:[?&](?:subject|body)=[\S\s]*?){0,2})$""".toRegex()
+
+	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).matches(mailRegex)
+	}
+
+	override suspend fun createIntent(context: Context, data: ByteArray): Intent? {
+		val mailWithMessage = mailRegex.matchEntire(
+			String(data)
+		)?.groupValues?.get(1) ?: return null
+		return Intent(
+			Intent.ACTION_SENDTO,
+			Uri.parse("mailto:$mailWithMessage")
+		)
+	}
+}
@@ -0,0 +1,10 @@
+package de.markusfisch.android.binaryeye.actions.otpauth
+
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.actions.SchemeAction
+
+object OtpauthAction : SchemeAction() {
+	override val iconResId: Int = R.drawable.ic_action_otpauth
+	override val titleResId: Int = R.string.otpauth_add
+	override val scheme: String = "otpauth"
+}
@@ -0,0 +1,55 @@
+package de.markusfisch.android.binaryeye.actions.search
+
+import android.content.Context
+import android.content.Intent
+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.execShareIntent
+import de.markusfisch.android.binaryeye.app.parseAndNormalizeUri
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.widget.toast
+import java.net.URLEncoder
+
+object OpenOrSearchAction : IAction {
+	override val iconResId: Int = R.drawable.ic_action_search
+	override val titleResId: Int = R.string.search_web
+
+	override fun canExecuteOn(data: ByteArray): Boolean = false
+
+	override suspend fun execute(context: Context, data: ByteArray) {
+		val intent = openUri(context, String(data)) ?: return
+		execShareIntent(context, intent)
+	}
+
+	private suspend fun openUri(context: Context, data: String, search: Boolean = true): Intent? {
+		val uri = parseAndNormalizeUri(data)
+		val intent = Intent(Intent.ACTION_VIEW, uri)
+		when {
+			intent.resolveActivity(context.packageManager) != null -> return intent
+			search -> return getSearchIntent(context, data)
+			else -> context.toast(R.string.cannot_resolve_action)
+		}
+		return null
+	}
+
+	private suspend fun getSearchIntent(context: Context, query: String): Intent? {
+		val names = context.resources.getStringArray(
+			R.array.search_engines_names
+		).toMutableList()
+		val urls = context.resources.getStringArray(
+			R.array.search_engines_values
+		).toMutableList()
+		if (prefs.openWithUrl.isNotEmpty()) {
+			names.add(prefs.openWithUrl)
+			urls.add(prefs.openWithUrl)
+		}
+		val queryUri = alertDialog<String>(context) { resume ->
+			setTitle(R.string.pick_search_engine)
+			setItems(names.toTypedArray()) { _, which ->
+				resume(urls[which] + URLEncoder.encode(query, "utf-8"))
+			}
+		} ?: return null
+		return openUri(context, queryUri, false)
+	}
+}
@@ -0,0 +1,34 @@
+package de.markusfisch.android.binaryeye.actions.sms
+
+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 SmsAction : IntentAction() {
+	private val smsRegex =
+		"""^sms(?:to)?:(\+?[0-9]+)(?::([\S\s]*))?$""".toRegex(RegexOption.IGNORE_CASE)
+
+	override val iconResId: Int = R.drawable.ic_action_sms
+	override val titleResId: Int = R.string.sms_send
+	override val errorMsg: Int = R.string.sms_error
+
+	override fun canExecuteOn(data: ByteArray): Boolean {
+		return String(data).matches(smsRegex)
+	}
+
+	override suspend fun createIntent(context: Context, data: ByteArray): Intent? {
+		val (number: String, message: String) = smsRegex.matchEntire(
+			String(data)
+		)?.let {
+			it.groupValues[1] to it.groupValues[2]
+		} ?: return null
+		return Intent(
+			Intent.ACTION_SENDTO,
+			Uri.parse("smsto:$number")
+		).apply {
+			if (message.isNotEmpty()) putExtra("sms_body", message)
+		}
+	}
+}
@@ -0,0 +1,23 @@
+package de.markusfisch.android.binaryeye.actions.tel
+
+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
+
+object TelAction : IntentAction() {
+	private val telRegex = """^tel:(\+?[0-9]+)$""".toRegex(RegexOption.IGNORE_CASE)
+
+	override val iconResId: Int = R.drawable.ic_action_tel
+	override val titleResId: Int = R.string.tel_dial
+	override val errorMsg: Int = R.string.tel_error
+
+	override fun canExecuteOn(data: ByteArray): Boolean {
+		return String(data).matches(telRegex)
+	}
+
+	override suspend fun createIntent(context: Context, data: ByteArray): Intent {
+		return Intent(Intent.ACTION_DIAL, parseAndNormalizeUri(String(data)))
+	}
+}
@@ -0,0 +1,36 @@
+package de.markusfisch.android.binaryeye.actions.vtype
+
+import java.util.*
+
+object VTypeParser {
+	private const val BACKSLASH_R_LEGACY =
+		"(?:\u000D\u000A|[\u000A\u000B\u000C\u000D\u0085\u2028\u2029])"
+	private val vTypeRegex =
+		"""^BEGIN:(VCARD|VEVENT)(?:$BACKSLASH_R_LEGACY.+?:[\s\S]+?)+?${BACKSLASH_R_LEGACY}END:\1$BACKSLASH_R_LEGACY?$""".toRegex(
+			RegexOption.IGNORE_CASE
+		)
+	private val propertyRegex = """^(.+?):([\s\S]*?)$""".toRegex(RegexOption.MULTILINE)
+
+	fun parseVType(data: String): String? =
+		vTypeRegex.matchEntire(data)?.groupValues?.get(1)?.toUpperCase(Locale.US)
+
+	fun parseMap(data: String): Map<String, List<VTypeProperty>> = propertyRegex.findAll(data).map {
+		it.groupValues[1].split(';').let { typeAndInfo ->
+			typeAndInfo[0] to VTypeProperty(typeAndInfo.drop(1), it.groupValues[2])
+		}
+	}.groupBy({ it.first.toUpperCase(Locale.US) }) { it.second }
+}
+
+data class VTypeProperty(
+	val info: List<String>,
+	val value: String
+) {
+	val firstTypeOrFirstInfo: String?
+		get() = this.info.find { it.startsWith("TYPE=", true) }?.let {
+			typeRegex.matchEntire(it)?.groupValues?.get(1)
+		} ?: this.info.firstOrNull()
+
+	companion object {
+		private val typeRegex = """^(?:TYPE=)(.+?)[:;]?.*$""".toRegex(RegexOption.IGNORE_CASE)
+	}
+}
@@ -0,0 +1,185 @@
+package de.markusfisch.android.binaryeye.actions.vtype.vcard
+
+import android.content.ContentValues
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+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
+
+object VCardAction : IntentAction() {
+	override val iconResId: Int
+		get() = R.drawable.ic_action_vcard
+	override val titleResId: Int
+		get() = R.string.vcard_add
+	override val errorMsg: Int
+		get() = R.string.vcard_failed
+
+	override fun canExecuteOn(data: ByteArray): Boolean {
+		return VTypeParser.parseVType(String(data)) == "VCARD"
+	}
+
+	override suspend fun createIntent(context: Context, data: ByteArray): Intent? {
+		val info = VTypeParser.parseMap(String(data))
+
+		return Intent(Intent.ACTION_INSERT_OR_EDIT).apply {
+			type = ContactsContract.Contacts.CONTENT_ITEM_TYPE
+			info["FN"]?.singleOrNull()?.also { name ->
+				putExtra(ContactsContract.Intents.Insert.NAME, name.value)
+			} ?: info["N"]?.singleOrNull()?.also { name ->
+				putExtra(ContactsContract.Intents.Insert.NAME, name.value.nameFormat)
+			}
+			info["TEL"]?.filter { it.value.isNotEmpty() }?.forEachIndexed { index, phoneProperty ->
+				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 {
+					it.phoneType?.also { phoneType ->
+						putExtra(extraPhoneType, phoneType)
+					} ?: putExtra(extraPhoneType, it)
+				}
+				putExtra(
+					extraPhone,
+					phoneProperty.value.toLowerCase(Locale.US).removePrefix("tel:")
+				)
+			}
+			info["EMAIL"]?.forEachIndexed { index, mailProperty ->
+				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 {
+					it.mailType?.also { mailType ->
+						putExtra(extraMailType, mailType)
+					} ?: putExtra(extraMailType, it)
+				}
+				putExtra(extraMail, mailProperty.value)
+			}
+			info["ORG"]?.singleOrNull()?.also { organization ->
+				putExtra(ContactsContract.Intents.Insert.COMPANY, organization.value)
+			}
+			info["TITLE"]?.singleOrNull()?.also { jobTitle ->
+				putExtra(ContactsContract.Intents.Insert.JOB_TITLE, jobTitle.value)
+			}
+			info["ADR"]?.forEach { addr ->
+				addr.firstTypeOrFirstInfo?.also {
+					it.addressType?.also { addressType ->
+						putExtra(ContactsContract.Intents.Insert.POSTAL_TYPE, addressType)
+					} ?: putExtra(ContactsContract.Intents.Insert.POSTAL_TYPE, it)
+				}
+				putExtra(ContactsContract.Intents.Insert.POSTAL, addr.value.locationFormat)
+			}
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+				val urls = info["URL"]?.mapNotNull {
+					it.value.takeIf { url -> url.isNotBlank() }?.let { url ->
+						ContentValues(2).apply {
+							put(
+								ContactsContract.Data.MIMETYPE,
+								ContactsContract.CommonDataKinds.Website.CONTENT_ITEM_TYPE
+							)
+							put(ContactsContract.CommonDataKinds.Website.URL, url)
+						}
+					}
+				}
+				val bDays = info["BDAY"]?.mapNotNull {
+					it.value.takeIf { day -> day.isNotBlank() }?.let { day ->
+						ContentValues(3).apply {
+							put(
+								ContactsContract.Data.MIMETYPE,
+								ContactsContract.CommonDataKinds.Event.CONTENT_ITEM_TYPE
+							)
+							put(
+								ContactsContract.CommonDataKinds.Event.TYPE,
+								ContactsContract.CommonDataKinds.Event.TYPE_BIRTHDAY
+							)
+							put(ContactsContract.CommonDataKinds.Event.START_DATE, day)
+						}
+					}
+				}
+				putParcelableArrayListExtra(
+					ContactsContract.Intents.Insert.DATA,
+					ArrayList(listOfNotNull(urls, bDays).flatten())
+				)
+			}
+		}
+	}
+
+	private val String.locationFormat: String
+		get() = """^([^;]*?);([^;]*?);([^;]*?);([^;]*?);([^;]*?);([^;]*?);([^;]*?)$""".toRegex()
+			.matchEntire(
+				this
+			)?.groupValues?.let {
+				listOf(
+					it[1],
+					it[2],
+					it[3],
+					"${it[4]} ${it[6]}",
+					"${it[5]} ${it[7]}"
+				).filter { line -> line.isNotBlank() }
+					.joinToString("\n").takeIf { location -> location.isNotBlank() }
+			} ?: this
+
+	private val String.nameFormat: String
+		get() = """^([^;]*?);([^;]*?);([^;]*?);([^;]*?);([^;]*?)$""".toRegex()
+			.matchEntire(this)?.groupValues?.let {
+				listOf(it[4], it[2], it[3], it[1], it[5]).joinToString(" ")
+					.takeIf { name -> name.isNotBlank() }
+			} ?: this
+
+	private val String.mailType: Int?
+		get() = when (this.toUpperCase(Locale.US)) {
+			"HOME" -> ContactsContract.CommonDataKinds.Email.TYPE_HOME
+			"WORK" -> ContactsContract.CommonDataKinds.Email.TYPE_WORK
+			"OTHER" -> ContactsContract.CommonDataKinds.Email.TYPE_OTHER
+			"MOBILE" -> ContactsContract.CommonDataKinds.Email.TYPE_MOBILE
+			else -> null
+		}
+
+	private val String.phoneType: Int?
+		get() = when (this.toUpperCase(Locale.US)) {
+			"HOME" -> ContactsContract.CommonDataKinds.Phone.TYPE_HOME
+			"MOBILE", "CELL" -> ContactsContract.CommonDataKinds.Phone.TYPE_MOBILE
+			"WORK" -> ContactsContract.CommonDataKinds.Phone.TYPE_WORK
+			"FAX_WORK" -> ContactsContract.CommonDataKinds.Phone.TYPE_FAX_WORK
+			"FAX_HOME" -> ContactsContract.CommonDataKinds.Phone.TYPE_FAX_HOME
+			"PAGER" -> ContactsContract.CommonDataKinds.Phone.TYPE_PAGER
+			"OTHER" -> ContactsContract.CommonDataKinds.Phone.TYPE_OTHER
+			"CALLBACK" -> ContactsContract.CommonDataKinds.Phone.TYPE_CALLBACK
+			"CAR" -> ContactsContract.CommonDataKinds.Phone.TYPE_CAR
+			"COMPANY_MAIN" -> ContactsContract.CommonDataKinds.Phone.TYPE_COMPANY_MAIN
+			"ISDN" -> ContactsContract.CommonDataKinds.Phone.TYPE_ISDN
+			"MAIN" -> ContactsContract.CommonDataKinds.Phone.TYPE_MAIN
+			"OTHER_FAX" -> ContactsContract.CommonDataKinds.Phone.TYPE_OTHER_FAX
+			"RADIO" -> ContactsContract.CommonDataKinds.Phone.TYPE_RADIO
+			"TELEX" -> ContactsContract.CommonDataKinds.Phone.TYPE_TELEX
+			"TTY_TDD" -> ContactsContract.CommonDataKinds.Phone.TYPE_TTY_TDD
+			"WORK_MOBILE" -> ContactsContract.CommonDataKinds.Phone.TYPE_WORK_MOBILE
+			"WORK_PAGER" -> ContactsContract.CommonDataKinds.Phone.TYPE_WORK_PAGER
+			"ASSISTANT" -> ContactsContract.CommonDataKinds.Phone.TYPE_ASSISTANT
+			"MMS" -> ContactsContract.CommonDataKinds.Phone.TYPE_MMS
+			else -> null
+		}
+
+	private val String.addressType: Int?
+		get() = when (this.toUpperCase(Locale.US)) {
+			"HOME" -> ContactsContract.CommonDataKinds.StructuredPostal.TYPE_HOME
+			"WORK" -> ContactsContract.CommonDataKinds.StructuredPostal.TYPE_WORK
+			"OTHER" -> ContactsContract.CommonDataKinds.StructuredPostal.TYPE_OTHER
+			else -> null
+		}
+}
@@ -0,0 +1,78 @@
+package de.markusfisch.android.binaryeye.actions.vtype.vevent
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import android.provider.CalendarContract
+import android.support.annotation.RequiresApi
+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.*
+
+object VEventAction : IntentAction() {
+	override val iconResId: Int
+		get() = R.drawable.ic_action_vevent
+	override val titleResId: Int
+		get() = R.string.vevent_add
+	override val errorMsg: Int
+		get() = R.string.vevent_failed
+
+	override fun canExecuteOn(data: ByteArray): Boolean {
+		return Build.VERSION.SDK_INT >= Build.VERSION_CODES.ICE_CREAM_SANDWICH
+				&& VTypeParser.parseVType(String(data)) == "VEVENT"
+	}
+
+	@RequiresApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+	override suspend fun createIntent(context: Context, data: ByteArray): Intent? {
+		val info = VTypeParser.parseMap(String(data))
+
+		return Intent(Intent.ACTION_EDIT).apply {
+			type = "vnd.android.cursor.item/event"
+			info["SUMMARY"]?.singleOrNull()?.also { title ->
+				putExtra(CalendarContract.Events.TITLE, title.value)
+			}
+			info["DESCRIPTION"]?.singleOrNull()?.also { description ->
+				putExtra(CalendarContract.Events.DESCRIPTION, description.value)
+			}
+			info["LOCATION"]?.singleOrNull()?.also { location ->
+				putExtra(CalendarContract.Events.EVENT_LOCATION, location.value)
+			}
+			info["DTSTART"]?.singleOrNull()?.also { eventStart ->
+				dateFormats.simpleFindParse(eventStart.value)?.also {
+					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)
+				}
+			}
+		}
+	}
+
+	@SuppressLint("SimpleDateFormat") // we definitely don't wan't the local format
+	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
+	}
+}
@@ -0,0 +1,11 @@
+package de.markusfisch.android.binaryeye.actions.web
+
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.actions.SchemeAction
+
+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
+}
@@ -0,0 +1,33 @@
+package de.markusfisch.android.binaryeye.actions.wifi
+
+import android.content.Context
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.actions.IAction
+import de.markusfisch.android.binaryeye.widget.toast
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+object WifiAction : IAction {
+	override val iconResId = R.drawable.ic_action_wifi
+	override val titleResId = R.string.connect_to_wifi
+
+	var password: String? = null
+
+	override fun canExecuteOn(data: ByteArray): Boolean =
+		WifiConnector.parse(String(data)) {
+			password = it
+		} != null
+
+	override suspend fun execute(
+		context: Context,
+		data: ByteArray
+	) = withContext(Dispatchers.IO) {
+		val wifiConfig = WifiConnector.parse(
+			String(data)
+		) ?: return@withContext
+		val message = WifiConnector.addNetwork(context, wifiConfig)
+		withContext(Dispatchers.Main) {
+			context.toast(message)
+		}
+	}
+}
@@ -0,0 +1,370 @@
+package de.markusfisch.android.binaryeye.actions.wifi
+
+import android.content.Context
+import android.net.wifi.WifiConfiguration
+import android.net.wifi.WifiEnterpriseConfig
+import android.net.wifi.WifiManager
+import android.net.wifi.WifiNetworkSuggestion
+import android.os.Build
+import android.support.annotation.RequiresApi
+import de.markusfisch.android.binaryeye.R
+import java.util.*
+
+/**
+ * Normal:
+ * WIFI:S:[network SSID];T:<WPA|WEP|nopass|>;P:[network password];H:<true|false|>;;
+ *
+ * WPA2 enterprise (EAP):
+ * WIFI:S:[network SSID];T:WPA2-EAP;H:<true|false|nopass|>;E:[EAP method];PH2:[Phase 2 method];AI:[anonymous identity];I:[identity];P:[password];;
+ *
+ * EPA methods:
+ *      "AKA",      "AKA_PRIME",
+ *      "NONE",     "PEAP",
+ *      "PWD",      "SIM",
+ *      "TLS",      "TTLS",
+ *      "UNAUTH_TLS"
+ * https://developer.android.com/reference/android/net/wifi/WifiEnterpriseConfig.Eap.html
+ *
+ * Phase 2 methods:
+ *      "AKA",      "AKA_PRIME",
+ *      "GTC",      "MSCHAP",
+ *      "MSCHAPV2", "NONE",
+ *      "PAP",      "SIM"
+ * https://developer.android.com/reference/android/net/wifi/WifiEnterpriseConfig.Phase2.html
+ *
+ * The fields can appear in any order. Only "S:" is required.
+ */
+object WifiConnector {
+	fun parse(
+		input: String,
+		passwordBlock: ((password: String?) -> Unit)? = null
+	): Any? {
+		val inputMap = parseMap(input) ?: return null
+		val parsedData = SimpleDataAccessor.of(inputMap) ?: return null
+		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)
+		}
+	}
+
+	fun addNetwork(context: Context, config: Any): Int {
+		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
+			}
+		} 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
+			}
+		}
+	}
+
+	internal fun parseMap(string: String): Map<String, String>? {
+		// normally those codes should have the last semicolon, but many
+		// generators don't add it
+		val wifiRegex = """^WIFI:((?:.+?:(?:[^\\;]|\\.)*;)+);?$""".toRegex()
+		// should be: ^(.+):((?:[^\\;,":]|\\.)*);$ but allows unescaped , "
+		// and : because many QR Code creators don't escape properly
+		val pairRegex = """(.+?):((?:[^\\;]|\\.)*);""".toRegex()
+		return wifiRegex.matchEntire(
+			string
+		)?.groupValues?.get(1)?.let { pairs ->
+			pairRegex.findAll(pairs).map { pair ->
+				pair.groupValues[1].toUpperCase(Locale.US) to pair.groupValues[2]
+			}.toMap()
+		}
+	}
+
+	internal class SimpleDataAccessor private constructor(
+		private val inputMap: Map<String, String>
+	) {
+		// this should be private but because of testing it isn't possible
+		internal val ssid: String
+			get() = inputMap.getValue("S").unescape
+		internal val securityType: String
+			get() = inputMap["T"]?.unescape ?: ""
+		internal val password: String?
+			get() = inputMap["P"]?.unescape
+		internal val hidden: Boolean
+			get() = inputMap["H"]?.unescape == "true"
+		internal val anonymousIdentity: String
+			get() = inputMap["AI"]?.unescape ?: ""
+		internal val identity: String
+			get() = inputMap["I"]?.unescape ?: ""
+		internal val eapMethod: Int?
+			get() = if (inputMap["E"].isNullOrEmpty()) {
+				requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) {
+					WifiEnterpriseConfig.Eap.NONE
+				}
+			} else when (inputMap["E"]) {
+				"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 }
+				"PEAP" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Eap.PEAP }
+				"PWD" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Eap.PWD }
+				"SIM" -> requireSdk(Build.VERSION_CODES.LOLLIPOP) { WifiEnterpriseConfig.Eap.SIM }
+				"TLS" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Eap.TLS }
+				"TTLS" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Eap.TTLS }
+				"UNAUTH_TLS" -> requireSdk(Build.VERSION_CODES.N) { WifiEnterpriseConfig.Eap.UNAUTH_TLS }
+				else -> null
+			}
+		internal val phase2Method: Int?
+			get() = if (inputMap["PH2"].isNullOrEmpty()) {
+				requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) {
+					WifiEnterpriseConfig.Phase2.NONE
+				}
+			} else when (inputMap["PH2"]) {
+				"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 }
+				"MSCHAP" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Phase2.MSCHAP }
+				"MSCHAPV2" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Phase2.MSCHAPV2 }
+				"NONE" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Phase2.NONE }
+				"PAP" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) { WifiEnterpriseConfig.Phase2.PAP }
+				"SIM" -> requireSdk(Build.VERSION_CODES.O) { WifiEnterpriseConfig.Phase2.SIM }
+				else -> null
+			}
+
+		internal companion object {
+			internal fun of(inputMap: Map<String, String>): SimpleDataAccessor? {
+				return SimpleDataAccessor(inputMap).takeUnless {
+					inputMap["S"].isNullOrEmpty()
+				}
+			}
+		}
+	}
+
+	@RequiresApi(Build.VERSION_CODES.Q)
+	private fun WifiNetworkSuggestion.Builder.apply(
+		data: SimpleDataAccessor
+	): WifiNetworkSuggestion.Builder? {
+		fun WifiNetworkSuggestion.Builder.applyCommon(
+			data: SimpleDataAccessor
+		): WifiNetworkSuggestion.Builder? {
+			setSsid(data.ssid)
+			return this
+		}
+
+		fun WifiNetworkSuggestion.Builder.applySecurity(
+			data: SimpleDataAccessor
+		): WifiNetworkSuggestion.Builder? {
+			when (data.securityType) {
+				"WPA", "WPA2" -> {
+					data.password?.let {
+						setWpa2Passphrase(it)
+					}
+				}
+				"WPA2-EAP" -> {
+					data.password?.let {
+						setWpa2Passphrase(it)
+					}
+					setWpa2EnterpriseConfig(WifiEnterpriseConfig().apply {
+						identity = data.identity
+						anonymousIdentity = data.anonymousIdentity
+						password = data.password
+						data.eapMethod?.let { eapMethod = it }
+						data.phase2Method?.let { phase2Method = it }
+					})
+				}
+				"WPA3" -> {
+					data.password?.let {
+						setWpa3Passphrase(it)
+					}
+				}
+				"WPA3-EAP" -> {
+					data.password?.let { setWpa3Passphrase(it) }
+					setWpa3EnterpriseConfig(WifiEnterpriseConfig().apply {
+						identity = data.identity
+						anonymousIdentity = data.anonymousIdentity
+						password = data.password
+						data.eapMethod?.let { eapMethod = it }
+						data.phase2Method?.let { phase2Method = it }
+					})
+				}
+			}
+			return this
+		}
+
+		return this.applyCommon(data)?.applySecurity(data)
+	}
+
+	// WifiConfiguration is deprecated in Android Q
+	@Suppress("DEPRECATION")
+	private fun WifiConfiguration.apply(
+		data: SimpleDataAccessor
+	): WifiConfiguration? {
+		val ssidWithQuotes = data.ssid.quote
+		val passwordWithQuotes = data.password?.quoteUnlessHex
+
+		fun WifiConfiguration.applyCommon(
+			data: SimpleDataAccessor
+		): WifiConfiguration? {
+			allowedAuthAlgorithms.clear()
+			allowedGroupCiphers.clear()
+			allowedKeyManagement.clear()
+			allowedPairwiseCiphers.clear()
+			allowedProtocols.clear()
+
+			SSID = ssidWithQuotes
+			hiddenSSID = data.hidden
+			return this
+		}
+
+		fun WifiConfiguration.applySecurity(
+			data: SimpleDataAccessor
+		): WifiConfiguration? {
+			when (data.securityType) {
+				"", "nopass" -> allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
+				"WEP" -> @Suppress("DEPRECATION") /* WEP as insecure */ {
+					passwordWithQuotes?.let {
+						wepKeys[0] = it
+					} ?: return null
+					wepTxKeyIndex = 0
+					allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED)
+					allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104)
+				}
+				"WPA" -> {
+					passwordWithQuotes?.let {
+						preSharedKey = it
+					} ?: return null
+					allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
+					@Suppress("DEPRECATION") // WPA 1 is insecure and has bad performance
+					allowedProtocols.set(WifiConfiguration.Protocol.WPA) // WPA
+					allowedProtocols.set(WifiConfiguration.Protocol.RSN) // WPA2
+					allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK)
+					allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP)
+					@Suppress("DEPRECATION") // TKIP is insecure and has bad performance
+					allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP)
+					allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
+				}
+				"WPA2-EAP" -> requireSdk(Build.VERSION_CODES.JELLY_BEAN_MR2) {
+					passwordWithQuotes?.let {
+						preSharedKey = it
+					} ?: return null
+					allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN)
+					allowedProtocols.set(WifiConfiguration.Protocol.RSN) // WPA2
+					allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP)
+					@Suppress("DEPRECATION") // TKIP is insecure and has bad performance
+					allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP)
+					allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP)
+					allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP)
+
+					enterpriseConfig.identity = data.identity
+					enterpriseConfig.anonymousIdentity = data.anonymousIdentity
+					enterpriseConfig.password = data.password
+					enterpriseConfig.eapMethod =
+						data.eapMethod ?: return null // non valid eapMethod
+					enterpriseConfig.phase2Method =
+						data.phase2Method ?: return null // non valid phase2Method
+				} ?: return null // api isn't high enough
+			}
+			return this
+		}
+
+		return this.applyCommon(data)?.applySecurity(data)
+	}
+
+	private inline fun <T> requireSdk(version: Int, block: () -> T): T? {
+		return if (Build.VERSION.SDK_INT >= version) return block() else null
+	}
+}
+
+// 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 ->
+		escaped.groupValues[1]
+	}
+
+private val String.quote: String
+	get() = if (startsWith("\"") && endsWith("\"")) this else "\"$this\""
+
+private val String.quoteUnlessHex: String
+	get() = if (isHex()) this else this.quote
+
+// Unfortunately, we can never know whether a string consisting only
+// of 0-f is a hex string. So we just make this one assumption that
+// a string of 0-f that is exactly 64 characters long, is _probably_
+// a hex string for raw PSK. Of course, this may fail for any string
+// that just happens to be 64 characters long and contains just 0-f.
+private val hexRegex = """^[0-9a-f]+$""".toRegex(
+	RegexOption.IGNORE_CASE
+)
+
+private fun String.isHex() = length == 64 && matches(hexRegex)
+
+private fun WifiManager.enableWifi(): Boolean {
+	// setWifiEnabled() will always return false for Android Q
+	// because Q doesn't allow apps to enable/disable Wi-Fi anymore
+	@Suppress("DEPRECATION")
+	return isWifiEnabled || setWifiEnabled(true)
+}
+
+// WifiConfiguration is deprecated in Android Q
+@Suppress("DEPRECATION")
+private fun WifiManager.removeOldNetwork(
+	wifiConfig: WifiConfiguration
+): Boolean {
+	try {
+		configuredNetworks?.firstOrNull {
+			it.SSID == wifiConfig.SSID &&
+					it.allowedKeyManagement == wifiConfig.allowedKeyManagement
+		}?.networkId?.also {
+			removeNetwork(it)
+		}
+	} catch (e: SecurityException) {
+		// the user didn't allow ACCESS_FINE_LOCATION which is
+		// required to access configuredNetworks and that's fine
+	}
+	return true
+}
+
+// WifiConfiguration is deprecated in Android Q
+@Suppress("DEPRECATION")
+private fun WifiManager.enableNewNetwork(
+	wifiConfig: WifiConfiguration
+): Boolean {
+	val id = addNetwork(wifiConfig)
+	if (id == -1) {
+		return false
+	}
+	disconnect()
+	return if (enableNetwork(id, true)) {
+		reconnect()
+		true
+	} else {
+		false
+	}
+}
@@ -1,57 +1,62 @@
 package de.markusfisch.android.binaryeye.activity

-import com.google.zxing.Result
-
-import de.markusfisch.android.cameraview.widget.CameraView
-
-import de.markusfisch.android.binaryeye.app.db
-import de.markusfisch.android.binaryeye.app.initSystemBars
-import de.markusfisch.android.binaryeye.app.prefs
-import de.markusfisch.android.binaryeye.graphics.lumaToBitmap
-import de.markusfisch.android.binaryeye.rs.Preprocessor
-import de.markusfisch.android.binaryeye.zxing.Zxing
-import de.markusfisch.android.binaryeye.R
-
+import android.app.Activity
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageManager
-import android.graphics.Bitmap
 import android.hardware.Camera
 import android.net.Uri
 import android.os.Bundle
-import android.os.Parcelable
 import android.os.Vibrator
-import android.provider.MediaStore
-import android.support.v4.app.ActivityCompat
-import android.support.v4.content.ContextCompat
 import android.support.v7.app.AppCompatActivity
 import android.support.v7.widget.Toolbar
-import android.support.v8.renderscript.RSRuntimeException
 import android.view.Menu
 import android.view.MenuItem
+import android.view.MotionEvent
 import android.view.View
 import android.widget.SeekBar
-import android.widget.Toast
-
+import com.google.zxing.Result
+import com.google.zxing.ResultMetadataType
+import com.google.zxing.ResultPointCallback
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.data.Scan
+import de.markusfisch.android.binaryeye.graphics.Mapping
+import de.markusfisch.android.binaryeye.graphics.frameToView
+import de.markusfisch.android.binaryeye.rs.Preprocessor
+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 kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
-
-import java.io.IOException
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt

 class CameraActivity : AppCompatActivity() {
-	private val zxing = Zxing()
+	private val zxing = Zxing(ResultPointCallback { point ->
+		point?.let {
+			mapping?.map(it)?.let {
+				detectorView.post {
+					detectorView.mark(listOf(it))
+				}
+			}
+		}
+	})

 	private lateinit var vibrator: Vibrator
 	private lateinit var cameraView: CameraView
+	private lateinit var detectorView: DetectorView
 	private lateinit var zoomBar: SeekBar
 	private lateinit var flashFab: View

 	private var preprocessor: Preprocessor? = null
+	private var mapping: Mapping? = null
 	private var invert = false
 	private var flash = false
 	private var returnResult = false
 	private var frontFacing = false
-	private var useRenderScript = true
 	private var fallbackBuffer: IntArray? = null

 	override fun onRequestPermissionsResult(
@@ -60,60 +65,71 @@ class CameraActivity : AppCompatActivity() {
 		grantResults: IntArray
 	) {
 		when (requestCode) {
-			REQUEST_CAMERA -> if (grantResults.size > 0 &&
+			REQUEST_CAMERA -> if (grantResults.isNotEmpty() &&
 				grantResults[0] != PackageManager.PERMISSION_GRANTED
 			) {
-				Toast.makeText(
-					this,
-					R.string.no_camera_no_fun,
-					Toast.LENGTH_SHORT
-				).show()
+				toast(R.string.no_camera_no_fun)
 				finish()
 			}
 		}
 	}

+	override fun onActivityResult(
+		requestCode: Int,
+		resultCode: Int,
+		resultData: Intent?
+	) {
+		when (requestCode) {
+			PICK_FILE_RESULT_CODE -> {
+				if (resultCode == Activity.RESULT_OK && resultData != null) {
+					val pick = Intent(this, PickActivity::class.java)
+					pick.action = Intent.ACTION_VIEW
+					pick.setDataAndType(resultData.data, "image/*")
+					startActivity(pick)
+				}
+			}
+		}
+	}
+
 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
 		setContentView(R.layout.activity_camera)

+		vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+
 		initSystemBars(this)
 		setSupportActionBar(findViewById(R.id.toolbar) as Toolbar)

-		vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
-
 		cameraView = findViewById(R.id.camera_view) as CameraView
+		detectorView = findViewById(R.id.detector_view) as DetectorView
 		zoomBar = findViewById(R.id.zoom) as SeekBar
 		flashFab = findViewById(R.id.flash)
-		flashFab.setOnClickListener { _ -> toggleTorchMode() }
+		flashFab.setOnClickListener { toggleTorchMode() }

 		initCameraView()
 		initZoomBar()
 		restoreZoom()

-		if (intent?.action == Intent.ACTION_SEND) {
-			if (intent.type == "text/plain") {
-				handleSendText(intent)
-			} else if (intent.type?.startsWith("image/") == true) {
-				handleSendImage(intent)
-			}
+		if (intent?.action == Intent.ACTION_SEND &&
+			intent.type == "text/plain"
+		) {
+			handleSendText(intent)
 		}
 	}

 	override fun onDestroy() {
 		super.onDestroy()
 		preprocessor?.destroy()
-		saveZoom()
 		fallbackBuffer = null
+		saveZoom()
 	}

 	override fun onResume() {
 		super.onResume()
 		System.gc()
-		returnResult = "com.google.zxing.client.android.SCAN".equals(
-			intent.action
-		)
-		if (hasCameraPermission()) {
+		zxing.updateHints(prefs.tryHarder)
+		returnResult = "com.google.zxing.client.android.SCAN" == intent.action
+		if (hasCameraPermission(this, REQUEST_CAMERA)) {
 			openCamera()
 		}
 	}
@@ -121,6 +137,7 @@ class CameraActivity : AppCompatActivity() {
 	private fun openCamera() {
 		cameraView.openAsync(
 			CameraView.findCameraId(
+				@Suppress("DEPRECATION")
 				if (frontFacing) {
 					Camera.CameraInfo.CAMERA_FACING_FRONT
 				} else {
@@ -137,6 +154,8 @@ class CameraActivity : AppCompatActivity() {

 	private fun closeCamera() {
 		cameraView.close()
+		// closing the camera will also shut off the flash
+		flash = false
 	}

 	override fun onRestoreInstanceState(savedState: Bundle) {
@@ -166,10 +185,26 @@ class CameraActivity : AppCompatActivity() {
 				startActivity(MainActivity.getHistoryIntent(this))
 				true
 			}
+			R.id.pick_file -> {
+				val chooseFile = Intent(Intent.ACTION_GET_CONTENT)
+				chooseFile.type = "image/*"
+				startActivityForResult(
+					Intent.createChooser(
+						chooseFile,
+						getString(R.string.pick_file)
+					),
+					PICK_FILE_RESULT_CODE
+				)
+				true
+			}
 			R.id.switch_camera -> {
 				switchCamera()
 				true
 			}
+			R.id.preferences -> {
+				startActivity(MainActivity.getPreferencesIntent(this))
+				true
+			}
 			R.id.info -> {
 				openReadme()
 				true
@@ -185,13 +220,15 @@ class CameraActivity : AppCompatActivity() {
 	}

 	private fun openReadme() {
-		startActivity(
-			Intent(
-				Intent.ACTION_VIEW, Uri.parse(
-					"https://github.com/markusfisch/BinaryEye/blob/master/README.md"
-				)
-			)
+		val intent = Intent(
+			Intent.ACTION_VIEW,
+			Uri.parse(getString(R.string.project_url))
 		)
+		if (intent.resolveActivity(packageManager) != null) {
+			startActivity(intent)
+		} else {
+			toast(R.string.project_url)
+		}
 	}

 	private fun handleSendText(intent: Intent) {
@@ -202,54 +239,52 @@ class CameraActivity : AppCompatActivity() {
 		}
 	}

-	private fun handleSendImage(intent: Intent) {
-		val uri = intent.getParcelableExtra<Parcelable>(Intent.EXTRA_STREAM) as? Uri ?: return
-		val bitmap = try {
-			MediaStore.Images.Media.getBitmap(contentResolver, uri)
-		} catch (e: IOException) {
-			null
-		}
-		if (bitmap == null) {
-			Toast.makeText(
-				this,
-				R.string.error_no_content,
-				Toast.LENGTH_SHORT
-			).show()
-			return
-		}
-		val result = zxing.decodePositiveNegative(downsizeIfBigger(bitmap, 1024))
-		if (result != null) {
-			showResult(result)
-			finish()
-			return
-		}
-		Toast.makeText(
-			this,
-			R.string.no_barcode_found,
-			Toast.LENGTH_SHORT
-		).show()
-		finish()
-	}
-
-	private fun hasCameraPermission(): Boolean {
-		val permission = android.Manifest.permission.CAMERA
-
-		if (ContextCompat.checkSelfPermission(this, permission) !=
-			PackageManager.PERMISSION_GRANTED
-		) {
-			ActivityCompat.requestPermissions(
-				this, arrayOf(permission),
-				REQUEST_CAMERA
-			)
-			return false
-		}
-
-		return true
-	}
-
 	private fun initCameraView() {
 		cameraView.setUseOrientationListener(true)
-		cameraView.setTapToFocus()
+		@Suppress("ClickableViewAccessibility")
+		cameraView.setOnTouchListener(object : View.OnTouchListener {
+			var focus = true
+			var offset = -1f
+			var progress = 0
+
+			override fun onTouch(v: View?, event: MotionEvent?): Boolean {
+				event ?: return false
+				val pos = event.y
+				when (event.actionMasked) {
+					MotionEvent.ACTION_DOWN -> {
+						offset = pos
+						progress = zoomBar.progress
+						return true
+					}
+					MotionEvent.ACTION_MOVE -> {
+						if (prefs.zoomBySwiping) {
+							v ?: return false
+							val dist = offset - pos
+							val maxValue = zoomBar.max
+							val change = maxValue / v.height.toFloat() * 2f * dist
+							zoomBar.progress = min(
+								maxValue,
+								max(progress + change.roundToInt(), 0)
+							)
+							return true
+						}
+					}
+					MotionEvent.ACTION_UP -> {
+						// stop calling focusTo() as soon as it returns false
+						// to avoid throwing and catching future exceptions
+						if (focus) {
+							focus = cameraView.focusTo(v, event.x, event.y)
+							if (focus) {
+								v?.performClick()
+								return true
+							}
+						}
+					}
+				}
+				return false
+			}
+		})
+		@Suppress("DEPRECATION")
 		cameraView.setOnCameraListener(object : CameraView.OnCameraListener {
 			override fun onConfigureParameters(
 				parameters: Camera.Parameters
@@ -279,11 +314,7 @@ class CameraActivity : AppCompatActivity() {
 			}

 			override fun onCameraError() {
-				Toast.makeText(
-					this@CameraActivity,
-					R.string.camera_error,
-					Toast.LENGTH_SHORT
-				).show()
+				this@CameraActivity.toast(R.string.camera_error)
 				finish()
 			}

@@ -302,8 +333,17 @@ class CameraActivity : AppCompatActivity() {
 						)
 						result?.let {
 							cameraView.post {
-								vibrator.vibrate(100)
-								showResult(result)
+								val rp = result.resultPoints
+								val m = mapping
+								if (m != null && rp != null && rp.isNotEmpty()) {
+									detectorView.mark(m.map(rp))
+								}
+								vibrator.vibrate()
+								showResult(
+									this@CameraActivity,
+									result,
+									returnResult
+								)
 							}
 							decoding = false
 						}
@@ -337,6 +377,7 @@ class CameraActivity : AppCompatActivity() {
 		})
 	}

+	@Suppress("DEPRECATION")
 	private fun setZoom(zoom: Int) {
 		val camera: Camera? = cameraView.camera
 		camera?.let {
@@ -373,6 +414,7 @@ class CameraActivity : AppCompatActivity() {
 		}
 	}

+	@Suppress("DEPRECATION")
 	private fun toggleTorchMode() {
 		val camera = cameraView.camera
 		val parameters = camera?.parameters
@@ -398,96 +440,107 @@ class CameraActivity : AppCompatActivity() {
 		frameOrientation: Int
 	): Result? {
 		frameData ?: return null
-		if (preprocessor == null) {
-			preprocessor = Preprocessor(
-				this,
-				frameWidth,
-				frameHeight,
-				frameOrientation
-			)
-		}
-		val pp = preprocessor
-		pp ?: return null
-		try {
-			if (useRenderScript) {
-				pp.process(frameData)
-			}
-		} catch (e: RSRuntimeException) {
-			// because RenderScript fails on some devices/ROMS for
-			// unknown reasons (e.g. Lineage)
-			useRenderScript = false
-		}
 		invert = invert xor true
-		if (useRenderScript) {
-			return zxing.decode(frameData, pp.outWidth, pp.outHeight, invert)
-		} else {
-			val size = pp.outWidth * pp.outHeight
-			val fb = fallbackBuffer ?: IntArray(size)
-			fallbackBuffer = fb
-			val bmp = lumaToBitmap(
-				frameData,
-				frameWidth,
-				frameHeight,
-				frameOrientation,
-				pp.outWidth,
-				pp.outHeight
-			)
-			return zxing.decode(fb, bmp, invert)
-		}
+		val pp = preprocessor ?: createPreprocessorAndMapping(
+			frameWidth,
+			frameHeight,
+			frameOrientation
+		)
+		pp.process(frameData)
+		preprocessor = pp
+		return zxing.decode(
+			frameData,
+			pp.outWidth,
+			pp.outHeight,
+			invert
+		)
 	}

-	private fun showResult(result: Result) {
-		if (prefs.useHistory) {
-			GlobalScope.launch {
-				db.insertScan(
-					System.currentTimeMillis(),
-					result.text,
-					result.barcodeFormat.toString()
-				)
-			}
-		}
-
-		if (returnResult) {
-			val resultIntent = Intent()
-			resultIntent.putExtra("SCAN_RESULT", result.text)
-			setResult(RESULT_OK, resultIntent)
-			finish()
-			return
-		}
-
-		startActivity(
-			MainActivity.getDecodeIntent(
-				this,
-				result.text,
-				result.barcodeFormat
-			)
+	private fun createPreprocessorAndMapping(
+		frameWidth: Int,
+		frameHeight: Int,
+		frameOrientation: Int
+	): Preprocessor {
+		val pp = Preprocessor(
+			this,
+			frameWidth,
+			frameHeight,
+			frameOrientation
 		)
+		mapping = frameToView(
+			pp.outWidth,
+			pp.outHeight,
+			cameraView.previewRect
+		)
+		return pp
 	}

 	companion object {
 		private const val REQUEST_CAMERA = 1
+		private const val PICK_FILE_RESULT_CODE = 1
 		private const val ZOOM_MAX = "zoom_max"
 		private const val ZOOM_LEVEL = "zoom_level"
 	}
 }

-fun downsizeIfBigger(bitmap: Bitmap, max: Int): Bitmap {
-	return if (Math.max(bitmap.width, bitmap.height) > max) {
-		var width: Int = max
-		var height: Int = max
-		if (bitmap.width > bitmap.height) {
-			height = Math.round(
-				width.toFloat() / bitmap.width.toFloat() *
-						bitmap.height.toFloat()
-			)
-		} else {
-			width = Math.round(
-				height.toFloat() / bitmap.height.toFloat() *
-						bitmap.width.toFloat()
-			)
-		}
-		Bitmap.createScaledBitmap(bitmap, width, height, true)
+fun showResult(
+	activity: Activity,
+	result: Result,
+	isResult: Boolean = false
+) {
+	val scan = Scan(result)
+	if (isResult) {
+		activity.setResult(Activity.RESULT_OK, getReturnIntent(result))
+		activity.finish()
 	} else {
-		bitmap
+		if (prefs.useHistory) {
+			GlobalScope.launch {
+				db.insertScan(scan)
+			}
+		}
+		activity.startActivity(
+			MainActivity.getDecodeIntent(activity, 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)
+	}
+	result.resultMetadata?.let { metadata ->
+		metadata[ResultMetadataType.UPC_EAN_EXTENSION]?.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
+}
@@ -1,19 +1,22 @@
 package de.markusfisch.android.binaryeye.activity

-import com.google.zxing.BarcodeFormat
-
-import de.markusfisch.android.binaryeye.app.initSystemBars
-import de.markusfisch.android.binaryeye.app.setFragment
-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.R
-
 import android.content.Context
 import android.content.Intent
+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.colorSystemAndToolBars
+import de.markusfisch.android.binaryeye.app.initSystemBars
+import de.markusfisch.android.binaryeye.app.setFragment
+import de.markusfisch.android.binaryeye.data.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.setupInsets

 class MainActivity : AppCompatActivity() {
 	override fun onSupportNavigateUp(): Boolean {
@@ -29,33 +32,51 @@ class MainActivity : AppCompatActivity() {
 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
 		setContentView(R.layout.activity_main)
-		initSystemBars(this)

-		setSupportActionBar(findViewById(R.id.toolbar) as Toolbar)
+		initSystemBars(this)
+		val toolbar = findViewById(R.id.toolbar) as Toolbar
+		setupInsets(
+			findViewById(android.R.id.content),
+			toolbar
+		)
+		setSupportActionBar(toolbar)
 		supportActionBar?.setDisplayHomeAsUpEnabled(true)

+		supportFragmentManager.addOnBackStackChangedListener {
+			colorSystemAndToolBars(this@MainActivity)
+		}
+
 		if (state == null) {
-			setFragment(supportFragmentManager, when {
-				intent?.hasExtra(HISTORY) == true -> HistoryFragment()
-				intent?.hasExtra(ENCODE) == true -> EncodeFragment.newInstance(
-					intent.getStringExtra(ENCODE)
-				)
-				intent?.hasExtra(DECODE) == true -> DecodeFragment.newInstance(
-					intent.getStringExtra(DECODE),
-					intent.getSerializableExtra(
-						DECODE_FORMAT
-					) as BarcodeFormat
-				)
-				else -> DecodeFragment()
-			})
+			setFragment(supportFragmentManager, getFragmentForIntent(intent))
 		}
 	}

 	companion object {
+		private const val PREFERENCES = "preferences"
 		private const val HISTORY = "history"
 		private const val ENCODE = "encode"
-		private const val DECODE = "decode"
-		private const val DECODE_FORMAT = "decode_format"
+		private const val DECODED = "decoded"
+
+		private fun getFragmentForIntent(intent: Intent?): Fragment {
+			intent ?: return PreferencesFragment()
+			return when {
+				intent.hasExtra(PREFERENCES) -> PreferencesFragment()
+				intent.hasExtra(HISTORY) -> HistoryFragment()
+				intent.hasExtra(ENCODE) -> EncodeFragment.newInstance(
+					intent.getStringExtra(ENCODE)!!
+				)
+				intent.hasExtra(DECODED) -> DecodeFragment.newInstance(
+					intent.getParcelableExtra(DECODED)!!
+				)
+				else -> PreferencesFragment()
+			}
+		}
+
+		fun getPreferencesIntent(context: Context): Intent {
+			val intent = Intent(context, MainActivity::class.java)
+			intent.putExtra(PREFERENCES, true)
+			return intent
+		}

 		fun getHistoryIntent(context: Context): Intent {
 			val intent = Intent(context, MainActivity::class.java)
@@ -71,23 +92,22 @@ class MainActivity : AppCompatActivity() {
 			val intent = Intent(context, MainActivity::class.java)
 			intent.putExtra(ENCODE, text)
 			if (isExternal) {
+				val flagActivityClearTask =
+					if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+						Intent.FLAG_ACTIVITY_CLEAR_TASK
+					} else 0
 				intent.addFlags(
-					android.content.Intent.FLAG_ACTIVITY_NO_HISTORY or
-							android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK or
-							android.content.Intent.FLAG_ACTIVITY_NEW_TASK
+					Intent.FLAG_ACTIVITY_NO_HISTORY or
+							flagActivityClearTask or
+							Intent.FLAG_ACTIVITY_NEW_TASK
 				)
 			}
 			return intent
 		}

-		fun getDecodeIntent(
-			context: Context,
-			text: String,
-			format: BarcodeFormat
-		): Intent {
+		fun getDecodeIntent(context: Context, scan: Scan): Intent {
 			val intent = Intent(context, MainActivity::class.java)
-			intent.putExtra(DECODE, text)
-			intent.putExtra(DECODE_FORMAT, format)
+			intent.putExtra(DECODED, scan)
 			return intent
 		}
 	}
@@ -0,0 +1,149 @@
+package de.markusfisch.android.binaryeye.activity
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Bitmap
+import android.graphics.Point
+import android.graphics.Rect
+import android.net.Uri
+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.view.Menu
+import android.view.MenuItem
+import com.google.zxing.Result
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.app.colorSystemAndToolBars
+import de.markusfisch.android.binaryeye.app.initSystemBars
+import de.markusfisch.android.binaryeye.app.vibrate
+import de.markusfisch.android.binaryeye.graphics.crop
+import de.markusfisch.android.binaryeye.graphics.loadImageUri
+import de.markusfisch.android.binaryeye.graphics.mapResult
+import de.markusfisch.android.binaryeye.view.setWindowInsetListener
+import de.markusfisch.android.binaryeye.view.setupInsets
+import de.markusfisch.android.binaryeye.widget.CropImageView
+import de.markusfisch.android.binaryeye.widget.toast
+import de.markusfisch.android.binaryeye.zxing.Zxing
+
+class PickActivity : AppCompatActivity() {
+	private val zxing = Zxing()
+
+	private lateinit var vibrator: Vibrator
+	private lateinit var cropImageView: CropImageView
+
+	override fun onCreate(state: Bundle?) {
+		super.onCreate(state)
+		setContentView(R.layout.activity_pick)
+
+		zxing.updateHints(true)
+		vibrator = getSystemService(Context.VIBRATOR_SERVICE) as Vibrator
+
+		initSystemBars(this)
+		val toolbar = findViewById(R.id.toolbar) as Toolbar
+		setupInsets(findViewById(android.R.id.content), toolbar)
+		setSupportActionBar(toolbar)
+
+		supportFragmentManager.addOnBackStackChangedListener {
+			colorSystemAndToolBars(this@PickActivity)
+		}
+
+		val bitmap = if (
+			intent?.action == Intent.ACTION_SEND &&
+			intent.type?.startsWith("image/") == true
+		) {
+			loadSentImage(intent)
+		} else if (
+			intent?.action == Intent.ACTION_VIEW &&
+			intent.type?.startsWith("image/") == true
+		) {
+			loadImageToOpen(intent)
+		} else {
+			null
+		}
+
+		if (bitmap == null) {
+			applicationContext.toast(R.string.error_no_content)
+			finish()
+			return
+		}
+
+		val scannedRect = Rect()
+		val scanWithinBounds: () -> Result? = {
+			var result: Result? = null
+			crop(
+				bitmap,
+				cropImageView.normalizedRectInBounds,
+				cropImageView.imageRotation
+			)?.also {
+				scannedRect.set(0, 0, it.width, it.height)
+				result = zxing.decodePositiveNegative(it)
+			}
+			result
+		}
+
+		cropImageView = findViewById(R.id.image) as CropImageView
+		cropImageView.setImageBitmap(bitmap)
+		cropImageView.onScan = {
+			var points: List<Point>? = null
+			scanWithinBounds()?.let {
+				points = mapResult(
+					scannedRect.width(),
+					scannedRect.height(),
+					cropImageView.getBoundsRect(),
+					it
+				)
+				vibrator.vibrate()
+			}
+			points
+		}
+		setWindowInsetListener { insets ->
+			cropImageView.windowInsets.set(insets)
+		}
+
+		findViewById(R.id.scan).setOnClickListener {
+			scanImage(scanWithinBounds())
+		}
+	}
+
+	override fun onCreateOptionsMenu(menu: Menu): Boolean {
+		menuInflater.inflate(R.menu.activity_pick, menu)
+		return true
+	}
+
+	override fun onOptionsItemSelected(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.rotate -> {
+				rotateClockwise()
+				true
+			}
+			else -> super.onOptionsItemSelected(item)
+		}
+	}
+
+	private fun rotateClockwise() {
+		cropImageView.imageRotation = cropImageView.imageRotation + 90 % 360
+	}
+
+	private fun loadSentImage(intent: Intent): Bitmap? {
+		val uri = intent.getParcelableExtra<Parcelable>(
+			Intent.EXTRA_STREAM
+		) as? Uri ?: return null
+		return loadImageUri(contentResolver, uri)
+	}
+
+	private fun loadImageToOpen(intent: Intent): Bitmap? {
+		val uri = intent.data ?: return null
+		return loadImageUri(contentResolver, uri)
+	}
+
+	private fun scanImage(result: Result?) {
+		if (result != null) {
+			showResult(this, result)
+			finish()
+			return
+		}
+		applicationContext.toast(R.string.no_barcode_found)
+	}
+}
@@ -1,31 +1,45 @@
 package de.markusfisch.android.binaryeye.adapter

-import de.markusfisch.android.binaryeye.data.Database
-import de.markusfisch.android.binaryeye.R
-
 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
 import android.widget.CursorAdapter
 import android.widget.TextView
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.data.Database

 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 selectedColor = ContextCompat.getColor(context, R.color.selected_row)
+
+	fun select(id: Long, position: Int) {
+		selectedScanId = id
+		selectedScanPosition = position
+	}
+
+	fun clearSelection() {
+		selectedScanId = 0L
+		selectedScanPosition = -1
+	}

 	override fun newView(
 		context: Context,
 		cursor: Cursor,
 		parent: ViewGroup
-	): View {
-		return LayoutInflater.from(parent.context).inflate(
-			R.layout.row_scan, parent, false
-		)
-	}
+	) = LayoutInflater.from(parent.context).inflate(
+		R.layout.row_scan, parent, false
+	)

 	override fun bindView(
 		view: View,
@@ -34,21 +48,36 @@ class ScansAdapter(context: Context, cursor: Cursor) :
 	) {
 		val holder = getViewHolder(view)
 		holder.timeView.text = cursor.getString(timeIndex)
-		holder.contentView.text = cursor.getString(contentIndex)
+		val name = cursor.getString(nameIndex)
+		val content = cursor.getString(contentIndex)
+		var icon = 0
+		holder.contentView.text = when {
+			name?.isNotEmpty() == true -> {
+				icon = R.drawable.ic_label
+				name
+			}
+			content?.isEmpty() == true -> context.getString(R.string.binary_data)
+			else -> content
+		}
+		holder.contentView.setCompoundDrawablesWithIntrinsicBounds(
+			icon, 0, 0, 0
+		)
 		holder.formatView.text = cursor.getString(formatIndex)
+		// view.isSelected needs to be put on the queue to work
+		val selected = cursor.getLong(idIndex) == selectedScanId
+		view.post {
+			view.isSelected = selected
+		}
 	}

 	private fun getViewHolder(view: View): ViewHolder {
-		var holder = view.tag as ViewHolder?
-		if (holder == null) {
-			holder = ViewHolder(
-				view.findViewById(R.id.time),
-				view.findViewById(R.id.content),
-				view.findViewById(R.id.format)
-			)
-			view.tag = holder
+		return view.tag as ViewHolder? ?: ViewHolder(
+			view.findViewById(R.id.time),
+			view.findViewById(R.id.content),
+			view.findViewById(R.id.format)
+		).also {
+			view.tag = it
 		}
-		return holder
 	}

 	private data class ViewHolder(
@@ -0,0 +1,23 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.content.Context
+import android.support.v7.app.AlertDialog
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import kotlin.coroutines.resume
+import kotlin.coroutines.suspendCoroutine
+
+suspend inline fun <T : Any> alertDialog(
+	context: Context,
+	crossinline build: AlertDialog.Builder.(resume: (T?) -> Unit) -> Unit
+): T? = withContext(Dispatchers.Main) {
+	suspendCoroutine<T?> { continuation ->
+		AlertDialog.Builder(context).apply {
+			setOnCancelListener {
+				continuation.resume(null)
+			}
+			build(continuation::resume)
+			show()
+		}
+	}
+}
@@ -1,16 +1,33 @@
 package de.markusfisch.android.binaryeye.app

+import android.app.Application
+import android.support.v8.renderscript.RenderScript
+import de.markusfisch.android.binaryeye.BuildConfig
 import de.markusfisch.android.binaryeye.data.Database
 import de.markusfisch.android.binaryeye.preference.Preferences

-import android.app.Application
-
 val db = Database()
 val prefs = Preferences()

 class BinaryEyeApp : Application() {
 	override fun onCreate() {
 		super.onCreate()
+
+		// `RenderScript.forceCompat()` will crash the app when compiled
+		// on macOS Catalina with build tools 29.0.3 :( To make things
+		// even more complicated, `forceCompat()` will continue to work
+		// if the app is compiled on Linux with the exact same version
+		// 29.0.3 of the build tools
+		if (!BuildConfig.IS_CATALINA &&
+			System.getProperty("os.version")?.contains(
+				"lineageos", true
+			) == true
+		) {
+			// required to make RenderScript work for Lineage 16.0
+			// possibly because of a system/device bug
+			RenderScript.forceCompat()
+		}
+
 		db.open(this)
 		prefs.init(this)
 	}
@@ -0,0 +1,17 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.content.ClipData
+import android.content.Context
+import android.os.Build
+
+fun Context.copyToClipboard(text: String) {
+	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("simple text", text)
+		)
+	}
+}
@@ -1,11 +1,9 @@
 package de.markusfisch.android.binaryeye.app

-import de.markusfisch.android.binaryeye.R
-
 import android.annotation.SuppressLint
 import android.support.v4.app.Fragment
 import android.support.v4.app.FragmentManager
-import android.support.v4.app.FragmentTransaction
+import de.markusfisch.android.binaryeye.R

 fun setFragment(fm: FragmentManager?, fragment: Fragment) {
 	fm?.let { getTransaction(fm, fragment).commit() }
@@ -19,6 +17,4 @@ fun addFragment(fm: FragmentManager?, fragment: Fragment) {
 private fun getTransaction(
 	fm: FragmentManager,
 	fragment: Fragment
-): FragmentTransaction {
-	return fm.beginTransaction().replace(R.id.content_frame, fragment)
-}
+) = fm.beginTransaction().replace(R.id.content_frame, fragment)
@@ -0,0 +1,12 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.net.Uri
+import android.os.Build
+
+private val nonPrintable = "[\\x00-\\x08\\x0e-\\x1f]".toRegex()
+
+fun hasNonPrintableCharacters(s: String) = nonPrintable.containsMatchIn(s)
+
+fun parseAndNormalizeUri(input: String): Uri = Uri.parse(input).let {
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) it.normalizeScheme() else it
+}
@@ -0,0 +1,91 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.app.Activity
+import android.content.ContentValues
+import android.content.Context
+import android.os.Build
+import android.os.Environment
+import android.provider.MediaStore
+import android.support.annotation.MainThread
+import android.widget.EditText
+import de.markusfisch.android.binaryeye.R
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+
+fun addSuffixIfNotGiven(name: String, suffix: String): String {
+	val trimmed = name.trim()
+	return if (suffix.isNotEmpty() && !trimmed.endsWith(suffix)) {
+		"$trimmed$suffix"
+	} else {
+		trimmed
+	}
+}
+
+// Dialogs doesn't have any root layout, need to be inflated with null root
+@Suppress("InflateParams")
+@MainThread
+suspend fun Activity.askForFileName(suffix: String = ""): String? {
+	val view = layoutInflater.inflate(R.layout.dialog_save_file, null)
+	val editText = view.findViewById<EditText>(R.id.file_name)
+	return alertDialog<String>(this as Context) { resume ->
+		setView(view)
+		setPositiveButton(android.R.string.ok) { _, _ ->
+			resume(editText.text.toString())
+		}
+	}?.let { name ->
+		addSuffixIfNotGiven(name, suffix)
+	}
+}
+
+fun writeExternalFile(
+	context: Context,
+	fileName: String,
+	mimeType: String,
+	write: (outputStream: OutputStream) -> Any
+): Int = try {
+	val outputStream = getExternalOutputStream(
+		context,
+		fileName,
+		mimeType
+	) ?: throw IOException()
+	outputStream.use { write(it) }
+	R.string.saved_in_downloads
+} catch (e: FileAlreadyExistsException) {
+	R.string.error_file_exists
+} catch (e: IOException) {
+	R.string.error_saving_binary_data
+}
+
+private fun getExternalOutputStream(
+	context: Context,
+	fileName: String,
+	mimeType: String
+): OutputStream? = if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q) {
+	@Suppress("DEPRECATION")
+	val file = File(
+		Environment.getExternalStoragePublicDirectory(
+			Environment.DIRECTORY_DOWNLOADS
+		),
+		fileName
+	)
+	if (file.exists()) {
+		throw FileAlreadyExistsException(file)
+	}
+	FileOutputStream(file)
+} else {
+	val resolver = context.contentResolver
+	val uri = resolver.insert(
+		MediaStore.Downloads.EXTERNAL_CONTENT_URI,
+		ContentValues().apply {
+			put(MediaStore.Downloads.DISPLAY_NAME, fileName)
+			put(MediaStore.Downloads.MIME_TYPE, mimeType)
+		}
+	)
+	if (uri != null) {
+		resolver.openOutputStream(uri)
+	} else {
+		null
+	}
+}
@@ -0,0 +1,27 @@
+package de.markusfisch.android.binaryeye.app
+
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.emitAll
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.flow.scanReduce
+
+@ExperimentalCoroutinesApi
+fun Flow<ByteArray>.addDelimiter(delimiter: String) = addDelimiter(
+	delimiter.toByteArray(),
+	ByteArray::plus
+)
+
+@ExperimentalCoroutinesApi
+inline fun <T, R> Flow<T>.addDelimiter(
+	delimiter: R,
+	crossinline append: R.(T) -> T
+): Flow<T> = scanReduce { _, content ->
+	delimiter.append(content)
+}
+
+@ExperimentalCoroutinesApi
+infix fun <T> T.asFlowWith(other: Flow<T>) = flow<T> {
+	emit(this@asFlowWith)
+	emitAll(other)
+}
@@ -0,0 +1,13 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.content.Context
+import android.view.View
+import android.view.inputmethod.InputMethodManager
+
+fun Context.hideSoftKeyboard(view: View) {
+	(getSystemService(
+		Context.INPUT_METHOD_SERVICE
+	) as InputMethodManager).hideSoftInputFromWindow(
+		view.windowToken, 0
+	)
+}
@@ -0,0 +1,46 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.Manifest
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.support.v4.app.ActivityCompat
+import android.support.v4.content.ContextCompat
+
+fun hasCameraPermission(activity: Activity, requestCode: Int = 1): Boolean {
+	return hasPermission(activity, Manifest.permission.CAMERA, requestCode)
+}
+
+fun hasWritePermission(activity: Activity, requestCode: Int = 2): Boolean {
+	return hasPermission(
+		activity,
+		Manifest.permission.WRITE_EXTERNAL_STORAGE,
+		requestCode
+	)
+}
+
+fun hasLocationPermission(activity: Activity, requestCode: Int = 3): Boolean {
+	return hasPermission(
+		activity,
+		Manifest.permission.ACCESS_FINE_LOCATION,
+		requestCode
+	)
+}
+
+fun hasPermission(
+	activity: Activity,
+	permission: String,
+	requestCode: Int
+): Boolean {
+	return if (ContextCompat.checkSelfPermission(activity, permission) !=
+		PackageManager.PERMISSION_GRANTED
+	) {
+		ActivityCompat.requestPermissions(
+			activity,
+			arrayOf(permission),
+			requestCode
+		)
+		false
+	} else {
+		true
+	}
+}
@@ -3,12 +3,18 @@ package de.markusfisch.android.binaryeye.app
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
+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.widget.toast
+import java.io.File

 fun shareText(context: Context, text: String, type: String = "text/plain") {
 	val intent = Intent(Intent.ACTION_SEND)
 	intent.putExtra(Intent.EXTRA_TEXT, text)
 	intent.type = type
-	context.startActivity(intent)
+	execShareIntent(context, intent)
 }

 fun shareUri(context: Context, uri: Uri, type: String) {
@@ -16,5 +22,29 @@ fun shareUri(context: Context, uri: Uri, type: String) {
 	intent.putExtra(Intent.EXTRA_STREAM, uri)
 	intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
 	intent.type = type
-	context.startActivity(intent)
+	execShareIntent(context, intent)
+}
+
+fun execShareIntent(context: Context, intent: Intent) {
+	if (intent.resolveActivity(context.packageManager) != null) {
+		context.startActivity(intent)
+	} else {
+		context.toast(R.string.cannot_resolve_action)
+	}
+}
+
+fun shareFile(context: Context, file: File, type: String) {
+	shareUri(context, getUriForFile(context, file), type)
+}
+
+fun getUriForFile(context: Context, file: File): Uri {
+	return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+		Uri.fromFile(file)
+	} else {
+		FileProvider.getUriForFile(
+			context,
+			BuildConfig.APPLICATION_ID + ".provider",
+			file
+		)
+	}
 }
@@ -1,49 +1,117 @@
 package de.markusfisch.android.binaryeye.app

-import de.markusfisch.android.binaryeye.R
-
-import android.content.res.Resources
+import android.content.Context
+import android.content.ContextWrapper
+import android.graphics.drawable.ColorDrawable
 import android.os.Build
 import android.support.v4.content.ContextCompat
 import android.support.v7.app.AppCompatActivity
 import android.view.View
-import android.view.Window
+import android.widget.AbsListView
+import de.markusfisch.android.binaryeye.R

-fun initSystemBars(activity: AppCompatActivity?) {
-	val view = activity?.findViewById(R.id.main_layout)
-	if (view != null &&
-		setSystemBarColor(
-			activity.window,
-			ContextCompat.getColor(
-				activity,
-				R.color.primary_dark_translucent
-			)
-		)
+val systemBarScrollListener = object : AbsListView.OnScrollListener {
+	override fun onScroll(
+		view: AbsListView,
+		firstVisibleItem: Int,
+		visibleItemCount: Int,
+		totalItemCount: Int
+	) {
+		// give Android some time to settle down before running this,
+		// not putting it on the queue makes it only work sometimes
+		view.post {
+			val scrolled = firstVisibleItem > 0 ||
+					(totalItemCount > 0 && firstChildScrolled(view))
+			val scrollable = if (scrolled) {
+				true
+			} else {
+				totalItemCount > 0 && lastChildOutOfView(view)
+			}
+			colorSystemAndToolBars(view.context, scrolled, scrollable)
+		}
+	}
+
+	override fun onScrollStateChanged(
+		view: AbsListView,
+		scrollState: Int
 	) {
-		view.setPadding(0, getStatusBarHeight(activity.resources), 0, 0)
 	}
 }

-fun setSystemBarColor(window: Window, color: Int): Boolean {
-	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
-		return false
+private fun firstChildScrolled(listView: AbsListView): Boolean {
+	val child = listView.getChildAt(0)
+	return child != null && child.top < listView.paddingTop
+}
+
+private fun lastChildOutOfView(listView: AbsListView): Boolean {
+	val child = listView.getChildAt(listView.lastVisiblePosition)
+	return child.bottom >= listView.height
+}
+
+fun initSystemBars(activity: AppCompatActivity) {
+	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+		activity.window.decorView.systemUiVisibility =
+			View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+					View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
+					View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
 	}
-
-	window.statusBarColor = color
-	window.navigationBarColor = color
-	window.decorView.systemUiVisibility =
-		View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
-				View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
-				View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
-
-	return true
+	colorSystemAndToolBars(activity)
 }

-fun getStatusBarHeight(res: Resources): Int {
-	return getIdentifierDimen(res, "status_bar_height")
+private var statusBarColorLocked = false
+fun lockStatusBarColor() {
+	statusBarColorLocked = true
 }

-private fun getIdentifierDimen(res: Resources, name: String): Int {
-	val id = res.getIdentifier(name, "dimen", "android")
-	return if (id > 0) res.getDimensionPixelSize(id) else 0
+fun unlockStatusBarColor() {
+	statusBarColorLocked = false
+}
+
+private var translucentPrimaryColor = 0
+private val actionBarBackground = ColorDrawable()
+fun colorSystemAndToolBars(
+	context: Context,
+	scrolled: Boolean = false,
+	scrollable: Boolean = false
+) {
+	if (translucentPrimaryColor == 0) {
+		translucentPrimaryColor = ContextCompat.getColor(
+			context,
+			R.color.primary_translucent
+		)
+	}
+	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
+		} else {
+			0
+		}
+	}
+	activity.supportActionBar?.setBackgroundDrawable(
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+			// avoid allocation on Honeycomb and better
+			actionBarBackground.color = topColor
+			actionBarBackground
+		} else {
+			// ColorDrawable.setColor() doesn't exist pre Honeycomb
+			ColorDrawable(topColor)
+		}
+	)
+}
+
+private fun getAppCompatActivity(context: Context): AppCompatActivity? {
+	var ctx = context
+	while (ctx is ContextWrapper) {
+		if (ctx is AppCompatActivity) {
+			return ctx
+		}
+		ctx = ctx.baseContext ?: break
+	}
+	return null
 }
@@ -0,0 +1,24 @@
+package de.markusfisch.android.binaryeye.app
+
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+
+private const val MILLISECONDS = 100L
+
+fun Vibrator.vibrate() {
+	if (!prefs.vibrate) {
+		return
+	}
+	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+		@Suppress("DEPRECATION")
+		this.vibrate(MILLISECONDS)
+	} else {
+		this.vibrate(
+			VibrationEffect.createOneShot(
+				MILLISECONDS,
+				VibrationEffect.DEFAULT_AMPLITUDE
+			)
+		)
+	}
+}
@@ -5,7 +5,8 @@ import android.content.Context
 import android.database.Cursor
 import android.database.sqlite.SQLiteDatabase
 import android.database.sqlite.SQLiteOpenHelper
-import android.text.format.DateFormat
+import de.markusfisch.android.binaryeye.app.hasNonPrintableCharacters
+import de.markusfisch.android.binaryeye.app.prefs

 class Database {
 	private lateinit var db: SQLiteDatabase
@@ -14,40 +15,160 @@ class Database {
 		db = OpenHelper(context).writableDatabase
 	}

-	fun getScans(): Cursor? = db.rawQuery(
+	fun getScans(query: String? = null): Cursor? = db.rawQuery(
 		"""SELECT
 			$SCANS_ID,
 			$SCANS_DATETIME,
+			$SCANS_NAME,
 			$SCANS_CONTENT,
 			$SCANS_FORMAT
 			FROM $SCANS
+			${getWhereClause(query)}
 			ORDER BY $SCANS_DATETIME DESC
-		""", null
+		""", getWhereArguments(query)
 	)

-	fun getScan(id: Long): Cursor? = db.rawQuery(
+	fun getScansDetailed(query: String? = null): Cursor? = db.rawQuery(
 		"""SELECT
+			$SCANS_ID,
 			$SCANS_DATETIME,
+			$SCANS_NAME,
 			$SCANS_CONTENT,
-			$SCANS_FORMAT
+			$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
+			FROM $SCANS
+			${getWhereClause(query)}
+			ORDER BY $SCANS_DATETIME DESC
+		""", getWhereArguments(query)
+	)
+
+	private fun getWhereClause(query: String?) = if (query?.isNotEmpty() == true) {
+		"""WHERE $SCANS_CONTENT LIKE ?
+			OR $SCANS_NAME LIKE ?"""
+	} else {
+		""
+	}
+
+	private fun getWhereArguments(query: String?) = if (query?.isNotEmpty() == true) {
+		val instr = "%$query%"
+		arrayOf(instr, instr)
+	} else {
+		null
+	}
+
+	fun getScan(id: Long): Scan? = db.rawQuery(
+		"""SELECT
+			$SCANS_ID,
+			$SCANS_DATETIME,
+			$SCANS_NAME,
+			$SCANS_CONTENT,
+			$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
 			FROM $SCANS
 			WHERE $SCANS_ID = ?
 		""", arrayOf("$id")
-	)
+	)?.use {
+		if (it.moveToFirst()) {
+			Scan(
+				it.getString(SCANS_CONTENT),
+				it.getBlob(SCANS_RAW),
+				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_DATETIME),
+				it.getLong(SCANS_ID)
+			)
+		} else {
+			null
+		}
+	}

-	fun insertScan(timestamp: Long, name: String, code: String): Long {
+	fun insertScan(scan: Scan): Long {
 		val cv = ContentValues()
-		cv.put(
-			SCANS_DATETIME, DateFormat.format(
-				"yyyy-MM-dd HH:mm:ss",
-				timestamp
-			).toString()
-		)
-		cv.put(SCANS_CONTENT, name)
-		cv.put(SCANS_FORMAT, code)
+		cv.put(SCANS_DATETIME, scan.timestamp)
+		val isRaw = hasNonPrintableCharacters(scan.content)
+		if (isRaw) {
+			cv.put(SCANS_CONTENT, "")
+			cv.put(SCANS_RAW, scan.raw ?: scan.content.toByteArray())
+		} else {
+			cv.put(SCANS_CONTENT, scan.content)
+		}
+		cv.put(SCANS_FORMAT, scan.format)
+		scan.errorCorrectionLevel?.let {
+			cv.put(SCANS_ERROR_CORRECTION_LEVEL, it)
+		}
+		scan.issueNumber?.let { cv.put(SCANS_ISSUE_NUMBER, it) }
+		scan.orientation?.let { cv.put(SCANS_ORIENTATION, it) }
+		scan.otherMetaData?.let { cv.put(SCANS_OTHER_META_DATA, it) }
+		scan.pdf417ExtraMetaData?.let { cv.put(SCANS_PDF417_EXTRA_METADATA, it) }
+		scan.possibleCountry?.let { cv.put(SCANS_POSSIBLE_COUNTRY, it) }
+		scan.suggestedPrice?.let { cv.put(SCANS_SUGGESTED_PRICE, it) }
+		scan.upcEanExtension?.let { cv.put(SCANS_UPC_EAN_EXTENSION, it) }
+		if (prefs.ignoreConsecutiveDuplicates) {
+			val id = getIdOfLastScan(
+				cv.get(SCANS_CONTENT) as String,
+				if (isRaw) cv.get(SCANS_RAW) as ByteArray else null,
+				scan.format
+			)
+			if (id > 0L) {
+				return id
+			}
+		}
 		return db.insert(SCANS, null, cv)
 	}

+	private fun getIdOfLastScan(
+		content: String,
+		raw: ByteArray?,
+		format: String
+	): Long {
+		return db.rawQuery(
+			"""SELECT
+				$SCANS_ID,
+				$SCANS_CONTENT,
+				$SCANS_RAW,
+				$SCANS_FORMAT
+				FROM $SCANS
+				ORDER BY $SCANS_ID DESC
+				LIMIT 1
+			""", null
+		)?.use {
+			if (it.count > 0 &&
+				it.moveToFirst() &&
+				it.getString(it.getColumnIndex(SCANS_CONTENT)) == content &&
+				(raw == null || it.getBlob(it.getColumnIndex(SCANS_RAW))
+					?.contentEquals(raw) == true) &&
+				it.getString(it.getColumnIndex(SCANS_FORMAT)) == format
+			) {
+				it.getLong(it.getColumnIndex(SCANS_ID))
+			} else {
+				0L
+			}
+		} ?: 0L
+	}
+
 	fun removeScan(id: Long) {
 		db.delete(SCANS, "$SCANS_ID = ?", arrayOf("$id"))
 	}
@@ -56,8 +177,14 @@ class Database {
 		db.delete(SCANS, null, null)
 	}

+	fun renameScan(id: Long, name: String) {
+		val cv = ContentValues()
+		cv.put(SCANS_NAME, name)
+		db.update(SCANS, cv, "$SCANS_ID = ?", arrayOf("$id"))
+	}
+
 	private class OpenHelper(context: Context) :
-		SQLiteOpenHelper(context, "history.db", null, 1) {
+		SQLiteOpenHelper(context, "history.db", null, 4) {
 		override fun onCreate(db: SQLiteDatabase) {
 			createScans(db)
 		}
@@ -67,6 +194,15 @@ class Database {
 			oldVersion: Int,
 			newVersion: Int
 		) {
+			if (oldVersion < 2) {
+				addRawColumn(db)
+			}
+			if (oldVersion < 3) {
+				addMetaDataColumns(db)
+			}
+			if (oldVersion < 4) {
+				addNameColumn(db)
+			}
 		}
 	}

@@ -74,8 +210,18 @@ class Database {
 		const val SCANS = "scans"
 		const val SCANS_ID = "_id"
 		const val SCANS_DATETIME = "_datetime"
+		const val SCANS_NAME = "name"
 		const val SCANS_CONTENT = "content"
+		const val SCANS_RAW = "raw"
 		const val SCANS_FORMAT = "format"
+		const val SCANS_ERROR_CORRECTION_LEVEL = "error_correction_level"
+		const val SCANS_ISSUE_NUMBER = "issue_number"
+		const val SCANS_ORIENTATION = "orientation"
+		const val SCANS_OTHER_META_DATA = "other_meta_data"
+		const val SCANS_PDF417_EXTRA_METADATA = "pdf417_extra_metadata"
+		const val SCANS_POSSIBLE_COUNTRY = "possible_country"
+		const val SCANS_SUGGESTED_PRICE = "suggested_price"
+		const val SCANS_UPC_EAN_EXTENSION = "upc_ean_extension"

 		private fun createScans(db: SQLiteDatabase) {
 			db.execSQL("DROP TABLE IF EXISTS $SCANS")
@@ -83,10 +229,51 @@ class Database {
 				"""CREATE TABLE $SCANS (
 					$SCANS_ID INTEGER PRIMARY KEY AUTOINCREMENT,
 					$SCANS_DATETIME DATETIME NOT NULL,
+					$SCANS_NAME TEXT,
 					$SCANS_CONTENT TEXT NOT NULL,
-					$SCANS_FORMAT TEXT NOT NULL
+					$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
 				)"""
 			)
 		}
+
+		private fun addRawColumn(db: SQLiteDatabase) {
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_RAW BLOB")
+		}
+
+		private fun addMetaDataColumns(db: SQLiteDatabase) {
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ERROR_CORRECTION_LEVEL TEXT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ISSUE_NUMBER INT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_ORIENTATION INT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_OTHER_META_DATA TEXT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_PDF417_EXTRA_METADATA TEXT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_POSSIBLE_COUNTRY TEXT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_SUGGESTED_PRICE TEXT")
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_UPC_EAN_EXTENSION TEXT")
+		}
+
+		private fun addNameColumn(db: SQLiteDatabase) {
+			db.execSQL("ALTER TABLE $SCANS ADD COLUMN $SCANS_NAME TEXT")
+		}
 	}
 }
+
+private fun Cursor.getString(name: String) = this.getString(
+	this.getColumnIndex(name)
+)
+
+private fun Cursor.getBlob(name: String) = this.getBlob(
+	this.getColumnIndex(name)
+)
+
+private fun Cursor.getLong(name: String) = this.getLong(
+	this.getColumnIndex(name)
+)
@@ -0,0 +1,85 @@
+package de.markusfisch.android.binaryeye.data
+
+import android.content.Context
+import android.database.Cursor
+import de.markusfisch.android.binaryeye.app.writeExternalFile
+
+fun exportCsv(
+	context: Context,
+	name: String,
+	cursor: Cursor,
+	delimiter: String
+) {
+	if (!cursor.moveToFirst()) {
+		return
+	}
+	val columns = arrayOf(
+		Database.SCANS_DATETIME,
+		Database.SCANS_FORMAT,
+		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
+	)
+	val indices = columns.map {
+		cursor.getColumnIndex(it)
+	}
+	val contentIndex = cursor.getColumnIndex(Database.SCANS_CONTENT)
+	val rawIndex = cursor.getColumnIndex(Database.SCANS_RAW)
+	writeExternalFile(context, name, "text/csv") { outputStream ->
+		outputStream.write(
+			columns.joinToString(
+				delimiter,
+				postfix = "\n"
+			).toByteArray()
+		)
+		do {
+			var deviation: Pair<Int, String>? = null
+			if (cursor.getString(contentIndex)?.isEmpty() == true) {
+				deviation = Pair(
+					contentIndex,
+					cursor.getBlob(rawIndex).toHexString()
+				)
+			}
+			outputStream.write(
+				cursor.toCsvRecord(indices, delimiter, deviation)
+			)
+		} while (cursor.moveToNext())
+	}
+}
+
+private fun ByteArray.toHexString(): String {
+	val hex = StringBuilder()
+	for (i in this.indices) {
+		hex.append(String.format("%02X", this[i]))
+	}
+	return hex.toString()
+}
+
+private fun Cursor.toCsvRecord(
+	indices: List<Int>,
+	delimiter: String,
+	deviation: Pair<Int, String>?
+): ByteArray {
+	val sb = StringBuilder()
+	indices.forEach {
+		val value = if (deviation?.first == it) {
+			deviation.second
+		} else {
+			this.getString(it)
+		}
+		sb.append(value?.quoteAndEscape() ?: "")
+		sb.append(delimiter)
+	}
+	sb.append("\n")
+	return sb.toString().toByteArray()
+}
+
+private fun String.quoteAndEscape() = "\"${this
+	.replace("\n", " ")
+	.replace("\"", "\"\"")}\""
@@ -0,0 +1,169 @@
+package de.markusfisch.android.binaryeye.data
+
+import android.os.Parcel
+import android.os.Parcelable
+import android.text.format.DateFormat
+import com.google.zxing.Result
+import com.google.zxing.ResultMetadataType
+
+data class Scan(
+	val content: 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 timestamp: String = getDateTime(),
+	val id: Long = 0L
+) : Parcelable {
+	constructor(result: Result) : this(
+		result.text,
+		getRawBytes(result),
+		result.barcodeFormat.toString(),
+		result.getMetaString(ResultMetadataType.ERROR_CORRECTION_LEVEL),
+		result.getMetaString(ResultMetadataType.ISSUE_NUMBER),
+		result.getMetaString(ResultMetadataType.ORIENTATION),
+		result.getMetaString(ResultMetadataType.OTHER),
+		result.getMetaString(ResultMetadataType.PDF417_EXTRA_METADATA),
+		result.getMetaString(ResultMetadataType.POSSIBLE_COUNTRY),
+		result.getMetaString(ResultMetadataType.SUGGESTED_PRICE),
+		result.getMetaString(ResultMetadataType.UPC_EAN_EXTENSION)
+	)
+
+	// Needs to be overwritten manually, as ByteArray is an array and
+	// this isn't handled well by Kotlin
+	override fun equals(other: Any?): Boolean {
+		if (this === other) {
+			return true
+		}
+		if (javaClass != other?.javaClass) {
+			return false
+		}
+
+		other as Scan
+
+		return id == other.id &&
+				timestamp == other.timestamp &&
+				content == other.content &&
+				((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
+	}
+
+	// Needs to be overwritten manually, as ByteArray is an array and
+	// this isn't handled well by Kotlin
+	override fun hashCode(): Int {
+		var result = id.hashCode()
+		result = 31 * result + timestamp.hashCode()
+		result = 31 * result + content.hashCode()
+		result = 31 * result + (raw?.contentHashCode() ?: 0)
+		result = 31 * result + format.hashCode()
+		result = 31 * result + (errorCorrectionLevel?.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() ?: "",
+		raw = readByteArray(parcel),
+		format = parcel.readString() ?: "",
+		errorCorrectionLevel = parcel.readString(),
+		issueNumber = parcel.readString(),
+		orientation = parcel.readString(),
+		otherMetaData = parcel.readString(),
+		pdf417ExtraMetaData = parcel.readString(),
+		possibleCountry = parcel.readString(),
+		suggestedPrice = parcel.readString(),
+		upcEanExtension = parcel.readString(),
+		timestamp = parcel.readString() ?: "",
+		id = parcel.readLong()
+	)
+
+	override fun writeToParcel(parcel: Parcel, flags: Int) {
+		parcel.writeString(content)
+		writeByteArray(parcel, raw)
+		parcel.writeString(format)
+		parcel.writeString(errorCorrectionLevel)
+		parcel.writeString(issueNumber)
+		parcel.writeString(orientation)
+		parcel.writeString(otherMetaData)
+		parcel.writeString(pdf417ExtraMetaData)
+		parcel.writeString(possibleCountry)
+		parcel.writeString(suggestedPrice)
+		parcel.writeString(upcEanExtension)
+		parcel.writeString(timestamp)
+		parcel.writeLong(id)
+	}
+
+	override fun describeContents() = 0
+
+	companion object {
+		@JvmField
+		val CREATOR = object : Parcelable.Creator<Scan> {
+			override fun createFromParcel(parcel: Parcel) = Scan(parcel)
+			override fun newArray(size: Int) = arrayOfNulls<Scan>(size)
+		}
+	}
+}
+
+private fun getDateTime(time: Long = System.currentTimeMillis()) = DateFormat.format(
+	"yyyy-MM-dd HH:mm:ss",
+	time
+).toString()
+
+private fun getRawBytes(result: Result): ByteArray? {
+	val metadata = result.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
+	}
+	// byte segments can never be shorter than the text.
+	// Zxing cuts off content prefixes like "WIFI:"
+	return if (bytes.size >= result.text.length) bytes else null
+}
+
+private fun Result.getMetaString(
+	key: ResultMetadataType
+): String? = this.resultMetadata?.let {
+	it[key]?.toString()
+}
+
+private fun writeByteArray(parcel: Parcel, array: ByteArray?) {
+	val size = array?.size ?: 0
+	parcel.writeInt(size)
+	if (size > 0) {
+		parcel.writeByteArray(array)
+	}
+}
+
+private fun readByteArray(parcel: Parcel): ByteArray? {
+	val size = parcel.readInt()
+	return if (size > 0) {
+		val array = ByteArray(size)
+		parcel.readByteArray(array)
+		array
+	} else {
+		null
+	}
+}
@@ -1,39 +1,48 @@
 package de.markusfisch.android.binaryeye.fragment

-import com.google.zxing.BarcodeFormat
-
-import de.markusfisch.android.binaryeye.app.shareUri
-import de.markusfisch.android.binaryeye.zxing.Zxing
-import de.markusfisch.android.binaryeye.BuildConfig
-import de.markusfisch.android.binaryeye.R
-
-import android.net.Uri
-import android.os.Build
-import android.os.Bundle
+import android.annotation.SuppressLint
+import android.app.AlertDialog
 import android.graphics.Bitmap
+import android.os.Bundle
 import android.support.v4.app.Fragment
-import android.support.v4.content.FileProvider
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.widget.ImageView
-import android.widget.Toast
-
-import java.io.File
-import java.io.FileOutputStream
-import java.io.IOException
-
+import android.view.*
+import android.widget.EditText
+import com.google.zxing.BarcodeFormat
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.app.addSuffixIfNotGiven
+import de.markusfisch.android.binaryeye.app.hasWritePermission
+import de.markusfisch.android.binaryeye.app.shareFile
+import de.markusfisch.android.binaryeye.app.writeExternalFile
+import de.markusfisch.android.binaryeye.view.setPadding
+import de.markusfisch.android.binaryeye.view.setWindowInsetListener
+import de.markusfisch.android.binaryeye.widget.ConfinedScalingImageView
+import de.markusfisch.android.binaryeye.widget.toast
+import de.markusfisch.android.binaryeye.zxing.Zxing
 import kotlinx.coroutines.Dispatchers.Main
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.launch
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.OutputStream
+import java.util.*

 class BarcodeFragment : Fragment() {
+	private var barcode: Bitmap? = null
+	private var content: String = ""
+	private var format: BarcodeFormat? = null
+
+	override fun onCreate(state: Bundle?) {
+		super.onCreate(state)
+		setHasOptionsMenu(true)
+	}
+
 	override fun onCreateView(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
 		state: Bundle?
 	): View? {
-		activity.setTitle(R.string.view_barcode)
+		activity?.setTitle(R.string.view_barcode)

 		val view = inflater.inflate(
 			R.layout.fragment_barcode,
@@ -41,80 +50,126 @@ class BarcodeFragment : Fragment() {
 			false
 		)

-		val args = arguments
-		args?.let {
-			val content = args.getString(CONTENT)
-			val format = args.getSerializable(FORMAT) as BarcodeFormat?
-			if (content != null && format != null) {
-				val size = args.getInt(SIZE)
-				val bitmap: Bitmap?
-				try {
-					bitmap = Zxing.encodeAsBitmap(
-						content,
-						format,
-						size,
-						size
-					)
-				} catch (e: Exception) {
-					Toast.makeText(
-						activity,
-						e.message,
-						Toast.LENGTH_SHORT
-					).show()
-					fragmentManager.popBackStack()
-					return null
-				}
-				view.findViewById<ImageView>(R.id.barcode).setImageBitmap(bitmap)
-				view.findViewById<View>(R.id.share).setOnClickListener {
-					bitmap?.let {
-						share(bitmap)
-					}
-				}
+		val args = arguments ?: return view
+		val content = args.getString(CONTENT) ?: return view
+		val format = args.getSerializable(FORMAT) as BarcodeFormat? ?: return view
+		val size = args.getInt(SIZE)
+		try {
+			barcode = Zxing.encodeAsBitmap(content, format, size, size)
+		} catch (e: Exception) {
+			var message = e.message
+			if (message == null || message.isEmpty()) {
+				message = getString(R.string.error_encoding_barcode)
 			}
+			message?.let {
+				activity.toast(message)
+			}
+			fragmentManager.popBackStack()
+			return null
+		}
+		this.content = content
+		this.format = format
+
+		val imageView = view.findViewById<ConfinedScalingImageView>(
+			R.id.barcode
+		)
+		imageView.setImageBitmap(barcode)
+		imageView.post {
+			// make sure to invoke this after ScalingImageView.onLayout()
+			imageView.minWidth /= 2f
+		}
+
+		view.findViewById<View>(R.id.share).setOnClickListener {
+			val bitmap = barcode
+			bitmap?.let {
+				share(bitmap)
+			}
+		}
+
+		setWindowInsetListener { insets ->
+			(view.findViewById(R.id.inset_layout) as View).setPadding(insets)
+			imageView.insets.set(insets)
 		}

 		return view
 	}

-	private fun share(bitmap: Bitmap) {
-		GlobalScope.launch {
-			val file = saveBitmap(bitmap)
-			GlobalScope.launch(Main) {
-				file?.let {
-					shareUri(
-						context,
-						getUriForFile(file),
-						"image/png"
+	override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
+		inflater.inflate(R.menu.fragment_barcode, menu)
+	}
+
+	override fun onOptionsItemSelected(item: MenuItem): Boolean {
+		return when (item.itemId) {
+			R.id.save -> {
+				askForFileNameAndSave()
+				true
+			}
+			else -> super.onOptionsItemSelected(item)
+		}
+	}
+
+	// dialogs do not have a parent view
+	@SuppressLint("InflateParams")
+	private fun askForFileNameAndSave() {
+		val ac = activity ?: 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"))
+		AlertDialog.Builder(ac)
+			.setView(view)
+			.setPositiveButton(android.R.string.ok) { _, _ ->
+				val bitmap = barcode
+				bitmap?.let {
+					saveAsFile(
+						bitmap,
+						addSuffixIfNotGiven(
+							editText.text.toString(),
+							".png"
+						)
 					)
 				}
 			}
+			.setNegativeButton(android.R.string.cancel) { _, _ ->
+			}
+			.show()
+	}
+
+	private fun saveAsFile(bitmap: Bitmap, fileName: String) {
+		val ac = activity ?: return
+		if (!hasWritePermission(ac)) {
+			return
+		}
+		GlobalScope.launch {
+			val message = writeExternalFile(ac, fileName, "image/png") {
+				bitmap.saveAsPng(it)
+			}
+			GlobalScope.launch(Main) {
+				ac.toast(message)
+			}
 		}
 	}

-	private fun saveBitmap(bitmap: Bitmap): File? {
-		return try {
+	private fun share(bitmap: Bitmap) {
+		GlobalScope.launch {
 			val file = File(
 				context.externalCacheDir,
 				"shared_barcode.png"
 			)
-			val fos = FileOutputStream(file)
-			bitmap.compress(Bitmap.CompressFormat.PNG, 90, fos)
-			fos.close()
-			file
-		} catch (e: IOException) {
-			null
-		}
-	}
-
-	private fun getUriForFile(file: File): Uri {
-		return if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
-			Uri.fromFile(file)
-		} else {
-			FileProvider.getUriForFile(
-				context,
-				BuildConfig.APPLICATION_ID + ".provider",
-				file
-			)
+			val success = try {
+				FileOutputStream(file).use {
+					bitmap.saveAsPng(it)
+				}
+				true
+			} catch (e: IOException) {
+				false
+			}
+			GlobalScope.launch(Main) {
+				if (success) {
+					shareFile(context, file, "image/png")
+				} else {
+					activity?.toast(R.string.error_saving_binary_data)
+				}
+			}
 		}
 	}

@@ -138,3 +193,11 @@ class BarcodeFragment : Fragment() {
 		}
 	}
 }
+
+private fun Bitmap.saveAsPng(outputStream: OutputStream, quality: Int = 90) {
+	this.compress(Bitmap.CompressFormat.PNG, quality, outputStream)
+}
+
+private val fileNameCharacters = "[^A-Za-z0-9]".toRegex()
+private fun encodeFileName(name: String): String =
+	fileNameCharacters.replace(name, "_").take(16).trim('_').toLowerCase(Locale.getDefault())
@@ -1,35 +1,44 @@
 package de.markusfisch.android.binaryeye.fragment

-import com.google.zxing.BarcodeFormat
-
-import de.markusfisch.android.binaryeye.app.addFragment
-import de.markusfisch.android.binaryeye.app.shareText
-import de.markusfisch.android.binaryeye.R
-
-import android.content.Context
-import android.content.Intent
-import android.net.Uri
 import android.os.Build
 import android.os.Bundle
+import android.support.design.widget.FloatingActionButton
 import android.support.v4.app.Fragment
-import android.text.ClipboardManager
 import android.text.Editable
 import android.text.TextWatcher
-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.view.*
 import android.widget.EditText
+import android.widget.TableLayout
+import android.widget.TableRow
 import android.widget.TextView
-import android.widget.Toast
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.actions.ActionRegistry
+import de.markusfisch.android.binaryeye.actions.wifi.WifiAction
+import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.data.Scan
+import de.markusfisch.android.binaryeye.view.setPadding
+import de.markusfisch.android.binaryeye.view.setWindowInsetListener
+import de.markusfisch.android.binaryeye.widget.toast
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch

 class DecodeFragment : Fragment() {
 	private lateinit var contentView: EditText
 	private lateinit var formatView: TextView
+	private lateinit var metaView: TableLayout
 	private lateinit var hexView: TextView
-	private lateinit var format: BarcodeFormat
+	private lateinit var format: String
+	private lateinit var fab: FloatingActionButton
+
+	private var action = ActionRegistry.DEFAULT_ACTION
+	private var isBinary = false
+	private val content: String
+		get() = contentView.text.toString()
+
+	private val parentJob = Job()
+	private val scope: CoroutineScope = CoroutineScope(Dispatchers.Main + parentJob)

 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
@@ -41,7 +50,7 @@ class DecodeFragment : Fragment() {
 		container: ViewGroup?,
 		state: Bundle?
 	): View {
-		activity.setTitle(R.string.content)
+		activity?.setTitle(R.string.content)

 		val view = inflater.inflate(
 			R.layout.fragment_decode,
@@ -49,69 +58,163 @@ class DecodeFragment : Fragment() {
 			false
 		)

-		val content = arguments?.getString(CONTENT) ?: ""
-		format = arguments?.getSerializable(FORMAT) as BarcodeFormat? ?: BarcodeFormat.QR_CODE
+		val scan = arguments?.getParcelable(SCAN) as Scan?
+			?: throw IllegalArgumentException("DecodeFragment needs a Scan")
+
+		val inputContent = scan.content
+		isBinary = hasNonPrintableCharacters(
+			inputContent
+		) or inputContent.isEmpty()
+		val raw = scan.raw ?: inputContent.toByteArray()
+		format = scan.format

 		contentView = view.findViewById(R.id.content)
-		contentView.setText(content)
-		contentView.addTextChangedListener(object : TextWatcher {
-			override fun afterTextChanged(s: Editable?) {
-				updateFormatAndHex(contentView.text.toString())
+		fab = view.findViewById(R.id.open)
+
+		if (!isBinary) {
+			contentView.setText(inputContent)
+			contentView.addTextChangedListener(object : TextWatcher {
+				override fun afterTextChanged(s: Editable?) {
+					updateViewsAndAction(content.toByteArray())
+				}
+
+				override fun beforeTextChanged(
+					s: CharSequence?,
+					start: Int,
+					count: Int,
+					after: Int
+				) {
+				}
+
+				override fun onTextChanged(
+					s: CharSequence?,
+					start: Int,
+					before: Int,
+					count: Int
+				) {
+				}
+			})
+			fab.setOnClickListener {
+				executeAction(content.toByteArray())
+			}
+			if (prefs.openImmediately) {
+				executeAction(content.toByteArray())
+			}
+		} else {
+			contentView.setText(R.string.binary_data)
+			contentView.isEnabled = false
+			fab.setImageResource(R.drawable.ic_action_save)
+			fab.setOnClickListener {
+				askForFileNameAndSave(raw)
 			}
-			override fun beforeTextChanged(
-				s: CharSequence?,
-				start: Int,
-				count: Int,
-				after: Int
-			) {}
-			override fun onTextChanged(
-				s: CharSequence?,
-				start: Int,
-				before: Int,
-				count: Int
-			) {}
-		})
-
-		formatView = view.findViewById(R.id.format)
-		hexView = view.findViewById(R.id.hex)
-
-		view.findViewById<View>(R.id.share).setOnClickListener { v ->
-			shareText(v.context, getContent())
 		}

-		updateFormatAndHex(content)
+		formatView = view.findViewById(R.id.format)
+		metaView = view.findViewById(R.id.meta)
+		hexView = view.findViewById(R.id.hex)
+
+		updateViewsAndAction(raw)
+		if (action is WifiAction) {
+			val password = (action as WifiAction).password
+			if (password != null) {
+				activity?.apply {
+					copyToClipboard(password)
+					toast(R.string.copied_password_to_clipboard)
+				}
+			}
+		}
+
+		if (prefs.showMetaData) {
+			fillMetaView(metaView, scan)
+		}
+
+		setWindowInsetListener { insets ->
+			(view.findViewById(R.id.inset_layout) as View).setPadding(insets)
+			(view.findViewById(R.id.scroll_view) as View).setPadding(insets)
+		}

 		return view
 	}

-	private fun updateFormatAndHex(content: String) {
+	private fun updateViewsAndAction(bytes: ByteArray) {
+		val prevAction = action
+		if (!prevAction.canExecuteOn(bytes)) {
+			action = ActionRegistry.getAction(bytes)
+		}
 		formatView.text = resources.getQuantityString(
 			R.plurals.barcode_info,
-			content.length,
-			format.toString(),
-			content.length
+			bytes.size,
+			format,
+			bytes.size
 		)
-		hexView.text = hexDump(content, 33)
+		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
+				}
+			} else {
+				fab.tooltipText = getString(action.titleResId)
+			}
+		}
+	}
+
+	private fun fillMetaView(tableLayout: TableLayout, scan: Scan) {
+		val ctx = tableLayout.context
+		val spaceBetween = (ctx.resources.displayMetrics.density * 16f).toInt()
+		var hasMeta = false
+		sortedMapOf(
+			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
+		).forEach { item ->
+			item.value?.let {
+				val tr = TableRow(ctx)
+				val keyView = TextView(ctx)
+				keyView.setText(item.key)
+				val valueView = TextView(ctx)
+				valueView.setPadding(spaceBetween, 0, 0, 0)
+				valueView.text = it
+				tr.addView(keyView)
+				tr.addView(valueView)
+				tableLayout.addView(tr)
+				hasMeta = true
+			}
+		}
+		if (hasMeta) {
+			tableLayout.setPadding(0, 0, 0, spaceBetween)
+		}
 	}

 	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
+		}
 	}

 	override fun onOptionsItemSelected(item: MenuItem): Boolean {
 		return when (item.itemId) {
 			R.id.copy_to_clipboard -> {
-				copyToClipboard(getContent())
+				copyToClipboard(content)
 				true
 			}
-			R.id.open_url -> {
-				openUrl(getContent())
+			R.id.share -> {
+				context?.also { shareText(it, content) }
 				true
 			}
 			R.id.create -> {
 				addFragment(
 					fragmentManager,
-					EncodeFragment.newInstance(getContent(), format)
+					EncodeFragment.newInstance(content, format)
 				)
 				true
 			}
@@ -119,97 +222,98 @@ class DecodeFragment : Fragment() {
 		}
 	}

-	private fun getContent(): String {
-		return contentView.text.toString()
-	}
-
 	private fun copyToClipboard(text: String) {
-		activity ?: return
-
-		val cm = activity.getSystemService(
-			Context.CLIPBOARD_SERVICE
-		) as ClipboardManager
-		cm.text = text
-		Toast.makeText(
-			activity,
-			R.string.put_into_clipboard,
-			Toast.LENGTH_SHORT
-		).show()
+		activity?.apply {
+			copyToClipboard(text)
+			toast(R.string.copied_to_clipboard)
+		}
 	}

-	private fun openUrl(url: String) {
-		if (activity == null || url.isEmpty()) {
+	private fun executeAction(content: ByteArray) {
+		if (activity != null && content.isNotEmpty()) {
+			if (action is WifiAction &&
+				Build.VERSION.SDK_INT < Build.VERSION_CODES.Q &&
+				!hasLocationPermission(activity)
+			) {
+				return
+			}
+			scope.launch {
+				action.execute(activity, content)
+			}
+		}
+	}
+
+	private fun askForFileNameAndSave(raw: ByteArray) {
+		val ac = activity ?: return
+		if (!hasWritePermission(ac)) {
 			return
 		}
-		var uri = Uri.parse(url)
-		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
-			uri = uri.normalizeScheme()
-		}
-		val intent = Intent(Intent.ACTION_VIEW, uri)
-		if (intent.resolveActivity(activity.packageManager) != null) {
-			startActivity(intent)
-		} else {
-			Toast.makeText(
-				activity,
-				R.string.cannot_resolve_action,
-				Toast.LENGTH_SHORT
-			).show()
+		scope.launch(Dispatchers.Main) {
+			val name = ac.askForFileName() ?: return@launch
+			val message = writeExternalFile(
+				ac,
+				name,
+				"application/octet-stream"
+			) {
+				it.write(raw)
+			}
+			ac.toast(message)
 		}
 	}

-	private fun hexDump(content: String, charsPerLine: Int): String {
-		if (charsPerLine < 4 || content.isEmpty()) {
-			return ""
-		}
-		val dump = StringBuilder()
-		val hex = StringBuilder()
-		val ascii = StringBuilder()
-		val itemsPerLine = (charsPerLine - 1) / 4
-		val bytes = content.toByteArray()
-		val len = bytes.size
-		var i = 0
-		while (true) {
-			val ord = bytes[i]
-			hex.append(String.format("%02X ", ord))
-			ascii.append(if (ord > 31) ord.toChar() else " ")
-
-			++i
-
-			val posInLine = i % itemsPerLine
-			val atEnd = i >= len
-			var atLineEnd = posInLine == 0
-			if (atEnd && !atLineEnd) {
-				for (j in posInLine until itemsPerLine) {
-					hex.append("   ")
-				}
-				atLineEnd = true
-			}
-			if (atLineEnd) {
-				dump.append(hex.toString())
-				dump.append(" ")
-				dump.append(ascii.toString())
-				dump.append("\n")
-				hex.setLength(0)
-				ascii.setLength(0)
-			}
-			if (atEnd) {
-				break
-			}
-		}
-		return dump.toString()
+	override fun onDestroyView() {
+		parentJob.cancel()
+		super.onDestroyView()
 	}

 	companion object {
-		private const val CONTENT = "content"
-		private const val FORMAT = "format"
+		private const val SCAN = "scan"

-		fun newInstance(content: String, format: BarcodeFormat): Fragment {
+		fun newInstance(scan: Scan): Fragment {
 			val args = Bundle()
-			args.putString(CONTENT, content)
-			args.putSerializable(FORMAT, format)
+			args.putParcelable(SCAN, scan)
 			val fragment = DecodeFragment()
 			fragment.arguments = args
 			return fragment
 		}
 	}
 }
+
+fun hexDump(bytes: ByteArray, charsPerLine: Int = 33): String {
+	if (charsPerLine < 4 || bytes.isEmpty()) {
+		return ""
+	}
+	val dump = StringBuilder()
+	val hex = StringBuilder()
+	val ascii = StringBuilder()
+	val itemsPerLine = (charsPerLine - 1) / 4
+	val len = bytes.size
+	var i = 0
+	while (true) {
+		val ord = bytes[i]
+		hex.append(String.format("%02X ", ord))
+		ascii.append(if (ord > 31) ord.toChar() else " ")
+		++i
+		val posInLine = i % itemsPerLine
+		val atEnd = i >= len
+		var atLineEnd = posInLine == 0
+		if (atEnd && !atLineEnd) {
+			for (j in posInLine until itemsPerLine) {
+				hex.append("   ")
+			}
+			atLineEnd = true
+		}
+		if (atLineEnd) {
+			dump.append(hex.toString())
+			dump.append(" ")
+			dump.append(ascii.toString())
+			dump.append("\n")
+			hex.setLength(0)
+			ascii.setLength(0)
+		}
+		if (atEnd) {
+			break
+		}
+	}
+	return dump.toString()
+}
@@ -1,28 +1,23 @@
 package de.markusfisch.android.binaryeye.fragment

-import com.google.zxing.BarcodeFormat
-
-import de.markusfisch.android.binaryeye.app.addFragment
-import de.markusfisch.android.binaryeye.R
-
-import android.content.Context
 import android.os.Bundle
 import android.support.v4.app.Fragment
-import android.view.inputmethod.InputMethodManager
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.widget.ArrayAdapter
-import android.widget.EditText
-import android.widget.SeekBar
-import android.widget.Spinner
-import android.widget.TextView
-import android.widget.Toast
+import android.view.*
+import android.widget.*
+import com.google.zxing.BarcodeFormat
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.app.addFragment
+import de.markusfisch.android.binaryeye.app.hideSoftKeyboard
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.view.setPadding
+import de.markusfisch.android.binaryeye.view.setWindowInsetListener

 class EncodeFragment : Fragment() {
 	private lateinit var formatView: Spinner
 	private lateinit var sizeView: TextView
 	private lateinit var sizeBarView: SeekBar
+	private lateinit var contentView: EditText
+
 	private val writers = arrayListOf(
 		BarcodeFormat.AZTEC,
 		BarcodeFormat.CODABAR,
@@ -37,12 +32,18 @@ class EncodeFragment : Fragment() {
 		BarcodeFormat.UPC_A
 	)

+	override fun onCreate(state: Bundle?) {
+		super.onCreate(state)
+		setHasOptionsMenu(true)
+	}
+
 	override fun onCreateView(
 		inflater: LayoutInflater,
 		container: ViewGroup?,
 		state: Bundle?
-	): View {
-		activity.setTitle(R.string.compose_barcode)
+	): View? {
+		val ac = activity ?: return null
+		ac.setTitle(R.string.compose_barcode)

 		val view = inflater.inflate(
 			R.layout.fragment_encode,
@@ -51,8 +52,8 @@ class EncodeFragment : Fragment() {
 		)

 		formatView = view.findViewById(R.id.format)
-		formatView.adapter = ArrayAdapter<String>(
-			activity,
+		formatView.adapter = ArrayAdapter(
+			ac,
 			android.R.layout.simple_list_item_1,
 			writers.map { it.name }
 		)
@@ -61,43 +62,74 @@ class EncodeFragment : Fragment() {
 		sizeBarView = view.findViewById(R.id.size_bar)
 		initSizeBar()

-		val contentView = view.findViewById<EditText>(R.id.content)
+		contentView = view.findViewById(R.id.content)

 		val args = arguments
-		args?.let {
-			contentView.setText(args.getString(CONTENT))
-			formatView.setSelection(
-				writers.indexOf(
-					args.getSerializable(FORMAT) as BarcodeFormat?
-				)
-			)
+		args?.also {
+			contentView.setText(it.getString(CONTENT))
 		}

-		view.findViewById<View>(R.id.encode).setOnClickListener { v ->
-			val format = writers[formatView.selectedItemPosition]
-			val size = getSize(sizeBarView.progress)
-			val content = contentView.text.toString()
-			if (content.isEmpty()) {
-				Toast.makeText(
-					v.context,
-					R.string.error_no_content,
-					Toast.LENGTH_SHORT
-				).show()
-			} else {
-				hideSoftKeyboard(contentView)
-				addFragment(
-					fragmentManager, BarcodeFragment.newInstance(
-						content,
-						format,
-						size
-					)
-				)
+		val barcodeFormat = args?.getString(FORMAT)
+		if (barcodeFormat != null) {
+			formatView.setSelection(
+				writers.indexOf(resolveFormat(barcodeFormat))
+			)
+		} else if (state == null) {
+			formatView.post {
+				formatView.setSelection(prefs.indexOfLastSelectedFormat)
 			}
 		}

+		view.findViewById<View>(R.id.encode).setOnClickListener {
+			encode()
+		}
+
+		setWindowInsetListener { insets ->
+			(view.findViewById(R.id.inset_layout) as View).setPadding(insets)
+			(view.findViewById(R.id.scroll_view) as View).setPadding(insets)
+		}
+
 		return view
 	}

+	override fun onPause() {
+		super.onPause()
+		prefs.indexOfLastSelectedFormat = formatView.selectedItemPosition
+	}
+
+	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.next -> {
+				encode()
+				true
+			}
+			else -> super.onOptionsItemSelected(item)
+		}
+	}
+
+	private fun encode() {
+		val format = writers[formatView.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)
+			addFragment(
+				fragmentManager,
+				BarcodeFragment.newInstance(content, format, size)
+			)
+		}
+	}
+
 	private fun initSizeBar() {
 		updateSize(sizeBarView.progress)
 		sizeBarView.setOnSeekBarChangeListener(
@@ -123,29 +155,26 @@ class EncodeFragment : Fragment() {

 	private fun getSize(power: Int) = 128 * (power + 1)

-	private fun hideSoftKeyboard(view: View) {
-		val im = activity?.getSystemService(
-			Context.INPUT_METHOD_SERVICE
-		) as InputMethodManager?
-		im?.let {
-			im.hideSoftInputFromWindow(view.windowToken, 0)
-		}
-	}
-
 	companion object {
 		private const val CONTENT = "content"
 		private const val FORMAT = "format"

 		fun newInstance(
 			content: String,
-			format: BarcodeFormat = BarcodeFormat.AZTEC
+			format: String? = null
 		): Fragment {
 			val args = Bundle()
 			args.putString(CONTENT, content)
-			args.putSerializable(FORMAT, format)
+			format?.let { args.putString(FORMAT, it) }
 			val fragment = EncodeFragment()
 			fragment.arguments = args
 			return fragment
 		}
 	}
 }
+
+private fun resolveFormat(name: String): BarcodeFormat = try {
+	BarcodeFormat.valueOf(name)
+} catch (_: IllegalArgumentException) {
+	BarcodeFormat.QR_CODE
+}
@@ -1,37 +1,105 @@
 package de.markusfisch.android.binaryeye.fragment

-import com.google.zxing.BarcodeFormat
-
-import de.markusfisch.android.binaryeye.adapter.ScansAdapter
-import de.markusfisch.android.binaryeye.app.addFragment
-import de.markusfisch.android.binaryeye.app.db
-import de.markusfisch.android.binaryeye.app.prefs
-import de.markusfisch.android.binaryeye.app.shareText
-import de.markusfisch.android.binaryeye.data.Database
-import de.markusfisch.android.binaryeye.R
-
+import android.annotation.SuppressLint
 import android.app.AlertDialog
+import android.app.SearchManager
 import android.content.Context
+import android.database.Cursor
+import android.os.Build
 import android.os.Bundle
+import android.os.Parcelable
+import android.support.v4.app.ActivityCompat
 import android.support.v4.app.Fragment
+import android.support.v4.content.ContextCompat
+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.LayoutInflater
-import android.view.Menu
-import android.view.MenuInflater
-import android.view.MenuItem
-import android.view.View
-import android.view.ViewGroup
+import android.view.*
+import android.widget.EditText
 import android.widget.ListView
-
-import kotlinx.coroutines.Dispatchers.Main
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.adapter.ScansAdapter
+import de.markusfisch.android.binaryeye.app.*
+import de.markusfisch.android.binaryeye.data.Database
+import de.markusfisch.android.binaryeye.data.exportCsv
+import de.markusfisch.android.binaryeye.view.setPadding
+import de.markusfisch.android.binaryeye.view.setWindowInsetListener
+import de.markusfisch.android.binaryeye.view.useVisibility
+import kotlinx.coroutines.*

 class HistoryFragment : Fragment() {
+	private lateinit var useHistorySwitch: SwitchCompat
 	private lateinit var listView: ListView
 	private lateinit var fab: View
 	private lateinit var progressView: View

+	private val parentJob = Job()
+	private val scope = CoroutineScope(Dispatchers.IO + parentJob)
+	private val actionModeCallback = object : ActionMode.Callback {
+		override fun onCreateActionMode(
+			mode: ActionMode,
+			menu: Menu
+		): Boolean {
+			mode.menuInflater.inflate(
+				R.menu.fragment_history_edit,
+				menu
+			)
+			if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+				lockStatusBarColor()
+				val ac = activity
+				ac.window.statusBarColor = ContextCompat.getColor(
+					ac,
+					R.color.accent_dark
+				)
+			}
+			return true
+		}
+
+		override fun onPrepareActionMode(
+			mode: ActionMode,
+			menu: Menu
+		): Boolean {
+			return false
+		}
+
+		override fun onActionItemClicked(
+			mode: ActionMode,
+			item: MenuItem
+		): Boolean {
+			return when (item.itemId) {
+				R.id.edit_scan -> {
+					scansAdapter?.let {
+						askForName(
+							activity,
+							it.selectedScanId,
+							getScanName(it.selectedScanPosition)
+						)
+					}
+					closeActionMode()
+					true
+				}
+				R.id.remove_scan -> {
+					scansAdapter?.let {
+						askToRemoveScan(activity, it.selectedScanId)
+					}
+					closeActionMode()
+					true
+				}
+				else -> false
+			}
+		}
+
+		override fun onDestroyActionMode(mode: ActionMode) {
+			closeActionMode()
+		}
+	}
+
+	private var scansAdapter: ScansAdapter? = null
+	private var listViewState: Parcelable? = null
+	private var actionMode: ActionMode? = null
+	private var filter: String? = null
+
 	override fun onCreate(state: Bundle?) {
 		super.onCreate(state)
 		setHasOptionsMenu(true)
@@ -42,7 +110,7 @@ class HistoryFragment : Fragment() {
 		container: ViewGroup?,
 		state: Bundle?
 	): View {
-		activity.setTitle(R.string.history)
+		activity?.setTitle(R.string.history)

 		val view = inflater.inflate(
 			R.layout.fragment_history,
@@ -50,20 +118,27 @@ class HistoryFragment : Fragment() {
 			false
 		)

-		val useHistorySwitch = view.findViewById(
+		useHistorySwitch = view.findViewById(
 			R.id.use_history
 		) as SwitchCompat
 		initHistorySwitch(useHistorySwitch)

 		listView = view.findViewById(R.id.scans)
-		listView.emptyView = useHistorySwitch
 		listView.setOnItemClickListener { _, _, _, id ->
 			showScan(id)
 		}
-		listView.setOnItemLongClickListener { _, v, _, id ->
-			askToRemoveScan(v.context, id)
+		listView.setOnItemLongClickListener { _, v, position, id ->
+			v.isSelected = true
+			scansAdapter?.select(id, position)
+			val ac = activity
+			if (actionMode == null && ac is AppCompatActivity) {
+				actionMode = ac.delegate.startSupportActionMode(
+					actionModeCallback
+				)
+			}
 			true
 		}
+		listView.setOnScrollListener(systemBarScrollListener)

 		fab = view.findViewById(R.id.share)
 		fab.setOnClickListener { v ->
@@ -72,21 +147,58 @@ class HistoryFragment : Fragment() {

 		progressView = view.findViewById(R.id.progress_view)

+		setWindowInsetListener { insets ->
+			(view.findViewById(R.id.inset_layout) as View).setPadding(insets)
+			listView.setPadding(insets)
+		}
+
+		update()
+
 		return view
 	}

 	override fun onDestroy() {
 		super.onDestroy()
-		(listView.adapter as ScansAdapter?)?.changeCursor(null)
+		scansAdapter?.changeCursor(null)
+		parentJob.cancel()
 	}

-	override fun onResume() {
-		super.onResume()
-		update(context)
+	override fun onPause() {
+		super.onPause()
+		listViewState = listView.onSaveInstanceState()
 	}

 	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)
+	}
+
+	private fun initSearchView(item: MenuItem?) {
+		item ?: return
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
+			item.isVisible = false
+		} else {
+			val ac = activity
+			val searchView = item.actionView as SearchView
+			val searchManager = ac.getSystemService(
+				Context.SEARCH_SERVICE
+			) as SearchManager
+			searchView.setSearchableInfo(
+				searchManager.getSearchableInfo(ac.componentName)
+			)
+			searchView.setOnQueryTextListener(object : SearchView.OnQueryTextListener {
+				override fun onQueryTextSubmit(query: String): Boolean {
+					update(query)
+					return false
+				}
+
+				override fun onQueryTextChange(query: String): Boolean {
+					update(query)
+					return false
+				}
+			})
+		}
 	}

 	override fun onOptionsItemSelected(item: MenuItem): Boolean {
@@ -95,6 +207,10 @@ class HistoryFragment : Fragment() {
 				askToRemoveAllScans(context)
 				true
 			}
+			R.id.export_history -> {
+				askToExportToFile(context)
+				true
+			}
 			else -> super.onOptionsItemSelected(item)
 		}
 	}
@@ -108,46 +224,84 @@ class HistoryFragment : Fragment() {
 		}
 	}

-	private fun update(context: Context) {
-		GlobalScope.launch {
-			val cursor = db.getScans()
-			GlobalScope.launch(Main) {
-				fab.visibility = if (cursor != null && cursor.count > 0) {
+	private fun updateAndClearFilter() {
+		filter = null
+		update()
+	}
+
+	private fun update(query: String? = null) {
+		query?.let { filter = it }
+		scope.launch {
+			val cursor = db.getScans(filter)
+			withContext(Dispatchers.Main) {
+				val ac = activity ?: return@withContext
+				val hasScans = cursor != null && cursor.count > 0
+				if (filter == null) {
+					if (!hasScans) {
+						listView.emptyView = useHistorySwitch
+					}
+					ActivityCompat.invalidateOptionsMenu(ac)
+				}
+				fab.visibility = if (hasScans) {
 					View.VISIBLE
 				} else {
 					View.GONE
 				}
-				cursor?.let {
-					if (listView.adapter == null) {
-						listView.adapter = ScansAdapter(context, cursor)
-					} else {
-						val adapter = listView.adapter as ScansAdapter
-						adapter.changeCursor(cursor)
-						adapter.notifyDataSetChanged()
+				cursor?.let { cursor ->
+					// close previous cursor
+					scansAdapter?.also { it.changeCursor(null) }
+					scansAdapter = ScansAdapter(ac, cursor)
+					listView.adapter = scansAdapter
+					listViewState?.also {
+						listView.onRestoreInstanceState(it)
 					}
 				}
 			}
 		}
 	}

-	private fun showScan(id: Long) {
-		val cursor = db.getScan(id)
-		if (cursor != null && cursor.moveToFirst()) {
-			val contentIndex = cursor.getColumnIndex(Database.SCANS_CONTENT)
-			val formatIndex = cursor.getColumnIndex(Database.SCANS_FORMAT)
-			try {
-				addFragment(
-					fragmentManager,
-					DecodeFragment.newInstance(
-						cursor.getString(contentIndex),
-						BarcodeFormat.valueOf(cursor.getString(formatIndex))
-					)
-				)
-			} catch (e: IllegalArgumentException) {
-				// shouldn't ever happen
-			}
+	private fun closeActionMode() {
+		unlockStatusBarColor()
+		scansAdapter?.clearSelection()
+		actionMode?.finish()
+		actionMode = null
+		scansAdapter?.notifyDataSetChanged()
+	}
+
+	private fun showScan(id: Long) = db.getScan(id)?.also { scan ->
+		closeActionMode()
+		try {
+			addFragment(
+				fragmentManager,
+				DecodeFragment.newInstance(scan)
+			)
+		} catch (e: IllegalArgumentException) {
+			// ignore, can never happen
 		}
-		cursor?.close()
+	}
+
+	private fun getScanName(position: Int): String? {
+		val cursor = scansAdapter?.getItem(position) as Cursor?
+		return cursor?.getString(cursor.getColumnIndex(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(
+			R.layout.dialog_enter_name, null
+		)
+		val nameView = view.findViewById<EditText>(R.id.name)
+		nameView.setText(text)
+		AlertDialog.Builder(context)
+			.setView(view)
+			.setPositiveButton(android.R.string.ok) { _, _ ->
+				val name = nameView.text.toString()
+				db.renameScan(id, name)
+				update()
+			}
+			.setNegativeButton(android.R.string.cancel) { _, _ -> }
+			.show()
 	}

 	private fun askToRemoveScan(context: Context, id: Long) {
@@ -155,7 +309,11 @@ class HistoryFragment : Fragment() {
 			.setMessage(R.string.really_remove_scan)
 			.setPositiveButton(android.R.string.ok) { _, _ ->
 				db.removeScan(id)
-				update(context)
+				if (scansAdapter?.count == 1) {
+					updateAndClearFilter()
+				} else {
+					update()
+				}
 			}
 			.setNegativeButton(android.R.string.cancel) { _, _ ->
 			}
@@ -167,13 +325,36 @@ class HistoryFragment : Fragment() {
 			.setMessage(R.string.really_remove_all_scans)
 			.setPositiveButton(android.R.string.ok) { _, _ ->
 				db.removeScans()
-				update(context)
+				updateAndClearFilter()
 			}
 			.setNegativeButton(android.R.string.cancel) { _, _ ->
 			}
 			.show()
 	}

+	private fun askToExportToFile(context: Context) = scope.launch {
+		progressView.useVisibility {
+			if (!hasWritePermission(activity)) {
+				return@useVisibility
+			}
+			val delimiters = context.resources.getStringArray(
+				R.array.csv_delimiters_values
+			)
+			val delimiter = alertDialog<String>(context) { resume ->
+				setTitle(R.string.csv_delimiter)
+				setItems(R.array.csv_delimiters_names) { _, which ->
+					resume(delimiters[which])
+				}
+			} ?: return@useVisibility
+			val name = withContext(Dispatchers.Main) {
+				activity.askForFileName(suffix = ".csv")
+			} ?: return@useVisibility
+			db.getScansDetailed(filter)?.use { cursor ->
+				exportCsv(context, name, cursor, delimiter)
+			}
+		}
+	}
+
 	private fun pickListSeparatorAndShare(context: Context) {
 		val separators = context.resources.getStringArray(
 			R.array.list_separators_values
@@ -187,31 +368,25 @@ class HistoryFragment : Fragment() {
 	}

 	private fun shareScans(separator: String) {
-		if (progressView.visibility == View.VISIBLE) {
-			return
-		}
-		progressView.visibility = View.VISIBLE
-		GlobalScope.launch {
-			val cursor = db.getScans()
-			cursor?.let {
+		scope.launch {
+			progressView.useVisibility {
 				val sb = StringBuilder()
-				if (cursor.moveToFirst()) {
-					val contentIndex = cursor.getColumnIndex(
-						Database.SCANS_CONTENT
-					)
-					do {
-						sb.append(cursor.getString(contentIndex))
-						sb.append(separator)
-					} while (cursor.moveToNext())
-				}
-				cursor.close()
-				val text = sb.toString()
-				if (text.isNotEmpty()) {
-					GlobalScope.launch(Main) {
-						progressView.visibility = View.GONE
-						shareText(context, text)
+				db.getScans(filter)?.use { cursor ->
+					val contentIndex = cursor.getColumnIndex(Database.SCANS_CONTENT)
+					if (cursor.moveToFirst()) {
+						do {
+							val content = cursor.getString(contentIndex)
+							if (content?.isNotEmpty() == true) {
+								sb.append(content)
+								sb.append(separator)
+							}
+						} while (cursor.moveToNext())
 					}
 				}
+				val text = sb.toString()
+				if (text.isNotEmpty()) withContext(Dispatchers.Main) {
+					shareText(context, text)
+				}
 			}
 		}
 	}
@@ -0,0 +1,103 @@
+package de.markusfisch.android.binaryeye.fragment
+
+import android.os.Bundle
+import android.support.v4.app.Fragment
+import android.support.v7.widget.SwitchCompat
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.EditText
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.app.prefs
+import de.markusfisch.android.binaryeye.view.setPadding
+import de.markusfisch.android.binaryeye.view.setWindowInsetListener
+
+class PreferencesFragment : Fragment() {
+	private lateinit var zoomBySwipingSwitch: SwitchCompat
+	private lateinit var openImmediatelySwitch: SwitchCompat
+	private lateinit var vibrateSwitch: SwitchCompat
+	private lateinit var useHistorySwitch: SwitchCompat
+	private lateinit var showMetaDataSwitch: SwitchCompat
+	private lateinit var showHexDumpSwitch: SwitchCompat
+	private lateinit var tryHarderSwitch: SwitchCompat
+	private lateinit var ignoreConsecutiveDuplicatesSwitch: SwitchCompat
+	private lateinit var openWithUrlInput: EditText
+
+	override fun onCreateView(
+		inflater: LayoutInflater,
+		container: ViewGroup?,
+		state: Bundle?
+	): View? {
+		activity?.setTitle(R.string.preferences)
+
+		val view = inflater.inflate(
+			R.layout.fragment_preferences,
+			container,
+			false
+		)
+
+		zoomBySwipingSwitch = view.findViewById(R.id.zoom_by_swiping)
+		if (prefs.zoomBySwiping) {
+			zoomBySwipingSwitch.toggle()
+		}
+
+		openImmediatelySwitch = view.findViewById(R.id.open_immediately)
+		if (prefs.openImmediately) {
+			openImmediatelySwitch.toggle()
+		}
+
+		vibrateSwitch = view.findViewById(R.id.vibrate)
+		if (prefs.vibrate) {
+			vibrateSwitch.toggle()
+		}
+
+		useHistorySwitch = view.findViewById(R.id.use_history)
+		if (prefs.useHistory) {
+			useHistorySwitch.toggle()
+		}
+
+		ignoreConsecutiveDuplicatesSwitch = view.findViewById(
+			R.id.ignore_consecutive_duplicates
+		)
+		if (prefs.ignoreConsecutiveDuplicates) {
+			ignoreConsecutiveDuplicatesSwitch.toggle()
+		}
+
+		showMetaDataSwitch = view.findViewById(R.id.show_meta_data)
+		if (prefs.showMetaData) {
+			showMetaDataSwitch.toggle()
+		}
+
+		showHexDumpSwitch = view.findViewById(R.id.show_hex_dump)
+		if (prefs.showHexDump) {
+			showHexDumpSwitch.toggle()
+		}
+
+		tryHarderSwitch = view.findViewById(R.id.try_harder)
+		if (prefs.tryHarder) {
+			tryHarderSwitch.toggle()
+		}
+
+		openWithUrlInput = view.findViewById(R.id.open_with_url)
+		openWithUrlInput.setText(prefs.openWithUrl)
+
+		setWindowInsetListener { insets ->
+			(view.findViewById(R.id.scroll_view) as View).setPadding(insets)
+		}
+
+		return view
+	}
+
+	override fun onPause() {
+		super.onPause()
+		prefs.zoomBySwiping = zoomBySwipingSwitch.isChecked
+		prefs.openImmediately = openImmediatelySwitch.isChecked
+		prefs.vibrate = vibrateSwitch.isChecked
+		prefs.useHistory = useHistorySwitch.isChecked
+		prefs.ignoreConsecutiveDuplicates = ignoreConsecutiveDuplicatesSwitch.isChecked
+		prefs.showMetaData = showMetaDataSwitch.isChecked
+		prefs.showHexDump = showHexDumpSwitch.isChecked
+		prefs.tryHarder = tryHarderSwitch.isChecked
+		prefs.openWithUrl = openWithUrlInput.text.toString()
+	}
+}
@@ -0,0 +1,83 @@
+package de.markusfisch.android.binaryeye.graphics
+
+import android.content.ContentResolver
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import android.graphics.RectF
+import android.net.Uri
+import java.io.IOException
+import kotlin.math.roundToInt
+
+fun loadImageUri(cr: ContentResolver, uri: Uri): Bitmap? = try {
+	val options = BitmapFactory.Options()
+	cr.openInputStream(uri)?.use {
+		options.inJustDecodeBounds = true
+		BitmapFactory.decodeStream(it, null, options)
+		options.inSampleSize = calculateInSampleSize(
+			options.outWidth,
+			options.outHeight
+		)
+		options.inJustDecodeBounds = false
+	}
+	cr.openInputStream(uri)?.use {
+		BitmapFactory.decodeStream(it, null, options)
+	}
+} catch (e: IOException) {
+	null
+}
+
+private fun calculateInSampleSize(
+	width: Int,
+	height: Int,
+	reqWidth: Int = 1024,
+	reqHeight: Int = 1024
+): Int {
+	var inSampleSize = 1
+	if (height > reqHeight || width > reqWidth) {
+		val halfHeight = height / 2
+		val halfWidth = width / 2
+		while (
+			halfHeight / inSampleSize >= reqHeight ||
+			halfWidth / inSampleSize >= reqWidth
+		) {
+			inSampleSize *= 2
+		}
+	}
+	return inSampleSize
+}
+
+fun crop(bitmap: Bitmap, rect: RectF, rotation: Float) = try {
+	val erected = erect(bitmap, rotation)
+	val w = erected.width
+	val h = erected.height
+	Bitmap.createBitmap(
+		erected,
+		(rect.left * w).roundToInt(),
+		(rect.top * h).roundToInt(),
+		(rect.width() * w).roundToInt(),
+		(rect.height() * h).roundToInt()
+	)
+} catch (e: OutOfMemoryError) {
+	null
+} catch (e: IllegalArgumentException) {
+	null
+}
+
+private fun erect(bitmap: Bitmap, rotation: Float): Bitmap = if (
+	rotation % 360f != 0f
+) {
+	val matrix = Matrix()
+	matrix.setRotate(rotation)
+	Bitmap.createBitmap(
+		bitmap,
+		0,
+		0,
+		bitmap.width,
+		bitmap.height,
+		matrix,
+		true
+	)
+} else {
+	bitmap
+}
@@ -0,0 +1,32 @@
+package de.markusfisch.android.binaryeye.graphics
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Paint
+import android.graphics.Point
+import android.support.v4.content.ContextCompat
+import de.markusfisch.android.binaryeye.R
+
+class Candidates(context: Context) {
+	private val paint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private val radius = 8f * context.resources.displayMetrics.density
+
+	init {
+		paint.color = ContextCompat.getColor(
+			context,
+			R.color.candidate
+		)
+		paint.style = Paint.Style.FILL
+	}
+
+	fun draw(canvas: Canvas, points: List<Point>) {
+		for (point in points) {
+			canvas.drawCircle(
+				point.x.toFloat(),
+				point.y.toFloat(),
+				radius,
+				paint
+			)
+		}
+	}
+}
@@ -0,0 +1,37 @@
+package de.markusfisch.android.binaryeye.graphics
+
+import android.graphics.Point
+import android.graphics.Rect
+import com.google.zxing.Result
+import com.google.zxing.ResultPoint
+import kotlin.math.roundToInt
+
+fun mapResult(
+	width: Int,
+	height: Int,
+	viewRect: Rect,
+	result: Result
+): List<Point> = frameToView(width, height, viewRect).map(result.resultPoints)
+
+fun frameToView(width: Int, height: Int, viewRect: Rect) = Mapping(
+	viewRect.width().toFloat() / width.toFloat(),
+	viewRect.height().toFloat() / height.toFloat(),
+	viewRect.left,
+	viewRect.top
+)
+
+data class Mapping(
+	val ratioX: Float,
+	val ratioY: Float,
+	val offsetX: Int,
+	val offsetY: Int
+) {
+	fun map(point: ResultPoint) = Point(
+		(point.x * ratioX).roundToInt() + offsetX,
+		(point.y * ratioY).roundToInt() + offsetY
+	)
+
+	fun map(points: Array<ResultPoint?>): List<Point> =
+		// because ZXing apparently returns null in this array sometimes
+		points.filterNotNull().map { map(it) }
+}
@@ -1,52 +0,0 @@
-package de.markusfisch.android.binaryeye.graphics
-
-import android.graphics.Bitmap
-import android.graphics.Matrix
-
-val matrix = Matrix()
-var buf: IntArray? = null
-
-fun lumaToBitmap(
-	yuv: ByteArray,
-	width: Int,
-	height: Int,
-	orientation: Int,
-	destWidth: Int,
-	destHeight: Int
-): Bitmap {
-	// convert luma component only; ZXing will binarize the input image
-	// anyway so there's no need to preserve color information
-	val bitmap = lumaToBitmap(yuv, width, height)
-	var dw = destWidth
-	var dh = destHeight
-	if (orientation == 90 || orientation == 270) {
-		dw = destHeight
-		dh = destWidth
-	}
-	matrix.setScale(
-		dw.toFloat() / width.toFloat(),
-		dh.toFloat() / height.toFloat()
-	)
-	matrix.postRotate(orientation.toFloat())
-	return Bitmap.createBitmap(
-		bitmap,
-		0,
-		0,
-		width,
-		height,
-		matrix,
-		true
-	)
-}
-
-fun lumaToBitmap(yuv: ByteArray, width: Int, height: Int): Bitmap {
-	val size = width * height
-	// reuse buf to avoid allocation in hot path
-	val b = buf ?: IntArray(size)
-	buf = b
-	for (i in 0 until size) {
-		val l = yuv[i].toInt() and 255
-		b[i] = 0xff000000.toInt() or (l shl 16) or (l shl 8) or l
-	}
-	return Bitmap.createBitmap(b, width, height, Bitmap.Config.ARGB_8888)
-}
@@ -7,11 +7,56 @@ import android.preference.PreferenceManager
 class Preferences {
 	lateinit var preferences: SharedPreferences

+	var zoomBySwiping = true
+		set(value) {
+			setBoolean(ZOOM_BY_SWIPING, value)
+			field = value
+		}
+	var openImmediately = false
+		set(value) {
+			setBoolean(OPEN_IMMEDIATELY, value)
+			field = value
+		}
+	var vibrate = true
+		set(value) {
+			setBoolean(VIBRATE, value)
+			field = value
+		}
 	var useHistory = false
 		set(value) {
 			setBoolean(USE_HISTORY, value)
 			field = value
 		}
+	var ignoreConsecutiveDuplicates = true
+		set(value) {
+			setBoolean(IGNORE_CONSECUTIVE_DUPLICATES, value)
+			field = value
+		}
+	var showMetaData = true
+		set(value) {
+			setBoolean(SHOW_META_DATA, value)
+			field = value
+		}
+	var showHexDump = true
+		set(value) {
+			setBoolean(SHOW_HEX_DUMP, value)
+			field = value
+		}
+	var tryHarder = false
+		set(value) {
+			setBoolean(TRY_HARDER, value)
+			field = value
+		}
+	var openWithUrl: String = ""
+		set(value) {
+			setString(OPEN_WITH_URL, value)
+			field = value
+		}
+	var indexOfLastSelectedFormat: Int = 0
+		set(value) {
+			setInt(INDEX_OF_LAST_SELECTED_FORMAT, value)
+			field = value
+		}

 	fun init(context: Context) {
 		preferences = PreferenceManager.getDefaultSharedPreferences(context)
@@ -19,7 +64,27 @@ class Preferences {
 	}

 	fun update() {
+		zoomBySwiping = preferences.getBoolean(ZOOM_BY_SWIPING, zoomBySwiping)
+		openImmediately = preferences.getBoolean(
+			OPEN_IMMEDIATELY,
+			openImmediately
+		)
+		vibrate = preferences.getBoolean(VIBRATE, vibrate)
 		useHistory = preferences.getBoolean(USE_HISTORY, useHistory)
+		ignoreConsecutiveDuplicates = preferences.getBoolean(
+			IGNORE_CONSECUTIVE_DUPLICATES,
+			ignoreConsecutiveDuplicates
+		)
+		showMetaData = preferences.getBoolean(SHOW_META_DATA, showMetaData)
+		showHexDump = preferences.getBoolean(SHOW_HEX_DUMP, showHexDump)
+		tryHarder = preferences.getBoolean(TRY_HARDER, tryHarder)
+		preferences.getString(OPEN_WITH_URL, openWithUrl)?.also {
+			openWithUrl = it
+		}
+		indexOfLastSelectedFormat = preferences.getInt(
+			INDEX_OF_LAST_SELECTED_FORMAT,
+			indexOfLastSelectedFormat
+		)
 	}

 	private fun setBoolean(label: String, value: Boolean) {
@@ -28,7 +93,28 @@ class Preferences {
 		editor.apply()
 	}

+	private fun setString(label: String, value: String) {
+		val editor = preferences.edit()
+		editor.putString(label, value)
+		editor.apply()
+	}
+
+	private fun setInt(label: String, value: Int) {
+		val editor = preferences.edit()
+		editor.putInt(label, value)
+		editor.apply()
+	}
+
 	companion object {
+		const val ZOOM_BY_SWIPING = "zoom_by_swiping"
+		const val OPEN_IMMEDIATELY = "open_immediately"
+		const val VIBRATE = "vibrate"
 		const val USE_HISTORY = "use_history"
+		const val IGNORE_CONSECUTIVE_DUPLICATES = "ignore_consecutive_duplicates"
+		const val SHOW_HEX_DUMP = "show_hex_dump"
+		const val SHOW_META_DATA = "show_meta_data"
+		const val TRY_HARDER = "try_harder"
+		const val OPEN_WITH_URL = "open_with_url"
+		const val INDEX_OF_LAST_SELECTED_FORMAT = "index_of_last_selected_format"
 	}
 }
@@ -1,13 +1,9 @@
 package de.markusfisch.android.binaryeye.rs

-import de.markusfisch.android.binaryeye.renderscript.ScriptC_rotator
-
 import android.content.Context
-import android.support.v8.renderscript.Allocation
-import android.support.v8.renderscript.Element
-import android.support.v8.renderscript.RenderScript
-import android.support.v8.renderscript.ScriptIntrinsicResize
-import android.support.v8.renderscript.Type
+import android.support.v8.renderscript.*
+import de.markusfisch.android.binaryeye.renderscript.ScriptC_rotator
+import kotlin.math.roundToInt

 class Preprocessor(
 	context: Context,
@@ -43,8 +39,8 @@ class Preprocessor(
 		)

 		val f = .75f
-		var w = Math.round(width * f)
-		var h = Math.round(height * f)
+		var w = (width * f).roundToInt()
+		var h = (height * f).roundToInt()

 		resizedType = Type.createXY(
 			rs,
@@ -0,0 +1,35 @@
+package de.markusfisch.android.binaryeye.view
+
+import android.graphics.Rect
+import android.view.View
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+suspend inline fun View.useVisibility(
+	whileExecuting: Int = View.VISIBLE,
+	otherwise: Int = View.GONE,
+	crossinline block: suspend () -> Unit
+) {
+	if (visibility == whileExecuting) {
+		return
+	}
+	withContext(Dispatchers.Main) {
+		visibility = whileExecuting
+	}
+	try {
+		block()
+	} finally {
+		withContext(Dispatchers.Main) {
+			visibility = otherwise
+		}
+	}
+}
+
+fun View.setPadding(rect: Rect) {
+	this.setPadding(
+		rect.left,
+		rect.top,
+		rect.right,
+		rect.bottom
+	)
+}
@@ -0,0 +1,50 @@
+package de.markusfisch.android.binaryeye.view
+
+import android.graphics.Rect
+import android.os.Build
+import android.support.v4.view.ViewCompat
+import android.support.v7.widget.Toolbar
+import android.view.View
+
+private val windowInsets = Rect()
+private var windowInsetsSet = false
+private var windowInsetsListener: ((insets: Rect) -> Unit)? = null
+
+// invoke this from Fragment.onCreateView() *or* Activity.onCreate()
+fun setWindowInsetListener(listener: (insets: Rect) -> Unit) {
+	if (windowInsetsSet) {
+		// invoke listener for previously set window insets because
+		// setOnApplyWindowInsetsListener() won't fire again if we
+		// change Fragments
+		listener(windowInsets)
+	}
+	// *always* set the listener in case there is a configuration change
+	windowInsetsListener = listener
+}
+
+// invoke this from Activity.onCreate() to setup listening for insets
+fun setupInsets(view: View, toolbar: Toolbar) {
+	val toolBarHeight = toolbar.layoutParams.height
+	if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+		// save insets so setWindowInsetListener() can return them
+		// when it's called from Fragment.onCreateView() later on
+		windowInsets.set(0, toolBarHeight, 0, 0)
+		windowInsetsSet = true
+		windowInsetsListener?.also { it(windowInsets) }
+		return
+	}
+	ViewCompat.setOnApplyWindowInsetsListener(view) { _, insets ->
+		// runs *after* layout and thus *after* Fragment.onCreateView()
+		if (insets.hasSystemWindowInsets()) {
+			windowInsets.set(
+				insets.systemWindowInsetLeft,
+				insets.systemWindowInsetTop + toolBarHeight,
+				insets.systemWindowInsetRight,
+				insets.systemWindowInsetBottom
+			)
+			windowInsetsSet = true
+			windowInsetsListener?.also { it(windowInsets) }
+		}
+		insets
+	}
+}
@@ -0,0 +1,41 @@
+package de.markusfisch.android.binaryeye.widget
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Rect
+import android.util.AttributeSet
+import de.markusfisch.android.binaryeye.app.colorSystemAndToolBars
+import de.markusfisch.android.scalingimageview.widget.ScalingImageView
+
+open class ConfinedScalingImageView : ScalingImageView {
+	val insets = Rect()
+
+	constructor(context: Context, attrs: AttributeSet, defStyle: Int) :
+			super(context, attrs, defStyle)
+
+	constructor(context: Context, attrs: AttributeSet) :
+			this(context, attrs, 0)
+
+	override fun onDraw(canvas: Canvas) {
+		super.onDraw(canvas)
+		colorSystemAndToolBars(context, !bounds.contains(mappedRect))
+	}
+
+	override fun layoutImage(
+		changed: Boolean,
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int
+	) {
+		if (changed) {
+			setBounds(
+				(left + insets.left).toFloat(),
+				(top + insets.top).toFloat(),
+				(right - insets.right).toFloat(),
+				(bottom - insets.bottom).toFloat()
+			)
+		}
+		centerRemap()
+	}
+}
@@ -0,0 +1,45 @@
+package de.markusfisch.android.binaryeye.widget
+
+import android.content.Context
+import android.util.AttributeSet
+import android.widget.ScrollView
+import de.markusfisch.android.binaryeye.app.colorSystemAndToolBars
+
+class ConfinedScrollView : ScrollView {
+	private var scrollable = false
+
+	constructor(context: Context, attrs: AttributeSet, defStyle: Int) :
+			super(context, attrs, defStyle)
+
+	constructor(context: Context, attrs: AttributeSet) :
+			this(context, attrs, 0)
+
+	override fun onLayout(
+		changed: Boolean,
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int
+	) {
+		super.onLayout(changed, left, top, right, bottom)
+		if (changed) {
+			// give Android some time to settle down before running this,
+			// not putting it on the queue makes it only work sometimes
+			post {
+				getChildAt(0)?.also { child ->
+					scrollable = height < child.height + paddingTop + paddingBottom
+					colorSystemAndToolBars(
+						context,
+						scrollY > 0,
+						scrollable
+					)
+				}
+			}
+		}
+	}
+
+	override fun onScrollChanged(x: Int, y: Int, oldx: Int, oldy: Int) {
+		super.onScrollChanged(x, y, oldx, oldy)
+		colorSystemAndToolBars(context, y > 0, scrollable)
+	}
+}
@@ -0,0 +1,99 @@
+package de.markusfisch.android.binaryeye.widget
+
+import android.content.Context
+import android.graphics.*
+import android.support.v4.content.ContextCompat
+import android.util.AttributeSet
+import de.markusfisch.android.binaryeye.R
+import de.markusfisch.android.binaryeye.graphics.Candidates
+import kotlin.math.roundToInt
+
+class CropImageView(context: Context, attr: AttributeSet) :
+	ConfinedScalingImageView(context, attr) {
+	val windowInsets = Rect()
+
+	var onScan: (() -> List<Point>?)? = null
+
+	private val candidates = Candidates(context)
+	private val boundsPaint = Paint(Paint.ANTI_ALIAS_FLAG)
+	private val lastMappedRect = RectF()
+	private val dp = context.resources.displayMetrics.density
+	private val padding: Int = (dp * 24f).roundToInt()
+	private val onScanRunnable = Runnable {
+		onScan?.invoke()?.also {
+			candidatePoints = it
+			invalidate()
+		}
+	}
+
+	private var candidatePoints: List<Point>? = null
+
+	init {
+		boundsPaint.color = ContextCompat.getColor(context, R.color.crop_bound)
+		boundsPaint.style = Paint.Style.STROKE
+		boundsPaint.strokeWidth = dp * 2f
+		boundsPaint.pathEffect = DashPathEffect(floatArrayOf(dp * 10f, dp * 10f), 0f)
+		scaleType = ScaleType.CENTER_CROP
+	}
+
+	override fun onLayout(
+		changed: Boolean,
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int
+	) {
+		super.onLayout(changed, left, top, right, bottom)
+		setBoundsWithPadding(
+			left + windowInsets.left,
+			top + windowInsets.top,
+			right - windowInsets.right,
+			bottom - windowInsets.bottom
+		)
+	}
+
+	fun getBoundsRect() = Rect(
+		bounds.left.roundToInt(),
+		bounds.top.roundToInt(),
+		bounds.right.roundToInt(),
+		bounds.bottom.roundToInt()
+	)
+
+	private fun setBoundsWithPadding(
+		left: Int,
+		top: Int,
+		right: Int,
+		bottom: Int
+	) {
+		val width = right - left
+		val height = bottom - top
+		val size = if (width < height)
+			width - padding * 2
+		else
+			height - padding * 2
+		val hpad = (width - size) / 2
+		val vpad = (height - size) / 2
+		setBounds(
+			left.toFloat() + hpad,
+			top.toFloat() + vpad,
+			right.toFloat() - hpad,
+			bottom.toFloat() - vpad
+		)
+		center(bounds)
+	}
+
+	override fun onDraw(canvas: Canvas) {
+		super.onDraw(canvas)
+		canvas.drawRect(bounds, boundsPaint)
+		candidatePoints?.let {
+			candidates.draw(canvas, it)
+		}
+		candidatePoints = null
+		val mr = mappedRect ?: return
+		if (mr != lastMappedRect) {
+			removeCallbacks(onScanRunnable)
+			postDelayed(onScanRunnable, 500)
+			lastMappedRect.set(mr)
+		}
+	}
+}
@@ -0,0 +1,38 @@
+package de.markusfisch.android.binaryeye.widget
+
+import android.content.Context
+import android.graphics.Canvas
+import android.graphics.Point
+import android.graphics.PorterDuff
+import android.util.AttributeSet
+import android.view.View
+import de.markusfisch.android.binaryeye.graphics.Candidates
+
+class DetectorView : View {
+	private val candidates = Candidates(context)
+	private val invalidateRunnable: Runnable = Runnable {
+		marks = null
+		invalidate()
+	}
+	private var marks: List<Point>? = null
+
+	constructor(context: Context, attrs: AttributeSet) :
+			super(context, attrs)
+
+	constructor(context: Context, attrs: AttributeSet, defStyleAttr: Int) :
+			super(context, attrs, defStyleAttr)
+
+	fun mark(points: List<Point>) {
+		marks = points
+		invalidate()
+		removeCallbacks(invalidateRunnable)
+		postDelayed(invalidateRunnable, 500)
+	}
+
+	override fun onDraw(canvas: Canvas) {
+		canvas.drawColor(0, PorterDuff.Mode.CLEAR)
+		marks?.let {
+			candidates.draw(canvas, it)
+		}
+	}
+}
@@ -0,0 +1,16 @@
+package de.markusfisch.android.binaryeye.widget
+
+import android.content.Context
+import android.widget.Toast
+
+fun Context.toast(message: Int) = Toast.makeText(
+	this,
+	message,
+	Toast.LENGTH_LONG
+).show()
+
+fun Context.toast(message: String) = Toast.makeText(
+	this,
+	message,
+	Toast.LENGTH_LONG
+).show()
@@ -1,25 +1,13 @@
 package de.markusfisch.android.binaryeye.zxing

-import com.google.zxing.BarcodeFormat
-import com.google.zxing.BinaryBitmap
-import com.google.zxing.DecodeHintType
-import com.google.zxing.LuminanceSource
-import com.google.zxing.MultiFormatReader
-import com.google.zxing.MultiFormatWriter
-import com.google.zxing.PlanarYUVLuminanceSource
-import com.google.zxing.RGBLuminanceSource
-import com.google.zxing.ReaderException
-import com.google.zxing.Result
-import com.google.zxing.common.HybridBinarizer
-
 import android.graphics.Bitmap
+import com.google.zxing.*
+import com.google.zxing.common.HybridBinarizer
+import java.util.*

-import java.util.Arrays
-import java.util.EnumMap
-import java.util.EnumSet
-
-class Zxing {
-	private val multiFormatReader: MultiFormatReader = MultiFormatReader()
+class Zxing(possibleResultPoint: ResultPointCallback? = null) {
+	private val hints = EnumMap<DecodeHintType, Any>(DecodeHintType::class.java)
+	private val multiFormatReader = MultiFormatReader()

 	init {
 		val decodeFormats = EnumSet.noneOf<BarcodeFormat>(
@@ -27,7 +15,7 @@ class Zxing {
 		)
 		decodeFormats.addAll(
 			EnumSet.copyOf(
-				Arrays.asList(
+				listOf(
 					BarcodeFormat.AZTEC,
 					BarcodeFormat.CODABAR,
 					BarcodeFormat.CODE_39,
@@ -48,11 +36,18 @@ class Zxing {
 				)
 			)
 		)
-
-		val hints = EnumMap<DecodeHintType, Any>(DecodeHintType::class.java)
 		hints[DecodeHintType.POSSIBLE_FORMATS] = decodeFormats
+		possibleResultPoint?.let {
+			hints[DecodeHintType.NEED_RESULT_POINT_CALLBACK] = it
+		}
+	}

-		multiFormatReader.setHints(hints)
+	fun updateHints(tryHarder: Boolean) {
+		if (tryHarder) {
+			hints[DecodeHintType.TRY_HARDER] = java.lang.Boolean.TRUE
+		} else {
+			hints.remove(DecodeHintType.TRY_HARDER)
+		}
 	}

 	fun decode(
@@ -74,20 +69,15 @@ class Zxing {
 		return decodeLuminanceSource(source, invert)
 	}

-	fun decodePositiveNegative(bitmap: Bitmap): Result? {
-		val result = decode(bitmap, false)
-		if (result != null) {
-			return result
-		}
-		return decode(bitmap, true)
-	}
+	fun decodePositiveNegative(bitmap: Bitmap): Result? =
+		decode(bitmap, false) ?: decode(bitmap, true)

-	fun decode(bitmap: Bitmap, invert: Boolean = false): Result? {
+	private fun decode(bitmap: Bitmap, invert: Boolean = false): Result? {
 		val pixels = IntArray(bitmap.width * bitmap.height)
 		return decode(pixels, bitmap, invert)
 	}

-	fun decode(
+	private fun decode(
 		pixels: IntArray,
 		bitmap: Bitmap,
 		invert: Boolean = false
@@ -99,8 +89,10 @@ class Zxing {
 		} else {
 			bitmap
 		}.getPixels(pixels, 0, width, 0, 0, width, height)
-		val source = RGBLuminanceSource(width, height, pixels)
-		return decodeLuminanceSource(source, invert)
+		return decodeLuminanceSource(
+			RGBLuminanceSource(width, height, pixels),
+			invert
+		)
 	}

 	private fun decodeLuminanceSource(
@@ -119,7 +111,7 @@ class Zxing {
 	private fun decodeLuminanceSource(source: LuminanceSource): Result? {
 		val bitmap = BinaryBitmap(HybridBinarizer(source))
 		return try {
-			multiFormatReader.decodeWithState(bitmap)
+			multiFormatReader.decode(bitmap, hints)
 		} catch (e: ReaderException) {
 			null
 		} finally {
@@ -137,9 +129,14 @@ class Zxing {
 			width: Int,
 			height: Int
 		): Bitmap? {
+			val hints = EnumMap<EncodeHintType, Any>(EncodeHintType::class.java)
+			hints[EncodeHintType.CHARACTER_SET] = "utf-8"
 			val result = MultiFormatWriter().encode(
-				text, format,
-				width, height, null
+				text,
+				format,
+				width,
+				height,
+				hints
 			)
 			val w = result.width
 			val h = result.height
@@ -147,15 +144,16 @@ class Zxing {
 			var offset = 0
 			for (y in 0 until h) {
 				for (x in 0 until w) {
-					pixels[offset + x] = if (result.get(x, y))
+					pixels[offset + x] = if (result.get(x, y)) {
 						BLACK
-					else
+					} else {
 						WHITE
+					}
 				}
 				offset += w
 			}
 			val bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888)
-			bitmap.setPixels(pixels, 0, width, 0, 0, w, h)
+			bitmap.setPixels(pixels, 0, w, 0, 0, w, h)
 			return bitmap
 		}
 	}
@@ -1,7 +0,0 @@
-<shape xmlns:android="http://schemas.android.com/apk/res/android"
-	android:shape="line"
-	android:gravity="center">
-	<stroke
-		android:width="1dp"
-		android:color="@color/accent"/>
-</shape>
@@ -1,5 +0,0 @@
-<vector android:height="24dp" android:tint="#FFFFFF"
-    android:viewportHeight="24.0" android:viewportWidth="24.0"
-    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
-    <path android:fillColor="#FF000000" android:pathData="M6,19c0,1.1 0.9,2 2,2h8c1.1,0 2,-0.9 2,-2L18,7L6,7v12zM8.46,11.88l1.41,-1.41L12,12.59l2.12,-2.12 1.41,1.41L13.41,14l2.12,2.12 -1.41,1.41L12,15.41l-2.12,2.12 -1.41,-1.41L10.59,14l-2.13,-2.12zM15.5,4l-1,-1h-5l-1,1L5,4v2h14L19,4z"/>
-</vector>
@@ -1,9 +1,3 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M16,1L4,1c-1.1,0 -2,0.9 -2,2v14h2L4,3h12L16,1zM19,5L8,5c-1.1,0 -2,0.9 -2,2v14c0,1.1 0.9,2 2,2h11c1.1,0 2,-0.9 2,-2L21,7c0,-1.1 -0.9,-2 -2,-2zM19,21L8,21L8,7h11v14z"/>
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="24.0" android:viewportHeight="24.0">
+    <path android:fillColor="#FFFFFFFF" android:pathData="M16 1H4C2.9 1 2 1.9 2 3v14h2V3h12V1zm3 4H8C6.9 5 6 5.9 6 7v14c0 1.1 0.9 2 2 2h11c1.1 0 2-0.9 2-2V7c0-1.1-0.9-2-2-2zm0 16H8V7h11v14z"/>
 </vector>
@@ -1,9 +1,3 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M19,13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/>
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="24.0" android:viewportHeight="24.0">
+    <path android:fillColor="#FFFFFFFF" android:pathData="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z"/>
 </vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M3 17.25V21h3.75L17.81 9.94l-3.75-3.75L3 17.25zM20.71 7.04c0.39-0.39 0.39-1.02 0-1.41l-2.34-2.34c-0.39-0.39-1.02-0.39-1.41 0l-1.83 1.83 3.75 3.75 1.83-1.83z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M9 3L5 6.99h3V14h2V6.99h3L9 3zm7 14.01V10h-2v7.01h-3L15 21l4-3.99h-3z"/>
+</vector>
@@ -1,9 +1,3 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M7,2v11h3v9l7,-12h-4l4,-8z"/>
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="24.0" android:viewportHeight="24.0">
+    <path android:fillColor="#FFFFFFFF" android:pathData="M7 2v11h3v9l7-12h-4l4-8z"/>
 </vector>
@@ -1,5 +1,3 @@
-<vector android:height="24dp" android:tint="#FFFFFF"
-    android:viewportHeight="24.0" android:viewportWidth="24.0"
-    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
-    <path android:fillColor="#FF000000" android:pathData="M13,3c-4.97,0 -9,4.03 -9,9L1,12l3.89,3.89 0.07,0.14L9,12L6,12c0,-3.87 3.13,-7 7,-7s7,3.13 7,7 -3.13,7 -7,7c-1.93,0 -3.68,-0.79 -4.94,-2.06l-1.42,1.42C8.27,19.99 10.51,21 13,21c4.97,0 9,-4.03 9,-9s-4.03,-9 -9,-9zM12,8v5l4.28,2.54 0.72,-1.21 -3.5,-2.08L13.5,8L12,8z"/>
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M13 3c-4.97 0-9 4.03-9 9H1l3.89 3.89 0.07 0.14L9 12H6c0-3.87 3.13-7 7-7s7 3.13 7 7-3.13 7-7 7c-1.93 0-3.68-0.79-4.94-2.06l-1.42 1.42C8.27 19.99 10.51 21 13 21c4.97 0 9-4.03 9-9s-4.03-9-9-9zm-1 5v5l4.28 2.54 0.72-1.21-3.5-2.08V8H12z"/>
 </vector>
@@ -1,9 +1,3 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M12,2C6.48,2 2,6.48 2,12s4.48,10 10,10 10,-4.48 10,-10S17.52,2 12,2zM13,17h-2v-6h2v6zM13,9h-2L11,7h2v2z"/>
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="24.0" android:viewportHeight="24.0">
+    <path android:fillColor="#FFFFFFFF" android:pathData="M12 2C6.48 2 2 6.48 2 12s4.48 10 10 10 10-4.48 10-10S17.52 2 12 2zm1 15h-2v-6h2v6zm0-8h-2V7h2v2z"/>
 </vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M20 4H4C2.9 4 2.01 4.9 2.01 6L2 18c0 1.1 0.9 2 2 2h16c1.1 0 2-0.9 2-2V6c0-1.1-0.9-2-2-2zm0 14H4V8l8 5 8-5v10zm-8-7L4 6h16l-8 5z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M10 6L8.59 7.41 13.17 12l-4.58 4.59L10 18l6-6z"/>
+</vector>
@@ -1,9 +1,3 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-        android:width="24dp"
-        android:height="24dp"
-        android:viewportWidth="24.0"
-        android:viewportHeight="24.0">
-    <path
-        android:fillColor="#FFFFFFFF"
-        android:pathData="M19,4L5,4c-1.11,0 -2,0.9 -2,2v12c0,1.1 0.89,2 2,2h4v-2L5,18L5,8h14v10h-4v2h4c1.1,0 2,-0.9 2,-2L21,6c0,-1.1 -0.89,-2 -2,-2zM12,10l-4,4h3v6h2v-6h3l-4,-4z"/>
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:width="24dp" android:height="24dp" android:viewportWidth="24.0" android:viewportHeight="24.0">
+    <path android:fillColor="#FFFFFFFF" android:pathData="M19 4H5C3.89 4 3 4.9 3 6v12c0 1.1 0.89 2 2 2h4v-2H5V8h14v10h-4v2h4c1.1 0 2-0.9 2-2V6c0-1.1-0.89-2-2-2zm-7 6l-4 4h3v6h2v-6h3l-4-4z"/>
 </vector>
@@ -0,0 +1,3 @@
+<vector xmlns:android="http://schemas.android.com/apk/res/android" android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp">
+    <path android:fillColor="#FF000000" android:pathData="M14 10H2v2h12v-2zm0-4H2v2h12V6zm4 8v-4h-2v4h-4v2h4v4h2v-4h4v-2h-4zM2 16h8v-2H2v2z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M6 2C4.9 2 4.01 2.9 4.01 4L4 20c0 1.1 0.89 2 1.99 2H18c1.1 0 2-0.9 2-2V8l-6-6H6zm7 7V3.5L18.5 9H13z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24" android:viewportWidth="24" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M19.1 12.9a2.8 2.8 0 0 0 0.1-0.9 2.8 2.8 0 0 0-0.1-0.9l2.1-1.6a0.7 0.7 0 0 0 0.1-0.6l-1.9-3.4a0.7 0.7 0 0 0-0.6-0.2l-2.4 1a6.5 6.5 0 0 0-1.6-0.9l-0.4-2.6a0.5 0.5 0 0 0-0.5-0.4h-3.8a0.5 0.5 0 0 0-0.5 0.4L9.3 5.4a5.6 5.6 0 0 0-1.7 0.9l-2.4-1a0.4 0.4 0 0 0-0.5 0.2l-2 3.4c-0.1 0.2 0 0.4 0.2 0.6l2 1.6A2.8 2.8 0 0 0 4.8 12a2.8 2.8 0 0 0 0.1 0.9l-2.1 1.6a0.7 0.7 0 0 0-0.1 0.6l1.9 3.4a0.7 0.7 0 0 0 0.6 0.2l2.4-1a6.5 6.5 0 0 0 1.6 0.9l0.4 2.6a0.5 0.5 0 0 0 0.5 0.4h3.8a0.5 0.5 0 0 0 0.5-0.4l0.3-2.6a5.6 5.6 0 0 0 1.7-0.9l2.4 1a0.4 0.4 0 0 0 0.5-0.2l2-3.4c0.1-0.2 0-0.4-0.2-0.6zM12 15.6a3.6 3.6 0 1 1 3.6-3.6 3.6 3.6 0 0 1-3.6 3.6z"/>
+</vector>
@@ -1,5 +1,3 @@
-<vector android:height="24dp" android:tint="#FFFFFF"
-    android:viewportHeight="24.0" android:viewportWidth="24.0"
-    android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
-    <path android:fillColor="#FF000000" android:pathData="M12,2C6.48,2 2,6.48 2,12s4.48,10 10,10 10,-4.48 10,-10S17.52,2 12,2zM17,13L7,13v-2h10v2z"/>
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M6 19c0 1.1 0.9 2 2 2h8c1.1 0 2-0.9 2-2V7H6v12zM19 4h-3.5l-1-1h-5l-1 1H5v2h14V4z"/>
 </vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M15.55 5.55L11 1v3.07C7.06 4.56 4 7.92 4 12s3.05 7.44 7 7.93v-2.02C8.16 17.43 6 14.97 6 12s2.16-5.43 5-5.91V10l4.55-4.45zM19.93 11c-0.17-1.39-0.72-2.73-1.62-3.89l-1.42 1.42c0.54 0.75 0.88 1.6 1.02 2.47h2.02zM13 17.9v2.02c1.39-0.17 2.74-0.71 3.9-1.61l-1.44-1.44c-0.75 0.54-1.59 0.89-2.46 1.03zm3.89-2.42l1.42 1.41c0.9-1.16 1.45-2.5 1.62-3.89h-2.02c-0.14 0.87-0.48 1.72-1.02 2.48z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M17 3H5C3.89 3 3 3.9 3 5v14c0 1.1 0.89 2 2 2h14c1.1 0 2-0.9 2-2V7l-4-4zm-5 16c-1.66 0-3-1.34-3-3s1.34-3 3-3 3 1.34 3 3-1.34 3-3 3zm3-10H5V5h10v4z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M15.5 14h-0.79l-0.28-0.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-0.59 4.23-1.57L14 14.71v0.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/>
+</vector>
@@ -0,0 +1,3 @@
+<vector android:height="24dp" android:tint="#FFFFFF" android:viewportHeight="24.0" android:viewportWidth="24.0" android:width="24dp" xmlns:android="http://schemas.android.com/apk/res/android">
+    <path android:fillColor="#FF000000" android:pathData="M15.5 14h-0.79l-0.28-0.27C15.41 12.59 16 11.11 16 9.5 16 5.91 13.09 3 9.5 3S3 5.91 3 9.5 5.91 16 9.5 16c1.61 0 3.09-0.59 4.23-1.57L14 14.71v0.79l5 4.99L20.49 19l-4.99-5zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"/>
+</vector>
--- a/Show More
+++ b/Show More