Merge main and common module to simplify.

2026-09-14 18:26:11 -04:00 · 2025-09-29 13:36:43 +02:00
parent deb012600d
commit be8f4919c8
278 changed files with 142 additions and 117 deletions
@@ -5,7 +5,6 @@ plugins {
    id("kotlin-kapt")
    id("kotlin-parcelize")
 }
-apply(plugin = "dagger.hilt.android.plugin")

 android {
    compileSdk = ProjectConfig.compileSdk
@@ -28,7 +27,6 @@ android {
    }

    compileOptions {
-        isCoreLibraryDesugaringEnabled = true
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }
@@ -72,28 +70,8 @@ android {
        }
    }

-    testOptions {
-        unitTests {
-            isIncludeAndroidResources = true
-        }
-        //noinspection WrongGradleMethod
-        tasks.withType<Test> {
-            useJUnitPlatform()
-        }
-    }
 }

 dependencies {
-    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:2.1.5")
-
-    addBaseAndroid()
-    addBaseAndroidUi()
-    addBaseKotlin()
-    addDagger()
-    addMoshi()
-    addBaseWorkManager()
-    addNavigation()
-
-    addTesting()

 }
@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest>
-
-</manifest>
@@ -1,17 +0,0 @@
-package eu.darken.capod.debug.autoreport
-
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import eu.darken.capod.common.debug.autoreport.AutomaticBugReporter
-import eu.darken.capod.debug.autoreport.FossAutoReporting
-import javax.inject.Singleton
-
-@InstallIn(SingletonComponent::class)
-@Module
-abstract class AutoReportingModule {
-    @Binds
-    @Singleton
-    abstract fun autoreporting(foss: FossAutoReporting): AutomaticBugReporter
-}
@@ -1,17 +0,0 @@
-package eu.darken.capod.debug.autoreport
-
-import android.app.Application
-import eu.darken.capod.common.debug.autoreport.AutomaticBugReporter
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class FossAutoReporting @Inject constructor() : AutomaticBugReporter {
-    override fun setup(application: Application) {
-        // NOOP
-    }
-
-    override fun notify(throwable: Throwable) {
-        throw IllegalStateException("Who initliazed this? Without setup no calls to here!")
-    }
-}
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest>
-
-    <application>
-
-    </application>
-
-</manifest>
@@ -1,16 +0,0 @@
-package eu.darken.capod.debug.autoreport
-
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import eu.darken.capod.common.debug.autoreport.AutomaticBugReporter
-import javax.inject.Singleton
-
-@InstallIn(SingletonComponent::class)
-@Module
-abstract class AutoReportingModule {
-    @Binds
-    @Singleton
-    abstract fun autoreporting(foss: GplayAutoReporting): AutomaticBugReporter
-}
@@ -1,42 +0,0 @@
-package eu.darken.capod.debug.autoreport
-
-import android.app.Application
-import android.content.Context
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.InstallId
-import eu.darken.capod.common.debug.Bugs
-import eu.darken.capod.common.debug.DebugSettings
-import eu.darken.capod.common.debug.autoreport.AutomaticBugReporter
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class GplayAutoReporting @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val debugSettings: DebugSettings,
-    private val installId: InstallId,
-) : AutomaticBugReporter {
-
-    override fun setup(application: Application) {
-        val isEnabled = debugSettings.isAutoReportingEnabled.value
-        log(TAG) { "setup(): isEnabled=$isEnabled" }
-
-        if (!isEnabled) return
-
-        // Currently no 3rd party bug tracking
-
-        Bugs.reporter = this
-    }
-
-    override fun notify(throwable: Throwable) {
-        log(TAG, WARN) { "notify($throwable)" }
-    }
-
-    companion object {
-        private val TAG = logTag("Debug", "AutoReport")
-    }
-
-}
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="eu.darken.capod.common">
-
-    <uses-permission android:name="android.permission.ACCESS_BACKGROUND_LOCATION" />
-
-    <uses-permission
-        android:name="android.permission.BLUETOOTH"
-        android:maxSdkVersion="30" />
-    <uses-permission
-        android:name="android.permission.BLUETOOTH_ADMIN"
-        android:maxSdkVersion="30" />
-
-    <uses-permission
-        android:name="android.permission.ACCESS_COARSE_LOCATION"
-        android:maxSdkVersion="30" />
-    <uses-permission
-        android:name="android.permission.ACCESS_FINE_LOCATION"
-        android:maxSdkVersion="30" />
-
-    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
-    <uses-permission
-        android:name="android.permission.BLUETOOTH_SCAN"
-        android:usesPermissionFlags="neverForLocation" />
-
-    <application>
-        <receiver
-            android:name=".bluetooth.BleScanResultReceiver"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="eu.darken.capod.bluetooth.DELIVER_SCAN_RESULTS" />
-            </intent-filter>
-        </receiver>
-    </application>
-</manifest>
@@ -1,10 +0,0 @@
-import android.content.BroadcastReceiver
-import eu.darken.capod.common.debug.logging.log
-
-fun BroadcastReceiver.PendingResult.finish2(): Boolean = try {
-    finish()
-    true
-} catch (e: IllegalStateException) {
-    log { "BroadcastReceiver.PendingResult.finish() failed: $e" }
-    false
-}
@@ -1,44 +0,0 @@
-package eu.darken.capod.common
-
-
-// Can't be const because that prevents them from being mocked in tests
-@Suppress("MayBeConstant")
-object BuildConfigWrap {
-    val DEBUG: Boolean = BuildConfig.DEBUG
-
-    val BUILD_TYPE: BuildType = when (val typ = BuildConfig.BUILD_TYPE) {
-        "debug" -> BuildType.DEV
-        "beta" -> BuildType.BETA
-        "release" -> BuildType.RELEASE
-        else -> throw IllegalArgumentException("Unknown buildtype: $typ")
-    }
-
-    enum class BuildType {
-        DEV,
-        BETA,
-        RELEASE,
-        ;
-    }
-
-    val FLAVOR: Flavor = when (val flav = BuildConfig.FLAVOR) {
-        "gplay" -> Flavor.GPLAY
-        "foss" -> Flavor.FOSS
-        else -> throw IllegalStateException("Unknown flavor: $flav")
-    }
-
-    enum class Flavor {
-        GPLAY,
-        FOSS,
-        ;
-    }
-
-    val APPLICATION_ID: String = BuildConfig.APPLICATION_ID
-
-    val VERSION_CODE: Long = BuildConfig.VERSION_CODE.toLong()
-    val VERSION_NAME: String = BuildConfig.VERSION_NAME
-    val GIT_SHA: String = BuildConfig.GITSHA
-
-    val VERSION_DESCRIPTION_LONG: String = "v$VERSION_NAME ($VERSION_CODE) [$GIT_SHA] ${FLAVOR}_$BUILD_TYPE"
-    val VERSION_DESCRIPTION_SHORT: String = "v$VERSION_NAME [$GIT_SHA] $FLAVOR"
-    val VERSION_DESCRIPTION_TINY: String = "v$VERSION_NAME"
-}
@@ -1,18 +0,0 @@
-package eu.darken.capod.common
-
-import android.os.Build
-
-// Can't be const because that prevents them from being mocked in tests
-@Suppress("MayBeConstant")
-object BuildWrap {
-
-    val VERSION = VersionWrap
-
-    object VersionWrap {
-        val SDK_INT = Build.VERSION.SDK_INT
-    }
-}
-
-fun hasApiLevel(level: Int): Boolean = BuildWrap.VersionWrap.SDK_INT >= level
-
-fun withinApiLevel(start: Int, end: Int): Boolean = BuildWrap.VersionWrap.SDK_INT in start..end
@@ -1,29 +0,0 @@
-package eu.darken.capod.common
-
-import java.util.BitSet
-
-fun Byte.toHex(): String = String.format("%02X", this)
-fun UByte.toHex(): String = this.toByte().toHex()
-
-val Byte.upperNibble get() = (this.toInt() shr 4 and 0b1111).toShort()
-val Byte.lowerNibble get() = (this.toInt() and 0b1111).toShort()
-val UByte.upperNibble get() = (this.toInt() shr 4 and 0b1111).toUShort()
-val UByte.lowerNibble get() = (this.toInt() and 0b1111).toUShort()
-
-fun Byte.isBitSet(pos: Int): Boolean = BitSet.valueOf(arrayOf(this).toByteArray()).get(pos)
-fun UByte.isBitSet(pos: Int): Boolean = this.toByte().isBitSet(pos)
-
-fun Short.isBitSet(pos: Int): Boolean = this.toByte().isBitSet(pos)
-fun UShort.isBitSet(pos: Int): Boolean = this.toShort().isBitSet(pos)
-
-fun UShort.toBinaryString(): String = Integer.toBinaryString(this.toInt()).padStart(4, '0')
-fun UByte.toBinaryString(): String = Integer.toBinaryString(this.toInt()).padStart(8, '0')
-
-
-fun ByteArray.toHex(separator: String = "-"): String = joinToString(separator) { "%02X".format(it) }
-fun String.fromHex(): ByteArray = this
-    .replace(" ", "")
-    .replace("-", "")
-    .also { require(it.length % 2 == 0) { "Not a HEX string, length: ${it.length}" } }
-    .chunked(2).map { it.toInt(16).toByte() }
-    .toByteArray()
@@ -1,13 +0,0 @@
-package eu.darken.capod.common
-
-import android.content.Context
-import android.text.SpannableString
-import android.text.style.ForegroundColorSpan
-import androidx.annotation.ColorRes
-import androidx.core.content.ContextCompat
-
-fun colorString(context: Context, @ColorRes colorRes: Int, string: String): SpannableString {
-    val colored = SpannableString(string)
-    colored.setSpan(ForegroundColorSpan(ContextCompat.getColor(context, colorRes)), 0, string.length, 0)
-    return colored
-}
@@ -1,40 +0,0 @@
-package eu.darken.capod.common
-
-import android.annotation.SuppressLint
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.content.res.TypedArray
-import androidx.annotation.AttrRes
-import androidx.annotation.ColorInt
-import androidx.annotation.ColorRes
-import androidx.core.content.ContextCompat
-import androidx.fragment.app.Fragment
-
-
-@ColorInt
-fun Context.getColorForAttr(@AttrRes attrId: Int): Int {
-    var typedArray: TypedArray? = null
-    try {
-        typedArray = this.theme.obtainStyledAttributes(intArrayOf(attrId))
-        return typedArray.getColor(0, 0)
-    } finally {
-        typedArray?.recycle()
-    }
-}
-
-@ColorInt
-fun Fragment.getColorForAttr(@AttrRes attrId: Int): Int = requireContext().getColorForAttr(attrId)
-
-@ColorInt
-fun Context.getCompatColor(@ColorRes attrId: Int): Int {
-    return ContextCompat.getColor(this, attrId)
-}
-
-@ColorInt
-fun Fragment.getCompatColor(@ColorRes attrId: Int): Int = requireContext().getCompatColor(attrId)
-
-@SuppressLint("NewApi")
-fun Context.startServiceCompat(intent: Intent): ComponentName? {
-    return if (hasApiLevel(26)) startForegroundService(intent) else startService(intent)
-}
@@ -1,42 +0,0 @@
-package eu.darken.capod.common
-
-import android.content.Context
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import java.io.File
-import java.util.*
-import java.util.regex.Pattern
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class InstallId @Inject constructor(
-    @ApplicationContext private val context: Context,
-) {
-    private val installIDFile = File(context.filesDir, INSTALL_ID_FILENAME)
-    val id: String by lazy {
-        val existing = if (installIDFile.exists()) {
-            installIDFile.readText().also {
-                if (!UUID_PATTERN.matcher(it).matches()) throw IllegalStateException("Invalid InstallID: $it")
-            }
-        } else {
-            null
-        }
-
-        return@lazy existing ?: UUID.randomUUID().toString().also {
-            log(TAG) { "New install ID created: $it" }
-            installIDFile.writeText(it)
-        }
-    }
-
-    companion object {
-        private val TAG: String = logTag("InstallID")
-        private val UUID_PATTERN = Pattern.compile(
-            "^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$"
-        )
-
-        private const val INSTALL_ID_FILENAME = "installid"
-    }
-}
-
@@ -1,59 +0,0 @@
-package eu.darken.capod.common
-
-import android.media.AudioManager
-import android.os.SystemClock
-import android.view.KeyEvent
-import eu.darken.capod.common.debug.logging.Logging.Priority.INFO
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import kotlinx.coroutines.delay
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class MediaControl @Inject constructor(
-    private val audioManager: AudioManager,
-) {
-
-    val isPlaying: Boolean
-        get() = audioManager.isMusicActive
-
-    suspend fun sendPlay() {
-        log(TAG, INFO) { "sendPlay()" }
-        if (audioManager.isMusicActive) {
-            log(TAG, INFO) { "Music is already playing, not sending play" }
-            return
-        }
-        sendKey(KeyEvent.KEYCODE_MEDIA_PLAY)
-    }
-
-    suspend fun sendPause() {
-        log(TAG, INFO) { "sendPause()" }
-        if (!audioManager.isMusicActive) {
-            log(TAG, INFO) { "Music is not playing, not sending pause" }
-            return
-        }
-        sendKey(KeyEvent.KEYCODE_MEDIA_PAUSE)
-    }
-
-    suspend fun sendPlayPause() {
-        log(TAG) { "sendPlayPause()" }
-        if (audioManager.isMusicActive) {
-            sendPause()
-        } else {
-            sendPlay()
-        }
-    }
-
-    private suspend fun sendKey(keyCode: Int) {
-        log(TAG) { "Sending up+down KeyEvent: $keyCode" }
-        val eventTime = SystemClock.uptimeMillis()
-        audioManager.dispatchMediaKeyEvent(KeyEvent(eventTime, eventTime, KeyEvent.ACTION_DOWN, keyCode, 0))
-        delay(100)
-        audioManager.dispatchMediaKeyEvent(KeyEvent(eventTime + 200, eventTime + 200, KeyEvent.ACTION_UP, keyCode, 0))
-    }
-
-    companion object {
-        private val TAG = logTag("MediaControl")
-    }
-}
@@ -1,5 +0,0 @@
-package eu.darken.capod.common
-
-object PrivacyPolicy {
-    const val URL = "https://capod.darken.eu/privacy"
-}
@@ -1,9 +0,0 @@
-package eu.darken.capod.common
-
-import android.os.SystemClock
-
-object SystemClockWrap {
-
-    val elapsedRealtimeNanos: Long
-        get() = SystemClock.elapsedRealtimeNanos()
-}
@@ -1,22 +0,0 @@
-package eu.darken.capod.common
-
-import android.content.Context
-import android.util.TypedValue
-
-object UIConverter {
-    fun convertDpToPixels(context: Context, dp: Float): Int {
-        return TypedValue.applyDimension(
-            TypedValue.COMPLEX_UNIT_DIP,
-            dp,
-            context.resources.displayMetrics
-        ).toInt()
-    }
-
-    fun convertSpToPixels(context: Context, sp: Float): Int {
-        return TypedValue.applyDimension(
-            TypedValue.COMPLEX_UNIT_SP,
-            sp,
-            context.resources.displayMetrics
-        ).toInt()
-    }
-}
@@ -1,29 +0,0 @@
-package eu.darken.capod.common
-
-import android.content.Context
-import android.content.Intent
-import androidx.core.net.toUri
-import dagger.Reusable
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.debug.logging.Logging.Priority.ERROR
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-import javax.inject.Inject
-
-@Reusable
-class WebpageTool @Inject constructor(
-    @ApplicationContext private val context: Context,
-) {
-
-    fun open(address: String) {
-        val intent = Intent(Intent.ACTION_VIEW, address.toUri()).apply {
-            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        }
-        try {
-            context.startActivity(intent)
-        } catch (e: Exception) {
-            log(ERROR) { "Failed to launch: ${e.asLog()}" }
-        }
-    }
-
-}
@@ -1,44 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.le.ScanResult
-import android.os.Parcelable
-import androidx.core.util.forEach
-import com.squareup.moshi.Json
-import com.squareup.moshi.JsonClass
-import kotlinx.parcelize.Parcelize
-import java.time.Instant
-
-@Parcelize
-@JsonClass(generateAdapter = true)
-data class BleScanResult(
-    @Json(name = "receivedAt") val receivedAt: Instant,
-    @Json(name = "address") val address: String,
-    @Json(name = "rssi") val rssi: Int,
-    @Json(name = "generatedAtNanos") val generatedAtNanos: Long,
-    @Json(name = "manufacturerSpecificData") val manufacturerSpecificData: Map<Int, ByteArray>
-) : Parcelable {
-
-    fun getManufacturerSpecificData(id: Int): ByteArray? = manufacturerSpecificData[id]
-
-    override fun toString(): String {
-        val sb = StringBuilder()
-        manufacturerSpecificData.forEach { (key, value) ->
-            sb.append("$key: ${value.joinToString(separator = " ") { String.format("%02X", it) }}")
-        }
-        return "BleScanResult($rssi, $address, $generatedAtNanos, $sb"
-    }
-
-    companion object {
-        fun fromScanResult(scanResult: ScanResult) = BleScanResult(
-            receivedAt = Instant.now(),
-            address = scanResult.device.address,
-            rssi = scanResult.rssi,
-            generatedAtNanos = scanResult.timestampNanos,
-            manufacturerSpecificData = mutableMapOf<Int, ByteArray>().apply {
-                scanResult.scanRecord?.manufacturerSpecificData?.forEach { key, value ->
-                    this[key] = value
-                }
-            }
-        )
-    }
-}
@@ -1,33 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.le.ScanResult
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableSharedFlow
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class BleScanResultForwarder @Inject constructor() {
-
-    private val forwarder = MutableSharedFlow<Collection<ScanResult>>(
-        replay = 0,
-        extraBufferCapacity = 128,
-        onBufferOverflow = BufferOverflow.DROP_OLDEST
-    )
-    val results: Flow<Collection<ScanResult>> = forwarder
-
-    fun forward(scanResults: Collection<ScanResult>) {
-        log(TAG, VERBOSE) { "forward($scanResults)" }
-        val success = forwarder.tryEmit(scanResults)
-        if (!success) log(TAG, WARN) { "Failed to forward (overflow?) $scanResults" }
-    }
-
-    companion object {
-        private val TAG = logTag("Bluetooth", "BleScanner", "Forwarder")
-    }
-}
@@ -1,64 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.le.BluetoothLeScanner
-import android.bluetooth.le.ScanResult
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import dagger.hilt.android.AndroidEntryPoint
-import eu.darken.capod.common.coroutine.AppScope
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-
-@AndroidEntryPoint
-class BleScanResultReceiver : BroadcastReceiver() {
-
-    @Inject @AppScope lateinit var appScope: CoroutineScope
-    @Inject lateinit var scanResultForwarder: BleScanResultForwarder
-
-    override fun onReceive(context: Context, intent: Intent) {
-        log(TAG, VERBOSE) { "onReceive($context, $intent)" }
-        if (intent.action != ACTION) {
-            log(TAG, WARN) { "Unknown action: ${intent.action}" }
-            return
-        }
-        if (intent.extras == null) {
-            log(TAG) { "Extras are null!" }
-            return
-        }
-
-        val errorCode = intent.getIntExtra(BluetoothLeScanner.EXTRA_ERROR_CODE, 0)
-        log(TAG, VERBOSE) { "errorCode=$errorCode" }
-        if (errorCode != 0) {
-            log(TAG, WARN) { "ScanCallback error code: $errorCode" }
-            return
-        }
-
-        val callbackType = intent.getIntExtra(BluetoothLeScanner.EXTRA_CALLBACK_TYPE, -1)
-        log(TAG, VERBOSE) { "callbackType=$callbackType" }
-
-        val scanResults = intent.getParcelableArrayListExtra<ScanResult>(BluetoothLeScanner.EXTRA_LIST_SCAN_RESULT)
-        log(TAG, VERBOSE) { "scanResults=$scanResults" }
-
-        if (scanResults == null) {
-            log(TAG) { "Scan results were empty!" }
-            return
-        }
-
-        val pending = goAsync()
-        appScope.launch {
-            scanResultForwarder.forward(scanResults)
-            pending.finish()
-        }
-    }
-
-    companion object {
-        private val TAG = logTag("Bluetooth", "BleScanner", "Forwarder", "Receiver")
-        const val ACTION = "eu.darken.capod.bluetooth.DELIVER_SCAN_RESULTS"
-    }
-}
@@ -1,213 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.annotation.SuppressLint
-import android.app.PendingIntent
-import android.bluetooth.le.ScanCallback
-import android.bluetooth.le.ScanFilter
-import android.bluetooth.le.ScanResult
-import android.bluetooth.le.ScanSettings
-import android.content.Context
-import android.content.Intent
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.debug.logging.Logging.Priority.DEBUG
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import eu.darken.capod.common.notifications.PendingIntentCompat
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.launchIn
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.flow.onEach
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class BleScanner @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val bluetoothManager: BluetoothManager2,
-    private val fakeBleData: FakeBleData,
-    private val scanResultForwarder: BleScanResultForwarder,
-) {
-
-    @SuppressLint("MissingPermission") fun scan(
-        filters: Set<ScanFilter>,
-        scannerMode: ScannerMode = ScannerMode.BALANCED,
-        disableOffloadFiltering: Boolean = false,
-        disableOffloadBatching: Boolean = false,
-        disableDirectScanCallback: Boolean = false,
-    ): Flow<Collection<BleScanResult>> = callbackFlow {
-        log(TAG) { "scan(filters=$filters, scannerMode=$scannerMode)" }
-
-        val adapter = bluetoothManager.adapter ?: throw IllegalStateException("Bluetooth adapter unavailable")
-
-        val useOffloadedFiltering = adapter.isOffloadedFilteringSupported.also {
-            log(TAG, if (it) DEBUG else WARN) { "isOffloadedFilteringSupported=$it" }
-        } && !disableOffloadFiltering
-        if (disableOffloadFiltering) log(TAG, WARN) { "Offloaded filtering is disabled!" }
-
-        val useOffloadedBatching = adapter.isOffloadedScanBatchingSupported.also {
-            log(TAG, if (it) DEBUG else WARN) { "isOffloadedScanBatchingSupported=$it" }
-        } && !disableOffloadBatching
-        if (disableOffloadBatching) log(TAG, WARN) { "Offloaded scan-batching is disabled!" }
-
-        if (disableDirectScanCallback) log(TAG, WARN) { "Direct scan callback is disabled!" }
-
-        val scanner = bluetoothManager.scanner ?: throw IllegalStateException("BLE scanner unavailable")
-
-        val filterResults: (Collection<ScanResult>) -> Collection<BleScanResult> = { results ->
-            results
-                .filter { result ->
-                    val passed = when {
-                        useOffloadedFiltering -> true
-                        filters.isEmpty() -> true
-                        else -> filters.any { it.matches(result) }
-                    }
-                    if (!passed) log(TAG, VERBOSE) { "Manually filtered $result" }
-                    passed
-                }
-                .map { BleScanResult.fromScanResult(it) }
-        }
-
-        val callback = object : ScanCallback() {
-            var lastScanAt = System.currentTimeMillis()
-            override fun onScanResult(callbackType: Int, result: ScanResult) {
-                log(TAG, VERBOSE) {
-                    val delay = System.currentTimeMillis() - lastScanAt
-                    lastScanAt = System.currentTimeMillis()
-                    "onScanResult(delay=${delay}ms, callbackType=$callbackType, result=$result)"
-                }
-
-                trySend(filterResults(setOf(result)))
-            }
-
-            override fun onBatchScanResults(results: MutableList<ScanResult>) {
-                log(TAG, VERBOSE) {
-                    val delay = System.currentTimeMillis() - lastScanAt
-                    lastScanAt = System.currentTimeMillis()
-                    "onBatchScanResults(delay=${delay}ms, results=$results)"
-                }
-
-                trySend(filterResults(results))
-            }
-
-            override fun onScanFailed(errorCode: Int) {
-                log(TAG, WARN) { "onScanFailed(errorCode=$errorCode)" }
-            }
-        }
-
-        val forwarderConsumer = if (disableDirectScanCallback) {
-            scanResultForwarder.results
-                .onEach { results -> trySend(filterResults(results)) }
-                .launchIn(this)
-        } else {
-            null
-        }
-
-        val flushJob = if (!disableDirectScanCallback) {
-            launch {
-                log(TAG) { "Flush job launched" }
-                while (isActive) {
-                    log(TAG, VERBOSE) { "Flushing scan results." }
-                    // Can undercut the minimum setReportDelay(), e.g. 5000ms on a Pixel5@12
-                    adapter.bluetoothLeScanner.flushPendingScanResults(callback)
-                    when (scannerMode) {
-                        ScannerMode.LOW_POWER -> break
-                        ScannerMode.BALANCED -> delay(2000)
-                        ScannerMode.LOW_LATENCY -> delay(500)
-                    }
-                }
-            }
-        } else {
-            null
-        }
-
-        val filterList = when {
-            useOffloadedFiltering -> filters.toList()
-            else -> emptyList()
-        }
-
-        val scanSettings = ScanSettings.Builder().apply {
-            setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
-            when (scannerMode) {
-                ScannerMode.LOW_POWER -> {
-                    setScanMode(ScanSettings.SCAN_MODE_LOW_POWER)
-                    setMatchMode(ScanSettings.MATCH_MODE_STICKY)
-                    setNumOfMatches(ScanSettings.MATCH_NUM_MAX_ADVERTISEMENT)
-                }
-                ScannerMode.BALANCED -> {
-                    setScanMode(ScanSettings.SCAN_MODE_BALANCED)
-                    setMatchMode(ScanSettings.MATCH_MODE_STICKY)
-                    setNumOfMatches(ScanSettings.MATCH_NUM_MAX_ADVERTISEMENT)
-                }
-                ScannerMode.LOW_LATENCY -> {
-                    setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
-                    setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE)
-                    setNumOfMatches(ScanSettings.MATCH_NUM_MAX_ADVERTISEMENT)
-                }
-            }
-
-            val delay = if (useOffloadedBatching) {
-                when (scannerMode) {
-                    ScannerMode.LOW_POWER -> 2000L
-                    ScannerMode.BALANCED -> 1000L
-                    ScannerMode.LOW_LATENCY -> 500L
-                }
-            } else {
-                0L // Anything > 0 enables batching
-            }
-            setReportDelay(delay)
-        }.build()
-
-        if (disableDirectScanCallback) {
-            val callbackIntent = createStartIntent()
-            log(TAG) { "Intent callback: startScan(filters=$filters, settings=$scanSettings, callbackIntent=$callbackIntent)" }
-            scanner.startScan(filterList, scanSettings, callbackIntent)
-        } else {
-            log(TAG) { "Direct callback: startScan(filters=$filters, settings=$scanSettings, callback=$callback)" }
-            scanner.startScan(filterList, scanSettings, callback)
-        }
-
-        awaitClose {
-            forwarderConsumer?.cancel()
-            flushJob?.cancel()
-            if (disableDirectScanCallback) {
-                scanner.stopScan(createStopIntent())
-            } else {
-                scanner.stopScan(callback)
-            }
-            log(TAG) { "BleScanner stopped" }
-        }
-    }
-        .map { fakeBleData.maybeAddfakeData(it) }
-
-    private val receiverIntent by lazy {
-        Intent(context, BleScanResultReceiver::class.java).apply {
-            action = BleScanResultReceiver.ACTION
-        }
-    }
-
-    private fun createStartIntent(): PendingIntent = PendingIntent.getBroadcast(
-        context,
-        CALLBACK_INTENT_REQUESTCODE,
-        receiverIntent,
-        PendingIntent.FLAG_UPDATE_CURRENT or PendingIntentCompat.FLAG_MUTABLE
-    )
-
-    private fun createStopIntent(): PendingIntent = PendingIntent.getBroadcast(
-        context,
-        270,
-        receiverIntent,
-        PendingIntentCompat.FLAG_IMMUTABLE
-    )
-
-    companion object {
-        private const val CALLBACK_INTENT_REQUESTCODE = 270
-        private val TAG = logTag("Bluetooth", "BleScanner")
-    }
-}
@@ -1,3 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-typealias BluetoothAddress = String
@@ -1,15 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.BluetoothDevice
-import java.time.Instant
-
-data class BluetoothDevice2(
-    internal val internal: BluetoothDevice,
-    val seenFirstAt: Instant,
-) {
-    val address: BluetoothAddress
-        get() = internal.address
-
-    val name: String?
-        get() = internal.name
-}
@@ -1,26 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.le.ScanFilter
-import android.bluetooth.le.ScanResult
-import android.os.ParcelUuid
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-
-fun BluetoothDevice.hasFeature(uuid: ParcelUuid): Boolean {
-    return uuids?.contains(uuid) ?: false
-}
-
-/**
- * java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.Object android.util.SparseArray.get(int)' on a null object reference
- *  at android.bluetooth.le.ScanRecord.getManufacturerSpecificData(ScanRecord.java:118)
- *  at android.bluetooth.le.ScanFilter.matches(ScanFilter.java:369)
- * ZenFone Max Pro M1 (ZB602KL) (WW) / Max Pro M1 (ZB601KL) (IN) (ZB602KL), Android 9, PKQ1.WW_Phone-16.2017.2009.087-20200826
- * Intel Gemini Lake Chromebook (octopus), Android 9, R99-14469.59.0 release-keys
- */
-fun ScanFilter.matchesSafe(scanResult: ScanResult): Boolean = try {
-    matches(scanResult)
-} catch (e: NullPointerException) {
-    log { "AOSP error: ${e.asLog()}" }
-    false
-}
@@ -1,231 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothHeadset
-import android.bluetooth.BluetoothManager
-import android.bluetooth.BluetoothProfile
-import android.bluetooth.le.BluetoothLeScanner
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.os.Handler
-import android.os.HandlerThread
-import android.os.ParcelUuid
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.coroutine.DispatcherProvider
-import eu.darken.capod.common.debug.Bugs
-import eu.darken.capod.common.debug.logging.Logging.Priority.ERROR
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-import eu.darken.capod.pods.core.apple.protocol.ContinuityProtocol
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.flow.first
-import kotlinx.coroutines.flow.flatMapLatest
-import kotlinx.coroutines.flow.flow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import java.io.IOException
-import java.time.Instant
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class BluetoothManager2 @Inject constructor(
-    private val manager: BluetoothManager,
-    @ApplicationContext private val context: Context,
-    private val dispatcherProvider: DispatcherProvider,
-) {
-
-    val adapter: BluetoothAdapter?
-        get() = manager.adapter
-
-    val scanner: BluetoothLeScanner?
-        get() = adapter?.bluetoothLeScanner
-
-    val isBluetoothEnabled: Flow<Boolean> = callbackFlow {
-        send(manager.adapter?.isEnabled ?: false)
-
-        val receiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                if (BluetoothAdapter.ACTION_STATE_CHANGED != intent.action) {
-                    log(TAG) { "Unknown BluetoothAdapter action: $intent" }
-                    return
-                }
-
-                val value = when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)) {
-                    BluetoothAdapter.STATE_OFF -> false
-                    BluetoothAdapter.STATE_ON -> true
-                    else -> false
-                }
-
-                trySend(value)
-            }
-        }
-        context.registerReceiver(receiver, IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED))
-        awaitClose { context.unregisterReceiver(receiver) }
-    }
-
-    fun getBluetoothProfile(profile: Int = BluetoothProfile.HEADSET): Flow<BluetoothProfile2> = callbackFlow {
-        log(TAG, VERBOSE) { "getBluetoothProfile(profile=$profile)" }
-
-        var profileProxy: BluetoothProfile2? = null
-        manager.adapter.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
-            override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                log(TAG, VERBOSE) { "onServiceConnected(profile=$profile, proxy=$proxy)" }
-
-                profileProxy = BluetoothProfile2(
-                    profileType = profile,
-                    profileProxy = proxy,
-                ).also { trySend(it) }
-            }
-
-            override fun onServiceDisconnected(profile: Int) {
-                log(TAG, WARN) { "onServiceDisconnected(profile=$profile)" }
-                close(IOException("BluetoothProfile service disconnected (profile=$profile)"))
-            }
-
-        }, profile)
-
-        awaitClose {
-            log(TAG) { "Closing BluetoothProfile: $profileProxy" }
-            profileProxy?.let {
-                manager.adapter.closeProfileProxy(it.profileType, it.proxy)
-            }
-        }
-    }
-
-
-    private fun monitorDevicesForProfile(
-        profile: Int = BluetoothProfile.HEADSET
-    ): Flow<Set<BluetoothDevice>> = getBluetoothProfile(profile).flatMapLatest { bluetoothProfile ->
-        callbackFlow {
-            log(TAG, VERBOSE) { "connectedDevices(profile=$profile) starting" }
-            trySend(bluetoothProfile.connectedDevices)
-
-            val filter = IntentFilter().apply {
-                addAction(BluetoothDevice.ACTION_ACL_CONNECTED)
-                addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
-            }
-
-            val handlerThread = HandlerThread("BluetoothEventReceiver").apply {
-                start()
-            }
-            val handler = Handler(handlerThread.looper)
-
-            val receiver: BroadcastReceiver = object : BroadcastReceiver() {
-                override fun onReceive(context: Context, intent: Intent) {
-                    log(TAG, VERBOSE) { "Bluetooth event (intent=$intent, extras=${intent.extras})" }
-                    val action = intent.action
-                    if (action == null) {
-                        log(TAG, ERROR) { "Bluetooth event without action, how did we get this?" }
-                        return
-                    }
-                    val device = intent.getParcelableExtra<BluetoothDevice?>(BluetoothDevice.EXTRA_DEVICE)
-                    if (device == null) {
-                        log(TAG, ERROR) { "Connection event is missing EXTRA_DEVICE: ${intent.extras}" }
-                        return
-                    }
-
-                    this@callbackFlow.launch {
-                        val currentDevices = bluetoothProfile.connectedDevices
-
-                        when (action) {
-                            BluetoothDevice.ACTION_ACL_CONNECTED -> {
-                                log(TAG) { "Adding $device to current devices $currentDevices" }
-                                trySend(currentDevices.plus(device))
-                            }
-
-                            BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
-                                log(TAG) { "Removing $device from current devices $currentDevices" }
-                                trySend(currentDevices.minus(device))
-                            }
-                        }
-                    }
-                }
-            }
-            context.registerReceiver(receiver, filter, null, handler)
-
-            awaitClose {
-                log(TAG, VERBOSE) { "connectedDevices(profile=$profile) closed." }
-                context.unregisterReceiver(receiver)
-            }
-        }
-    }
-
-    private val seenDevicesLock = Mutex()
-    private val seenDevicesCache = mutableMapOf<String, Instant>()
-
-    fun connectedDevices(
-        featureFilter: Set<ParcelUuid> = ContinuityProtocol.BLE_FEATURE_UUIDS
-    ): Flow<List<BluetoothDevice2>> = isBluetoothEnabled
-        .flatMapLatest { monitorDevicesForProfile(BluetoothProfile.HEADSET) }
-        .map { devices ->
-            val currentAddresses = devices.map { it.address }
-
-            seenDevicesLock.withLock {
-                val cleanedCache = seenDevicesCache.filterKeys { currentAddresses.contains(it) }
-                seenDevicesCache.clear()
-                seenDevicesCache.putAll(cleanedCache)
-            }
-
-            devices
-                .filter { device -> featureFilter.any { feature -> device.hasFeature(feature) } }
-                .map { device ->
-                    BluetoothDevice2(
-                        internal = device,
-                        seenFirstAt = seenDevicesLock.withLock {
-                            seenDevicesCache[device.address] ?: Instant.now().also {
-                                seenDevicesCache[device.address] = it
-                            }
-                        }
-                    )
-                }
-        }
-
-    fun bondedDevices(): Flow<Set<BluetoothDevice2>> = flow {
-        val rawDevices = adapter?.bondedDevices ?: throw IllegalStateException("Bluetooth adapter unavailable")
-        val wrappedDevices = rawDevices.map { device ->
-
-            BluetoothDevice2(
-                internal = device,
-                seenFirstAt = seenDevicesLock.withLock {
-                    seenDevicesCache[device.address] ?: Instant.now().also {
-                        seenDevicesCache[device.address] = it
-                    }
-                }
-            )
-
-        }.toSet()
-        emit(wrappedDevices)
-    }
-
-    suspend fun nudgeConnection(device: BluetoothDevice2): Boolean = getBluetoothProfile().map { bluetoothProfile ->
-        try {
-            log(TAG) { "Nudging Android connection to $device" }
-
-            val connectMethod = BluetoothHeadset::class.java.getDeclaredMethod(
-                "connect", BluetoothDevice::class.java
-            ).apply { isAccessible = true }
-
-            connectMethod.invoke(bluetoothProfile.proxy, device.internal)
-
-            log(TAG) { "Nudged connection to $device" }
-            true
-        } catch (e: Exception) {
-            Bugs.report(tag = TAG, "BluetoothHeadset.connect(device) is unavailable", exception = e)
-            false
-        }
-    }.first()
-
-    companion object {
-        private val TAG = logTag("Bluetooth", "Manager2")
-    }
-}
@@ -1,16 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothProfile
-
-data class BluetoothProfile2(
-    internal val profileType: Int,
-    private val profileProxy: BluetoothProfile,
-) {
-
-    val proxy: BluetoothProfile
-        get() = profileProxy
-
-    val connectedDevices: Set<BluetoothDevice>
-        get() = proxy.connectedDevices.toSet()
-}
@@ -1,100 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import dagger.Reusable
-import eu.darken.capod.common.SystemClockWrap
-import eu.darken.capod.common.debug.DebugSettings
-import eu.darken.capod.common.fromHex
-import java.time.Instant
-import javax.inject.Inject
-import kotlin.random.Random
-
-@Reusable
-class FakeBleData @Inject constructor(
-    private val debugSettings: DebugSettings,
-) {
-
-    fun maybeAddfakeData(originals: Collection<BleScanResult>): Collection<BleScanResult> {
-        if (!debugSettings.showFakeData.value) return originals
-        return originals + getFakeData()
-    }
-
-    fun getFakeData(): Collection<BleScanResult> {
-        val fakeDevices = mutableListOf<BleScanResult>()
-        // AirPods Gen1
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "78:73:AF:B4:85:22",
-            rssi = Random.nextInt(100) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 100,
-            manufacturerSpecificData = mapOf(76 to "07 19 01 02 20 75 AA B6 31 00 05 9C 5A A4 5D C0 2C A0 B4 6F B9 ED 8E CE 03 97 CA".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-
-        // AirPods Gen2
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "78:73:FF:B4:85:5E",
-            rssi = Random.nextInt(100) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 100,
-            manufacturerSpecificData = mapOf(76 to "07 19 01 0F 20 75 AA B6 31 00 05 9C 5A A4 5D C0 2C A0 B4 6F B9 ED 8E CE 03 97 CA".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-
-        // AirPods Gen3
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "4E:9E:D1:49:D2:6D",
-            rssi = Random.nextInt(15, 75) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 200,
-            manufacturerSpecificData = mapOf(76 to "07 19 01 13 20 55 AF 56 31 00 06 6F E4 DF 10 AF 10 60 81 03 3B 76 D9 C7 11 22 88".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-        // AirPods Max
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "7E:E5:C7:65:D2:B5",
-            rssi = Random.nextInt(15, 75) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 300,
-            manufacturerSpecificData = mapOf(76 to "07 19 01 0A 20 02 05 80 04 0F 44 A7 60 9B F8 3C FD B1 D8 1C 61 EA 82 60 A3 2C 4E".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-        // BeatsFlex
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "5E:9E:D1:49:D2:6D",
-            rssi = Random.nextInt(15, 75) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 400,
-            manufacturerSpecificData = mapOf(76 to "07 19 01 10 20 0A F4 8F 00 01 00 C4 71 9F 9C EF A2 E3 BA 66 FE 1D 45 9F C9 2F A0".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-
-        // Tws i99999
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "5E:9E:D1:29:D2:6D",
-            rssi = Random.nextInt(15, 75) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 400,
-            manufacturerSpecificData = mapOf(76 to "07 13 01 02 20 71 AA 37 32 00 10 00 64 64 FF 00 00 00 00 00 00".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-
-        // Unknown Device
-        BleScanResult(
-            receivedAt = Instant.now(),
-            address = "6E:9E:D1:49:D2:6D",
-            rssi = Random.nextInt(15, 75) * -1,
-            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 500,
-            manufacturerSpecificData = mapOf(76 to "07 19 01 FF 20 0A F4 8F 00 01 00 C4 71 9F 9C EF A2 E3 BA 66 FE 1D 45 9F C9 2F A0".fromHex())
-        ).run {
-            fakeDevices.add(this)
-        }
-
-        return fakeDevices
-    }
-}
@@ -1,25 +0,0 @@
-package eu.darken.capod.common.bluetooth
-
-import androidx.annotation.StringRes
-import com.squareup.moshi.Json
-import com.squareup.moshi.JsonClass
-import eu.darken.capod.common.R
-
-@JsonClass(generateAdapter = false)
-enum class ScannerMode(
-    val identifier: String,
-    @StringRes val labelRes: Int
-) {
-    @Json(name = "scanner.mode.lowpower") LOW_POWER(
-        "scanner.mode.lowpower",
-        R.string.settings_scanner_mode_lowpower_label
-    ),
-    @Json(name = "scanner.mode.balanced") BALANCED(
-        "scanner.mode.balanced",
-        R.string.settings_scanner_mode_balanced_label
-    ),
-    @Json(name = "scanner.mode.lowlatency") LOW_LATENCY(
-        "scanner.mode.lowlatency",
-        R.string.settings_scanner_mode_lowlatency_label
-    ),
-}
@@ -1,10 +0,0 @@
-package eu.darken.capod.common.collections
-
-
-fun Collection<Int>.median(): Int = this.sorted().let {
-    if (it.size % 2 == 0) {
-        (it[it.size / 2] + it[(it.size - 1) / 2]) / 2
-    } else {
-        it[it.size / 2]
-    }
-}
@@ -1,5 +0,0 @@
-package eu.darken.capod.common.collections
-
-inline fun <K, V> Map<K, V>.mutate(block: MutableMap<K, V>.() -> Unit): Map<K, V> {
-    return toMutableMap().apply(block).toMap()
-}
@@ -1,19 +0,0 @@
-package eu.darken.capod.common.coroutine
-
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.SupervisorJob
-import javax.inject.Inject
-import javax.inject.Qualifier
-import javax.inject.Singleton
-import kotlin.coroutines.CoroutineContext
-
-@Singleton
-class AppCoroutineScope @Inject constructor() : CoroutineScope {
-    override val coroutineContext: CoroutineContext = SupervisorJob() + Dispatchers.Default
-}
-
-@Qualifier
-@MustBeDocumented
-@Retention(AnnotationRetention.RUNTIME)
-annotation class AppScope
@@ -1,19 +0,0 @@
-package eu.darken.capod.common.coroutine
-
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import kotlinx.coroutines.CoroutineScope
-
-@InstallIn(SingletonComponent::class)
-@Module
-abstract class CoroutineModule {
-
-    @Binds
-    abstract fun dispatcherProvider(defaultProvider: DefaultDispatcherProvider): DispatcherProvider
-
-    @Binds
-    @AppScope
-    abstract fun appscope(appCoroutineScope: AppCoroutineScope): CoroutineScope
-}
@@ -1,7 +0,0 @@
-package eu.darken.capod.common.coroutine
-
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class DefaultDispatcherProvider @Inject constructor() : DispatcherProvider
@@ -1,21 +0,0 @@
-package eu.darken.capod.common.coroutine
-
-import kotlinx.coroutines.Dispatchers
-import kotlin.coroutines.CoroutineContext
-
-// Need this to improve testing
-// Can currently only replace the main-thread dispatcher.
-// https://github.com/Kotlin/kotlinx.coroutines/issues/1365
-@Suppress("PropertyName", "VariableNaming")
-interface DispatcherProvider {
-    val Default: CoroutineContext
-        get() = Dispatchers.Default
-    val Main: CoroutineContext
-        get() = Dispatchers.Main
-    val MainImmediate: CoroutineContext
-        get() = Dispatchers.Main.immediate
-    val Unconfined: CoroutineContext
-        get() = Dispatchers.Unconfined
-    val IO: CoroutineContext
-        get() = Dispatchers.IO
-}
@@ -1,42 +0,0 @@
-package eu.darken.capod.common.dagger
-
-import android.app.Application
-import android.app.NotificationManager
-import android.bluetooth.BluetoothManager
-import android.content.Context
-import android.media.AudioManager
-import androidx.work.WorkManager
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@InstallIn(SingletonComponent::class)
-@Module
-class AndroidModule {
-
-    @Provides
-    @Singleton
-    fun context(app: Application): Context = app.applicationContext
-
-    @Provides
-    @Singleton
-    fun notificationManager(context: Context): NotificationManager =
-        context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-
-    @Provides
-    @Singleton
-    fun bluetoothManager(context: Context): BluetoothManager =
-        context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
-
-    @Provides
-    @Singleton
-    fun workerManager(context: Context): WorkManager =
-        WorkManager.getInstance(context)
-
-    @Provides
-    @Singleton
-    fun audioManager(context: Context): AudioManager =
-        context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-}
@@ -1,25 +0,0 @@
-package eu.darken.capod.common.debug
-
-import eu.darken.capod.common.debug.autoreport.AutomaticBugReporter
-import eu.darken.capod.common.debug.logging.Logging.Priority.*
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-
-object Bugs {
-    var reporter: AutomaticBugReporter? = null
-    fun report(
-        tag: String,
-        message: String,
-        exception: Throwable
-    ) {
-        log(TAG, VERBOSE) { "Reporting $exception" }
-        log(tag, ERROR) { "$message\n${exception.asLog()}" }
-
-        reporter?.notify(exception) ?: run {
-            log(TAG, WARN) { "Bug tracking not initialized yet." }
-        }
-    }
-
-    private val TAG = logTag("Bugs")
-}
@@ -1,38 +0,0 @@
-package eu.darken.capod.common.debug
-
-import android.content.Context
-import android.content.SharedPreferences
-import androidx.preference.PreferenceDataStore
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.BuildConfigWrap
-import eu.darken.capod.common.preferences.PreferenceStoreMapper
-import eu.darken.capod.common.preferences.Settings
-import eu.darken.capod.common.preferences.createFlowPreference
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class DebugSettings @Inject constructor(
-    @ApplicationContext private val context: Context,
-) : Settings() {
-
-    override val preferences: SharedPreferences = context.getSharedPreferences("settings_debug", Context.MODE_PRIVATE)
-
-    val isAutoReportingEnabled = preferences.createFlowPreference(
-        key = "debug.bugreport.automatic.enabled",
-        // Reporting is opt-out for gplay, and opt-in for github builds
-        defaultValue = BuildConfigWrap.FLAVOR == BuildConfigWrap.Flavor.GPLAY
-    )
-    val isDebugModeEnabled = preferences.createFlowPreference("debug.mode.enabled", false)
-
-    val showFakeData = preferences.createFlowPreference("debug.fakedata.enabled", false)
-
-    val showUnfiltered = preferences.createFlowPreference("debug.blescanner.unfiltered.enabled", false)
-
-    override val preferenceDataStore: PreferenceDataStore = PreferenceStoreMapper(
-        isDebugModeEnabled,
-        showFakeData,
-        showUnfiltered,
-    )
-
-}
@@ -1,10 +0,0 @@
-package eu.darken.capod.common.debug.autoreport
-
-import android.app.Application
-
-interface AutomaticBugReporter {
-
-    fun setup(application: Application)
-
-    fun notify(throwable: Throwable)
-}
@@ -1,79 +0,0 @@
-package eu.darken.capod.common.debug.logging
-
-import android.annotation.SuppressLint
-import android.util.Log
-import java.io.File
-import java.io.FileOutputStream
-import java.io.IOException
-import java.io.OutputStreamWriter
-import java.time.Instant
-
-
-@SuppressLint("LogNotTimber")
-class FileLogger(private val logFile: File) : Logging.Logger {
-    private var logWriter: OutputStreamWriter? = null
-
-    @SuppressLint("SetWorldReadable")
-    @Synchronized
-    fun start() {
-        if (logWriter != null) return
-
-        logFile.parentFile!!.mkdirs()
-        if (logFile.createNewFile()) {
-            Log.i(TAG, "File logger writing to " + logFile.path)
-        }
-        if (logFile.setReadable(true, false)) {
-            Log.i(TAG, "Debug run log read permission set")
-        }
-
-        try {
-            logWriter = OutputStreamWriter(FileOutputStream(logFile, true))
-            logWriter!!.write("=== BEGIN ===\n")
-            logWriter!!.write("Logfile: $logFile\n")
-            logWriter!!.flush()
-            Log.i(TAG, "File logger started.")
-        } catch (e: IOException) {
-            e.printStackTrace()
-
-            logFile.delete()
-            if (logWriter != null) logWriter!!.close()
-        }
-
-    }
-
-    @Synchronized
-    fun stop() {
-        logWriter?.let {
-            logWriter = null
-            try {
-                it.write("=== END ===\n")
-                it.close()
-            } catch (ignore: IOException) {
-            }
-            Log.i(TAG, "File logger stopped.")
-        }
-    }
-
-    override fun log(priority: Logging.Priority, tag: String, message: String, metaData: Map<String, Any>?) {
-        logWriter?.let {
-            try {
-                it.write("${Instant.ofEpochMilli(System.currentTimeMillis())}  ${priority.shortLabel}/$tag: $message\n")
-                it.flush()
-            } catch (e: IOException) {
-                Log.e(TAG, "Failed to write log line.", e)
-                try {
-                    it.close()
-                } catch (ignore: Exception) {
-                }
-                logWriter = null
-            }
-        }
-    }
-
-    override fun toString(): String = "FileLogger(file=$logFile)"
-
-    companion object {
-        private val TAG = logTag("Debug", "FileLogger")
-    }
-}
-
@@ -1,49 +0,0 @@
-package eu.darken.capod.common.debug.logging
-
-import android.os.Build
-import android.util.Log
-import kotlin.math.min
-
-class LogCatLogger : Logging.Logger {
-
-    override fun isLoggable(priority: Logging.Priority): Boolean = true
-
-    override fun log(priority: Logging.Priority, tag: String, message: String, metaData: Map<String, Any>?) {
-
-        val trimmedTag = if (tag.length <= MAX_TAG_LENGTH || Build.VERSION.SDK_INT >= 26) {
-            tag
-        } else {
-            tag.substring(0, MAX_TAG_LENGTH)
-        }
-
-        if (message.length < MAX_LOG_LENGTH) {
-            writeToLogcat(priority.intValue, trimmedTag, message)
-            return
-        }
-
-        // Split by line, then ensure each line can fit into Log's maximum length.
-        var i = 0
-        val length = message.length
-        while (i < length) {
-            var newline = message.indexOf('\n', i)
-            newline = if (newline != -1) newline else length
-            do {
-                val end = min(newline, i + MAX_LOG_LENGTH)
-                val part = message.substring(i, end)
-                writeToLogcat(priority.intValue, trimmedTag, part)
-                i = end
-            } while (i < newline)
-            i++
-        }
-    }
-
-    private fun writeToLogcat(priority: Int, tag: String, part: String) = when (priority) {
-        Log.ASSERT -> Log.wtf(tag, part)
-        else -> Log.println(priority, tag, part)
-    }
-
-    companion object {
-        private const val MAX_LOG_LENGTH = 4000
-        private const val MAX_TAG_LENGTH = 23
-    }
-}
@@ -1,10 +0,0 @@
-package eu.darken.capod.common.debug.logging
-
-fun logTag(vararg tags: String): String {
-    val sb = StringBuilder("CAP:")
-    for (i in tags.indices) {
-        sb.append(tags[i])
-        if (i < tags.size - 1) sb.append(":")
-    }
-    return sb.toString()
-}
@@ -1,132 +0,0 @@
-package eu.darken.capod.common.debug.logging
-
-import java.io.PrintWriter
-import java.io.StringWriter
-
-/**
- * Inspired by
- * https://github.com/PaulWoitaschek/Slimber
- * https://github.com/square/logcat
- * https://github.com/JakeWharton/timber
- */
-
-object Logging {
-    enum class Priority(
-        val intValue: Int,
-        val shortLabel: String
-    ) {
-        VERBOSE(2, "V"),
-        DEBUG(3, "D"),
-        INFO(4, "I"),
-        WARN(5, "W"),
-        ERROR(6, "E"),
-        ASSERT(7, "WTF");
-    }
-
-    interface Logger {
-        fun isLoggable(priority: Priority): Boolean = true
-
-        fun log(
-            priority: Priority,
-            tag: String,
-            message: String,
-            metaData: Map<String, Any>?
-        )
-    }
-
-    private val internalLoggers = mutableListOf<Logger>()
-
-    val loggers: List<Logger>
-        get() = synchronized(internalLoggers) { internalLoggers.toList() }
-
-    val hasReceivers: Boolean
-        get() = synchronized(internalLoggers) {
-            internalLoggers.isNotEmpty()
-        }
-
-    fun install(logger: Logger) {
-        synchronized(internalLoggers) { internalLoggers.add(logger) }
-        log { "Was installed $logger" }
-    }
-
-    fun remove(logger: Logger) {
-        log { "Removing: $logger" }
-        synchronized(internalLoggers) { internalLoggers.remove(logger) }
-    }
-
-    fun logInternal(
-        tag: String,
-        priority: Priority,
-        metaData: Map<String, Any>?,
-        message: String
-    ) {
-        val snapshot = synchronized(internalLoggers) { internalLoggers.toList() }
-        snapshot
-            .filter { it.isLoggable(priority) }
-            .forEach {
-                it.log(
-                    priority = priority,
-                    tag = tag,
-                    metaData = metaData,
-                    message = message
-                )
-            }
-    }
-
-    fun clearAll() {
-        log { "Clearing all loggers" }
-        synchronized(internalLoggers) { internalLoggers.clear() }
-    }
-}
-
-inline fun Any.log(
-    priority: Logging.Priority = Logging.Priority.DEBUG,
-    metaData: Map<String, Any>? = null,
-    message: () -> String,
-) {
-    if (Logging.hasReceivers) {
-        Logging.logInternal(
-            tag = "CAP:${logTagViaCallSite()}",
-            priority = priority,
-            metaData = metaData,
-            message = message(),
-        )
-    }
-}
-
-inline fun log(
-    tag: String,
-    priority: Logging.Priority = Logging.Priority.DEBUG,
-    metaData: Map<String, Any>? = null,
-    message: () -> String,
-) {
-    if (Logging.hasReceivers) {
-        Logging.logInternal(
-            tag = tag,
-            priority = priority,
-            metaData = metaData,
-            message = message(),
-        )
-    }
-}
-
-fun Throwable.asLog(): String {
-    val stringWriter = StringWriter(256)
-    val printWriter = PrintWriter(stringWriter, false)
-    printStackTrace(printWriter)
-    printWriter.flush()
-    return stringWriter.toString()
-}
-
-@PublishedApi
-internal fun Any.logTagViaCallSite(): String {
-    val javaClass = this::class.java
-    val fullClassName = javaClass.name
-    val outerClassName = fullClassName.substringBefore('$')
-    val simplerOuterClassName = outerClassName.substringAfterLast('.')
-    return if (simplerOuterClassName.isEmpty()) {
-        fullClassName
-    } else {
-        simplerOuterClassName.removeSuffix("Kt")
-    }
-}
@@ -1,18 +0,0 @@
-package eu.darken.capod.common.error
-
-import android.content.Context
-import com.google.android.material.dialog.MaterialAlertDialogBuilder
-
-fun Throwable.asErrorDialogBuilder(
-    context: Context
-) = MaterialAlertDialogBuilder(context).apply {
-    val error = this@asErrorDialogBuilder
-    val localizedError = error.localized(context)
-
-    setTitle(localizedError.label)
-    setMessage(localizedError.description)
-
-    setPositiveButton(android.R.string.ok) { _, _ ->
-
-    }
-}
@@ -1,7 +0,0 @@
-package eu.darken.capod.common.error
-
-import eu.darken.capod.common.livedata.SingleLiveEvent
-
-interface ErrorEventSource {
-    val errorEvents: SingleLiveEvent<Throwable>
-}
@@ -1,36 +0,0 @@
-package eu.darken.capod.common.error
-
-import android.content.Context
-import eu.darken.capod.common.R
-
-interface HasLocalizedError {
-    fun getLocalizedError(context: Context): LocalizedError
-}
-
-data class LocalizedError(
-    val throwable: Throwable,
-    val label: String,
-    val description: String
-) {
-    fun asText() = "$label:\n$description"
-}
-
-fun Throwable.localized(c: Context): LocalizedError = when {
-    this is HasLocalizedError -> this.getLocalizedError(c)
-    localizedMessage != null -> LocalizedError(
-        throwable = this,
-        label = "${c.getString(R.string.general_error_label)}: ${this::class.simpleName!!}",
-        description = localizedMessage ?: getStackTracePeek()
-    )
-    else -> LocalizedError(
-        throwable = this,
-        label = "${c.getString(R.string.general_error_label)}: ${this::class.simpleName!!}",
-        description = getStackTracePeek()
-    )
-}
-
-private fun Throwable.getStackTracePeek() = this.stackTraceToString()
-    .lines()
-    .filterIndexed { index, _ -> index > 1 }
-    .take(3)
-    .joinToString("\n")
@@ -1,42 +0,0 @@
-package eu.darken.capod.common.error
-
-import java.io.PrintWriter
-import java.io.StringWriter
-import java.lang.reflect.InvocationTargetException
-import kotlin.reflect.KClass
-
-val Throwable.causes: Sequence<Throwable>
-    get() = sequence {
-        var subCause = cause
-        while (subCause != null) {
-            yield(subCause)
-            subCause = subCause.cause
-        }
-    }
-
-fun Throwable.getRootCause(): Throwable {
-    var error = this
-    while (error.cause != null) {
-        error = error.cause!!
-    }
-    if (error is InvocationTargetException) {
-        error = error.targetException
-    }
-    return error
-}
-
-fun Throwable.hasCause(exceptionClazz: KClass<out Throwable>): Boolean {
-    if (exceptionClazz.isInstance(this)) return true
-    return exceptionClazz.isInstance(this.getRootCause())
-}
-
-fun Throwable.getStackTraceString(): String {
-    val sw = StringWriter(256)
-    val pw = PrintWriter(sw, false)
-    printStackTrace(pw)
-    pw.flush()
-    return sw.toString()
-}
-
-fun Throwable.tryUnwrap(kClass: KClass<RuntimeException> = RuntimeException::class): Throwable =
-    if (!kClass.isInstance(this)) this else cause ?: this
@@ -1,155 +0,0 @@
-package eu.darken.capod.common.flow
-
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.channels.BufferOverflow
-import kotlinx.coroutines.flow.*
-import kotlinx.coroutines.plus
-import kotlinx.coroutines.runBlocking
-import kotlinx.coroutines.sync.Mutex
-import kotlinx.coroutines.sync.withLock
-import kotlin.coroutines.CoroutineContext
-
-/**
- * A thread safe stateful flow that can be updated blocking and async with a lazy initial value provider.
- *
- * @param loggingTag will be prepended to logging tag, i.e. "$loggingTag:HD"
- * @param parentScope on which the update operations and callbacks will be executed on
- * @param coroutineContext used in combination with [CoroutineScope]
- * @param startValueProvider provides the first value, errors will be rethrown on [CoroutineScope]
- */
-class DynamicStateFlow<T>(
-    loggingTag: String? = null,
-    parentScope: CoroutineScope,
-    coroutineContext: CoroutineContext = parentScope.coroutineContext,
-    private val onRelease: CoroutineScope.(T) -> Unit = {},
-    private val startValueProvider: suspend CoroutineScope.() -> T,
-) {
-    private val lTag = loggingTag?.let { "$it:DSFlow" }
-
-    private val updateActions = MutableSharedFlow<Update<T>>(
-        replay = Int.MAX_VALUE,
-        extraBufferCapacity = Int.MAX_VALUE,
-        onBufferOverflow = BufferOverflow.SUSPEND
-    )
-    private val valueGuard = Mutex()
-
-    private val producer: Flow<State<T>> = channelFlow {
-        var currentValue = valueGuard.withLock {
-            lTag?.let { log(it, VERBOSE) { "Providing startValue..." } }
-
-            startValueProvider().also { startValue ->
-                val initializer = Update<T>(onError = null, onModify = { startValue })
-                send(State(value = startValue, updatedBy = initializer))
-                lTag?.let { log(it, VERBOSE) { "...startValue provided and emitted." } }
-            }
-        }
-
-        invokeOnClose {
-            lTag?.let { log(it, VERBOSE) { "invokeOnClose executing..." } }
-            onRelease(currentValue)
-            lTag?.let { log(it, VERBOSE) { "internal channelFlow finished." } }
-        }
-
-        updateActions.collect { update ->
-            currentValue = valueGuard.withLock {
-                try {
-                    update.onModify(currentValue).also {
-                        send(State(value = it, updatedBy = update))
-                    }
-                } catch (e: Exception) {
-                    lTag?.let {
-                        log(it, VERBOSE) { "Data modifying failed (onError=${update.onError}): ${e.asLog()}" }
-                    }
-
-                    if (update.onError != null) {
-                        update.onError.invoke(e)
-                    } else {
-                        send(State(value = currentValue, error = e, updatedBy = update))
-                    }
-
-                    currentValue
-                }
-            }
-        }
-    }
-
-    private val internalFlow = producer
-        .onStart { lTag?.let { log(it, VERBOSE) { "Internal onStart" } } }
-//        .onEach { value -> lTag?.let { log(it, VERBOSE) { "New value: $value" } } }
-        .onCompletion { err ->
-            when {
-                err is CancellationException -> {
-                    lTag?.let { log(it, VERBOSE) { "internal onCompletion() due to cancellation" } }
-                }
-                err != null -> {
-                    lTag?.let { log(it, VERBOSE) { "internal onCompletion() due to error: ${err.asLog()}" } }
-                }
-                else -> {
-                    lTag?.let { log(it, VERBOSE) { "internal onCompletion()" } }
-                }
-            }
-        }
-        .shareIn(
-            scope = parentScope + coroutineContext,
-            replay = 1,
-            started = SharingStarted.Lazily
-        )
-
-    val flow: Flow<T> = internalFlow
-        .map { it.value }
-        .distinctUntilChanged()
-
-    suspend fun value() = flow.first()
-
-    /**
-     * Non blocking update method.
-     * Gets executed on the scope and context this instance was initialized with.
-     *
-     * @param onError if you don't provide this, and exception in [onUpdate] will the scope passed to this class
-     */
-    fun updateAsync(
-        onError: (suspend (Exception) -> Unit) = { throw it },
-        onUpdate: suspend T.() -> T,
-    ) {
-        val update: Update<T> = Update(
-            onModify = onUpdate,
-            onError = onError
-        )
-        runBlocking { updateActions.emit(update) }
-    }
-
-    /**
-     * Blocking update method
-     * Gets executed on the scope and context this instance was initialized with.
-     * Waiting will happen on the callers scope.
-     *
-     * Any errors that occurred during [action] will be rethrown by this method.
-     */
-    suspend fun updateBlocking(action: suspend T.() -> T): T {
-        val update: Update<T> = Update(onModify = action)
-        updateActions.emit(update)
-
-        lTag?.let { log(it, VERBOSE) { "Waiting for update." } }
-        val ourUpdate = internalFlow.first { it.updatedBy == update }
-        lTag?.let { log(it, VERBOSE) { "Finished waiting, got $ourUpdate" } }
-
-        ourUpdate.error?.let { throw it }
-
-        return ourUpdate.value
-    }
-
-    private data class Update<T>(
-        val onModify: suspend T.() -> T,
-        val onError: (suspend (Exception) -> Unit)? = null,
-    )
-
-    private data class State<T>(
-        val value: T,
-        val error: Exception? = null,
-        val updatedBy: Update<T>,
-    )
-}
@@ -1,3 +0,0 @@
-package eu.darken.capod.common.flow
-
-
@@ -1,213 +0,0 @@
-package eu.darken.capod.common.flow
-
-import kotlinx.coroutines.flow.Flow
-
-
-//@Suppress("UNCHECKED_CAST", "LongParameterList")
-//inline fun <T1, T2, R> combine(
-//    flow: Flow<T1>,
-//    flow2: Flow<T2>,
-//    crossinline transform: suspend (T1, T2) -> R
-//): Flow<R> = kotlinx.coroutines.flow.combine(
-//    flow,
-//    flow2
-//) { args: Array<*> ->
-//    transform(
-//        args[0] as T1,
-//        args[1] as T2
-//    )
-//}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    crossinline transform: suspend (T1, T2, T3) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow,
-    flow2,
-    flow3,
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-    )
-}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, T4, T5, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    flow4: Flow<T4>,
-    flow5: Flow<T5>,
-    crossinline transform: suspend (T1, T2, T3, T4, T5) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow,
-    flow2,
-    flow3,
-    flow4,
-    flow5
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-        args[3] as T4,
-        args[4] as T5
-    )
-}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, T4, T5, T6, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    flow4: Flow<T4>,
-    flow5: Flow<T5>,
-    flow6: Flow<T6>,
-    crossinline transform: suspend (T1, T2, T3, T4, T5, T6) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow,
-    flow2,
-    flow3,
-    flow4,
-    flow5,
-    flow6
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-        args[3] as T4,
-        args[4] as T5,
-        args[5] as T6
-    )
-}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, T4, T5, T6, T7, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    flow4: Flow<T4>,
-    flow5: Flow<T5>,
-    flow6: Flow<T6>,
-    flow7: Flow<T7>,
-    crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow,
-    flow2,
-    flow3,
-    flow4,
-    flow5,
-    flow6,
-    flow7
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-        args[3] as T4,
-        args[4] as T5,
-        args[5] as T6,
-        args[6] as T7
-    )
-}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, T4, T5, T6, T7, T8, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    flow4: Flow<T4>,
-    flow5: Flow<T5>,
-    flow6: Flow<T6>,
-    flow7: Flow<T7>,
-    flow8: Flow<T8>,
-    crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow,
-    flow2,
-    flow3,
-    flow4,
-    flow5,
-    flow6,
-    flow7,
-    flow8
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-        args[3] as T4,
-        args[4] as T5,
-        args[5] as T6,
-        args[6] as T7,
-        args[7] as T8
-    )
-}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    flow4: Flow<T4>,
-    flow5: Flow<T5>,
-    flow6: Flow<T6>,
-    flow7: Flow<T7>,
-    flow8: Flow<T8>,
-    flow9: Flow<T9>,
-    flow10: Flow<T10>,
-    crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow, flow2, flow3, flow4, flow5, flow6, flow7, flow8, flow9, flow10
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-        args[3] as T4,
-        args[4] as T5,
-        args[5] as T6,
-        args[6] as T7,
-        args[7] as T8,
-        args[8] as T9,
-        args[9] as T10
-    )
-}
-
-@Suppress("UNCHECKED_CAST", "LongParameterList")
-inline fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, R> combine(
-    flow: Flow<T1>,
-    flow2: Flow<T2>,
-    flow3: Flow<T3>,
-    flow4: Flow<T4>,
-    flow5: Flow<T5>,
-    flow6: Flow<T6>,
-    flow7: Flow<T7>,
-    flow8: Flow<T8>,
-    flow9: Flow<T9>,
-    flow10: Flow<T10>,
-    flow11: Flow<T11>,
-    crossinline transform: suspend (T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) -> R
-): Flow<R> = kotlinx.coroutines.flow.combine(
-    flow, flow2, flow3, flow4, flow5, flow6, flow7, flow8, flow9, flow10, flow11
-) { args: Array<*> ->
-    transform(
-        args[0] as T1,
-        args[1] as T2,
-        args[2] as T3,
-        args[3] as T4,
-        args[4] as T5,
-        args[5] as T6,
-        args[6] as T7,
-        args[7] as T8,
-        args[8] as T9,
-        args[9] as T10,
-        args[10] as T11
-    )
-}
@@ -1,82 +0,0 @@
-package eu.darken.capod.common.flow
-
-import eu.darken.capod.common.debug.logging.Logging.Priority.ERROR
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.error.hasCause
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.*
-import kotlin.time.Duration
-
-/**
- * Create a stateful flow, with the initial value of null, but never emits a null value.
- * Helper method to create a new flow without suspending and without initial value
- * The flow collector will just wait for the first value
- */
-fun <T : Any> Flow<T>.shareLatest(
-    tag: String? = null,
-    scope: CoroutineScope,
-    started: SharingStarted = SharingStarted.WhileSubscribed(replayExpirationMillis = 0)
-) = this
-    .onStart { if (tag != null) log(tag) { "shareLatest(...) start" } }
-    .onEach { if (tag != null) log(tag) { "shareLatest(...) emission: $it" } }
-    .onCompletion { if (tag != null) log(tag) { "shareLatest(...) completed." } }
-    .catch {
-        if (tag != null) log(tag) { "shareLatest(...) catch(): ${it.asLog()}" }
-        throw it
-    }
-    .stateIn(
-        scope = scope,
-        started = started,
-        initialValue = null
-    )
-    .filterNotNull()
-
-fun <T : Any?> Flow<T>.replayingShare(scope: CoroutineScope) = this.shareIn(
-    scope = scope,
-    replay = 1,
-    started = SharingStarted.WhileSubscribed(replayExpiration = Duration.ZERO)
-)
-
-fun <T> Flow<T>.withPrevious(): Flow<Pair<T?, T>> = this
-    .scan(Pair<T?, T?>(null, null)) { previous, current -> Pair(previous.second, current) }
-    .drop(1)
-    .map {
-        @Suppress("UNCHECKED_CAST")
-        it as Pair<T?, T>
-    }
-
-
-fun <T> Flow<T>.onError(block: suspend (Throwable) -> Unit) = this.catch {
-    block(it)
-    throw it
-}
-
-fun <T> Flow<T>.takeUntilAfter(predicate: suspend (T) -> Boolean) = transformWhile {
-    val fullfilled = predicate(it)
-    emit(it)
-    !fullfilled // We keep emitting until condition is fullfilled = true
-}
-
-fun <T> Flow<T>.setupCommonEventHandlers(tag: String, identifier: () -> String) = this
-    .onStart { log(tag, VERBOSE) { "${identifier()}.onStart()" } }
-    .onEach { log(tag, VERBOSE) { "${identifier()}.onEach(): $it" } }
-    .onCompletion { log(tag, VERBOSE) { "${identifier()}.onCompletion()" } }
-    .catch {
-        if (it.hasCause(CancellationException::class)) {
-            log(tag, VERBOSE) { "${identifier()} cancelled" }
-        } else {
-            log(tag, ERROR) { "${identifier()} failed: ${it.asLog()}" }
-            throw it
-        }
-    }
-
-fun <T> Flow<T>.throttleLatest(delayMillis: Long): Flow<T> = this
-    .conflate()
-    .transform {
-        emit(it)
-        delay(delayMillis)
-    }
@@ -1,58 +0,0 @@
-package eu.darken.capod.common.lists
-
-import android.content.Context
-import android.content.res.Resources
-import android.view.LayoutInflater
-import android.view.ViewGroup
-import androidx.annotation.*
-import androidx.core.content.ContextCompat
-import androidx.recyclerview.widget.RecyclerView
-import eu.darken.capod.common.getColorForAttr
-
-abstract class BaseAdapter<T : BaseAdapter.VH> : RecyclerView.Adapter<T>() {
-
-    @CallSuper
-    final override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): T {
-        return onCreateBaseVH(parent, viewType)
-    }
-
-    abstract fun onCreateBaseVH(parent: ViewGroup, viewType: Int): T
-
-    @CallSuper
-    final override fun onBindViewHolder(holder: T, position: Int) {
-        onBindBaseVH(holder, position, mutableListOf())
-    }
-
-    @CallSuper
-    final override fun onBindViewHolder(holder: T, position: Int, payloads: MutableList<Any>) {
-        onBindBaseVH(holder, position, payloads)
-    }
-
-    abstract fun onBindBaseVH(holder: T, position: Int, payloads: MutableList<Any> = mutableListOf())
-
-    abstract class VH(@LayoutRes layoutRes: Int, private val parent: ViewGroup) : RecyclerView.ViewHolder(
-        LayoutInflater.from(parent.context).inflate(layoutRes, parent, false)
-    ) {
-
-        val context: Context
-            get() = parent.context
-
-        val resources: Resources
-            get() = context.resources
-
-        val layoutInflater: LayoutInflater
-            get() = LayoutInflater.from(context)
-
-        fun getColor(@ColorRes colorRes: Int): Int = ContextCompat.getColor(context, colorRes)
-
-        fun getColorForAttr(@AttrRes attrRes: Int): Int = context.getColorForAttr(attrRes)
-
-        fun getString(@StringRes stringRes: Int, vararg args: Any): String = context.getString(stringRes, *args)
-
-        fun getQuantityString(@PluralsRes pluralRes: Int, quantity: Int, vararg args: Any): String =
-            context.resources.getQuantityString(pluralRes, quantity, *args)
-
-        fun getQuantityString(@PluralsRes pluralRes: Int, quantity: Int): String =
-            context.resources.getQuantityString(pluralRes, quantity, quantity)
-    }
-}
@@ -1,26 +0,0 @@
-package eu.darken.capod.common.lists
-
-import androidx.viewbinding.ViewBinding
-
-interface BindableVH<ItemT, ViewBindingT : ViewBinding> {
-
-    val viewBinding: Lazy<ViewBindingT>
-
-    val onBindData: ViewBindingT.(item: ItemT, payloads: List<Any>) -> Unit
-
-    fun bind(item: ItemT, payloads: MutableList<Any> = mutableListOf()) = with(viewBinding.value) {
-        onBindData(item, payloads)
-    }
-}
-
-@Suppress("unused")
-inline fun <reified ItemT, ViewBindingT : ViewBinding> BindableVH<ItemT, ViewBindingT>.binding(
-    payload: Boolean = true,
-    crossinline block: ViewBindingT.(ItemT) -> Unit,
-): ViewBindingT.(item: ItemT, payloads: List<Any>) -> Unit = { item: ItemT, payloads: List<Any> ->
-    val newestItem = when (payload) {
-        true -> payloads.filterIsInstance<ItemT>().lastOrNull() ?: item
-        false -> item
-    }
-    block(newestItem)
-}
@@ -1,13 +0,0 @@
-package eu.darken.capod.common.lists
-
-import androidx.recyclerview.widget.RecyclerView
-
-interface DataAdapter<T> {
-    val data: MutableList<T>
-}
-
-fun <X, T> X.update(newData: List<T>?, notify: Boolean = true) where X : DataAdapter<T>, X : RecyclerView.Adapter<*> {
-    data.clear()
-    if (newData != null) data.addAll(newData)
-    if (notify) notifyDataSetChanged()
-}
@@ -1,3 +0,0 @@
-package eu.darken.capod.common.lists
-
-interface ListItem
@@ -1,13 +0,0 @@
-package eu.darken.capod.common.lists
-
-import androidx.recyclerview.widget.DefaultItemAnimator
-import androidx.recyclerview.widget.DividerItemDecoration
-import androidx.recyclerview.widget.LinearLayoutManager
-import androidx.recyclerview.widget.RecyclerView
-
-fun RecyclerView.setupDefaults(adapter: RecyclerView.Adapter<*>? = null, dividers: Boolean = true) = apply {
-    layoutManager = LinearLayoutManager(context)
-    itemAnimator = DefaultItemAnimator()
-    if (dividers) addItemDecoration(DividerItemDecoration(context, DividerItemDecoration.VERTICAL))
-    if (adapter != null) this.adapter = adapter
-}
@@ -1,43 +0,0 @@
-package eu.darken.capod.common.lists.differ
-
-import androidx.recyclerview.widget.AsyncListDiffer
-import androidx.recyclerview.widget.DiffUtil
-import eu.darken.capod.common.lists.modular.ModularAdapter
-import eu.darken.capod.common.lists.modular.mods.StableIdMod
-
-class AsyncDiffer<A, T : DifferItem> internal constructor(
-    adapter: A,
-    compareItem: (T, T) -> Boolean = { i1, i2 -> i1.stableId == i2.stableId },
-    compareItemContent: (T, T) -> Boolean = { i1, i2 -> i1 == i2 },
-    determinePayload: (T, T) -> Any? = { i1, i2 ->
-        when {
-            i1::class == i2::class -> i1.payloadProvider?.invoke(i1, i2)
-            else -> null
-        }
-    }
-) where A : HasAsyncDiffer<T>, A : ModularAdapter<*> {
-    private val callback = object : DiffUtil.ItemCallback<T>() {
-        override fun areItemsTheSame(oldItem: T, newItem: T): Boolean = compareItem(oldItem, newItem)
-        override fun areContentsTheSame(oldItem: T, newItem: T): Boolean = compareItemContent(oldItem, newItem)
-        override fun getChangePayload(oldItem: T, newItem: T): Any? = determinePayload(oldItem, newItem)
-    }
-
-    private val internalList = mutableListOf<T>()
-    private val listDiffer = AsyncListDiffer(adapter, callback)
-
-    val currentList: List<T>
-        get() = synchronized(internalList) { internalList }
-
-    init {
-        adapter.modules.add(0, StableIdMod(currentList))
-    }
-
-    fun submitUpdate(newData: List<T>) {
-        listDiffer.submitList(newData) {
-            synchronized(internalList) {
-                internalList.clear()
-                internalList.addAll(newData)
-            }
-        }
-    }
-}
@@ -1,15 +0,0 @@
-package eu.darken.capod.common.lists.differ
-
-import androidx.recyclerview.widget.RecyclerView
-import eu.darken.capod.common.lists.modular.ModularAdapter
-
-
-fun <X, T> X.update(newData: List<T>?)
-        where X : HasAsyncDiffer<T>, X : RecyclerView.Adapter<*> {
-
-    asyncDiffer.submitUpdate(newData ?: emptyList())
-}
-
-fun <A, T : DifferItem> A.setupDiffer(): AsyncDiffer<A, T>
-        where A : HasAsyncDiffer<T>, A : ModularAdapter<*> =
-    AsyncDiffer(this)
@@ -1,10 +0,0 @@
-package eu.darken.capod.common.lists.differ
-
-import eu.darken.capod.common.lists.ListItem
-
-interface DifferItem : ListItem {
-    val stableId: Long
-
-    val payloadProvider: ((DifferItem, DifferItem) -> DifferItem?)?
-        get() = null
-}
@@ -1,10 +0,0 @@
-package eu.darken.capod.common.lists.differ
-
-interface HasAsyncDiffer<T : DifferItem> {
-
-    val data: List<T>
-        get() = asyncDiffer.currentList
-
-    val asyncDiffer: AsyncDiffer<*, T>
-
-}
@@ -1,95 +0,0 @@
-package eu.darken.capod.common.lists.modular
-
-import android.view.ViewGroup
-import androidx.annotation.CallSuper
-import androidx.annotation.LayoutRes
-import androidx.recyclerview.widget.RecyclerView
-import eu.darken.capod.common.lists.BaseAdapter
-
-abstract class ModularAdapter<VH : ModularAdapter.VH> : BaseAdapter<VH>() {
-    val modules = mutableListOf<Module>()
-
-    init {
-        modules.filterIsInstance<Module.Setup>().forEach { it.onAdapterReady(this) }
-    }
-
-    override fun getItemId(position: Int): Long {
-        modules.filterIsInstance<Module.ItemId>().forEach {
-            val id = it.getItemId(this, position)
-            if (id != null) return id
-        }
-        return super.getItemId(position)
-    }
-
-    @CallSuper
-    override fun getItemViewType(position: Int): Int {
-        modules.filterIsInstance<Module.Typing>().forEach {
-            val type = it.onGetItemType(this, position)
-            if (type != null) return type
-        }
-        return super.getItemViewType(position)
-    }
-
-    override fun onCreateBaseVH(parent: ViewGroup, viewType: Int): VH {
-        modules.filterIsInstance<Module.Creator<VH>>().forEach {
-            val vh = it.onCreateModularVH(this, parent, viewType)
-            if (vh != null) return vh
-        }
-        throw IllegalStateException("Couldn't create VH for type $viewType with $parent")
-    }
-
-    @CallSuper
-    override fun onBindBaseVH(holder: VH, position: Int, payloads: MutableList<Any>) {
-        modules.filterIsInstance<Module.Binder<VH>>().forEach {
-            it.onBindModularVH(this, holder, position, payloads)
-            it.onPostBind(this, holder, position)
-        }
-    }
-
-    @CallSuper
-    override fun onAttachedToRecyclerView(recyclerView: RecyclerView) {
-        modules.filterIsInstance<Module.RecyclerViewLifecycle>().forEach { it.onAttachedToRecyclerView(recyclerView) }
-        super.onAttachedToRecyclerView(recyclerView)
-    }
-
-    @CallSuper
-    override fun onDetachedFromRecyclerView(recyclerView: RecyclerView) {
-        modules.filterIsInstance<Module.RecyclerViewLifecycle>().forEach { it.onDetachedFromRecyclerView(recyclerView) }
-        super.onDetachedFromRecyclerView(recyclerView)
-    }
-
-    abstract class VH(@LayoutRes layoutRes: Int, parent: ViewGroup) : BaseAdapter.VH(layoutRes, parent)
-
-    interface Module {
-        interface Setup {
-            fun onAdapterReady(adapter: ModularAdapter<*>)
-        }
-
-        interface Creator<T : VH> : Module {
-            fun onCreateModularVH(adapter: ModularAdapter<T>, parent: ViewGroup, viewType: Int): T?
-        }
-
-        interface Binder<T : VH> : Module {
-            fun onBindModularVH(adapter: ModularAdapter<T>, vh: T, pos: Int, payloads: MutableList<Any>) {
-                // NOOP
-            }
-
-            fun onPostBind(adapter: ModularAdapter<T>, vh: T, pos: Int) {
-                // NOOP
-            }
-        }
-
-        interface Typing : Module {
-            fun onGetItemType(adapter: ModularAdapter<*>, pos: Int): Int?
-        }
-
-        interface ItemId : Module {
-            fun getItemId(adapter: ModularAdapter<*>, position: Int): Long?
-        }
-
-        interface RecyclerViewLifecycle : Module {
-            fun onDetachedFromRecyclerView(recyclerView: RecyclerView)
-            fun onAttachedToRecyclerView(recyclerView: RecyclerView)
-        }
-    }
-}
@@ -1,12 +0,0 @@
-package eu.darken.capod.common.lists.modular.mods
-
-import eu.darken.capod.common.lists.modular.ModularAdapter
-
-class ClickMod<VHT : ModularAdapter.VH> constructor(
-    private val listener: (VHT, Int) -> Unit
-) : ModularAdapter.Module.Binder<VHT> {
-
-    override fun onBindModularVH(adapter: ModularAdapter<VHT>, vh: VHT, pos: Int, payloads: MutableList<Any>) {
-        vh.itemView.setOnClickListener { listener.invoke(vh, pos) }
-    }
-}
@@ -1,17 +0,0 @@
-package eu.darken.capod.common.lists.modular.mods
-
-import androidx.viewbinding.ViewBinding
-import eu.darken.capod.common.lists.BindableVH
-import eu.darken.capod.common.lists.modular.ModularAdapter
-
-class DataBinderMod<ItemT, HolderT> constructor(
-    private val data: List<ItemT>,
-    private val customBinder: (
-        (adapter: ModularAdapter<HolderT>, vh: HolderT, pos: Int, payload: MutableList<Any>) -> Unit
-    )? = null
-) : ModularAdapter.Module.Binder<HolderT> where HolderT : BindableVH<ItemT, ViewBinding>, HolderT : ModularAdapter.VH {
-
-    override fun onBindModularVH(adapter: ModularAdapter<HolderT>, vh: HolderT, pos: Int, payloads: MutableList<Any>) {
-        customBinder?.invoke(adapter, vh, pos, mutableListOf()) ?: vh.bind(data[pos], payloads)
-    }
-}
@@ -1,15 +0,0 @@
-package eu.darken.capod.common.lists.modular.mods
-
-import android.view.ViewGroup
-import eu.darken.capod.common.lists.modular.ModularAdapter
-
-class SimpleVHCreatorMod<HolderT> constructor(
-    private val viewType: Int = 0,
-    private val factory: (ViewGroup) -> HolderT
-) : ModularAdapter.Module.Creator<HolderT> where HolderT : ModularAdapter.VH {
-
-    override fun onCreateModularVH(adapter: ModularAdapter<HolderT>, parent: ViewGroup, viewType: Int): HolderT? {
-        if (this.viewType != viewType) return null
-        return factory.invoke(parent)
-    }
-}
@@ -1,21 +0,0 @@
-package eu.darken.capod.common.lists.modular.mods
-
-import androidx.recyclerview.widget.RecyclerView
-import eu.darken.capod.common.lists.differ.DifferItem
-import eu.darken.capod.common.lists.modular.ModularAdapter
-
-class StableIdMod<ItemT : DifferItem> constructor(
-    private val data: List<ItemT>,
-    private val customResolver: (position: Int) -> Long = {
-        (data[it] as? DifferItem)?.stableId ?: RecyclerView.NO_ID
-    }
-) : ModularAdapter.Module.ItemId, ModularAdapter.Module.Setup {
-
-    override fun onAdapterReady(adapter: ModularAdapter<*>) {
-        adapter.setHasStableIds(true)
-    }
-
-    override fun getItemId(adapter: ModularAdapter<*>, position: Int): Long? {
-        return customResolver.invoke(position)
-    }
-}
@@ -1,29 +0,0 @@
-package eu.darken.capod.common.lists.modular.mods
-
-import android.view.ViewGroup
-import eu.darken.capod.common.lists.modular.ModularAdapter
-
-class TypedVHCreatorMod<HolderT> constructor(
-    private val typeResolver: (Int) -> Boolean,
-    private val factory: (ViewGroup) -> HolderT
-) : ModularAdapter.Module.Typing,
-    ModularAdapter.Module.Creator<HolderT> where HolderT : ModularAdapter.VH {
-
-    private fun ModularAdapter<*>.determineOurViewType(): Int {
-        val typingModules = modules.filterIsInstance(ModularAdapter.Module.Typing::class.java)
-        return typingModules.indexOf(this@TypedVHCreatorMod)
-    }
-
-    override fun onGetItemType(adapter: ModularAdapter<*>, pos: Int): Int? {
-        return if (typeResolver.invoke(pos)) adapter.determineOurViewType() else null
-    }
-
-    override fun onCreateModularVH(
-        adapter: ModularAdapter<HolderT>,
-        parent: ViewGroup,
-        viewType: Int
-    ): HolderT? {
-        if (adapter.determineOurViewType() != viewType) return null
-        return factory.invoke(parent)
-    }
-}
@@ -1,76 +0,0 @@
-package eu.darken.capod.common.livedata
-
-/*
- *  Copyright 2017 Google Inc.
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- *
- */
-
-import androidx.annotation.MainThread
-import androidx.annotation.Nullable
-import androidx.lifecycle.LifecycleOwner
-import androidx.lifecycle.MutableLiveData
-import androidx.lifecycle.Observer
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import java.util.concurrent.atomic.AtomicBoolean
-
-/**
- * A lifecycle-aware observable that sends only new updates after subscription, used for events like
- * navigation and Snackbar messages.
- *
- *
- * This avoids a common problem with events: on configuration change (like rotation) an update
- * can be emitted if the observer is active. This LiveData only calls the observable if there's an
- * explicit call to setValue() or call().
- *
- *
- * Note that only one observer is going to be notified of changes.
- * https://github.com/android/architecture-samples/blob/166ca3a93ad14c6e224a3ea9bfcbd773eb048fb0/todoapp/app/src/main/java/com/example/android/architecture/blueprints/todoapp/SingleLiveEvent.java
- */
-class SingleLiveEvent<T> : MutableLiveData<T>() {
-
-    private val pending = AtomicBoolean(false)
-
-    @MainThread
-    override fun observe(owner: LifecycleOwner, observer: Observer<in T>) {
-        if (hasActiveObservers()) {
-            log(WARN) { "Multiple observers registered but only one will be notified of changes." }
-        }
-
-        // Observe the internal MutableLiveData
-        super.observe(
-            owner,
-            { t ->
-                if (pending.compareAndSet(true, false)) {
-                    observer.onChanged(t)
-                }
-            }
-        )
-    }
-
-    @MainThread
-    override fun setValue(@Nullable t: T?) {
-        pending.set(true)
-        super.setValue(t)
-    }
-
-    /**
-     * Used for cases where T is Void, to make calls cleaner.
-     */
-    @MainThread
-    fun call() {
-        value = null
-    }
-}
@@ -1,38 +0,0 @@
-package eu.darken.capod.common.navigation
-
-import android.app.Activity
-import androidx.annotation.IdRes
-import androidx.fragment.app.Fragment
-import androidx.fragment.app.FragmentContainerView
-import androidx.fragment.app.FragmentManager
-import androidx.navigation.NavController
-import androidx.navigation.NavDirections
-import androidx.navigation.fragment.NavHostFragment
-import androidx.navigation.fragment.findNavController
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-
-fun Fragment.doNavigate(direction: NavDirections) = findNavController().doNavigate(direction)
-
-fun Fragment.popBackStack(): Boolean {
-    if (!isAdded) {
-        IllegalStateException("Fragment is not added").also {
-            log(WARN) { "Trying to pop backstack on Fragment that isn't added to an Activity: ${it.asLog()}" }
-        }
-        return false
-    }
-    return findNavController().popBackStack()
-}
-
-/**
- * [FragmentContainerView] does not access [NavController] in [Activity.onCreate]
- * as workaround [FragmentManager] is used to get the [NavController]
- * @param id [Int] NavFragment id
- * @see <a href="https://issuetracker.google.com/issues/142847973">issue-142847973</a>
- */
-@Throws(IllegalStateException::class)
-fun FragmentManager.findNavController(@IdRes id: Int): NavController {
-    val fragment = findFragmentById(id) ?: throw IllegalStateException("Fragment is not found for id:$id")
-    return NavHostFragment.findNavController(fragment)
-}
@@ -1,20 +0,0 @@
-package eu.darken.capod.common.navigation
-
-import android.os.Bundle
-import android.os.Parcelable
-import androidx.lifecycle.SavedStateHandle
-import androidx.navigation.NavArgs
-import androidx.navigation.NavArgsLazy
-import java.io.Serializable
-
-// TODO Remove with "androidx.navigation:navigation-safe-args-gradle-plugin:2.4.0-alpha/stable"
-inline fun <reified Args : NavArgs> SavedStateHandle.navArgs() = NavArgsLazy(Args::class) {
-    Bundle().apply {
-        keys().forEach {
-            when (val value = get<Any>(it)) {
-                is Serializable -> putSerializable(it, value)
-                is Parcelable -> putParcelable(it, value)
-            }
-        }
-    }
-}
@@ -1,22 +0,0 @@
-package eu.darken.capod.common.navigation
-
-import android.os.Bundle
-import androidx.annotation.IdRes
-import androidx.navigation.NavController
-import androidx.navigation.NavDirections
-
-fun NavController.navigateIfNotThere(@IdRes resId: Int, args: Bundle? = null) {
-    if (currentDestination?.id == resId) return
-    navigate(resId, args)
-}
-
-fun NavController.doNavigate(direction: NavDirections) {
-    currentDestination?.getAction(direction.actionId)?.let { navigate(direction) }
-}
-
-fun NavController.isGraphSet(): Boolean = try {
-    graph
-    true
-} catch (e: IllegalStateException) {
-    false
-}
@@ -1,9 +0,0 @@
-package eu.darken.capod.common.navigation
-
-import androidx.annotation.IdRes
-import androidx.navigation.NavDestination
-
-fun NavDestination?.hasAction(@IdRes id: Int): Boolean {
-    if (this == null) return false
-    return getAction(id) != null
-}
@@ -1,13 +0,0 @@
-package eu.darken.capod.common.navigation
-
-import androidx.lifecycle.MutableLiveData
-import androidx.navigation.NavDirections
-import eu.darken.capod.common.livedata.SingleLiveEvent
-
-fun NavDirections.navVia(pub: MutableLiveData<in NavDirections>) = pub.postValue(this)
-
-fun NavDirections.navVia(provider: NavEventSource) = this.navVia(provider.navEvents)
-
-interface NavEventSource {
-    val navEvents: SingleLiveEvent<in NavDirections>
-}
@@ -1,17 +0,0 @@
-package eu.darken.capod.common.notifications
-
-import android.app.PendingIntent
-import eu.darken.capod.common.hasApiLevel
-
-object PendingIntentCompat {
-    val FLAG_IMMUTABLE: Int = if (hasApiLevel(31)) {
-        PendingIntent.FLAG_IMMUTABLE
-    } else {
-        0
-    }
-    val FLAG_MUTABLE: Int = if (hasApiLevel(31)) {
-        PendingIntent.FLAG_MUTABLE
-    } else {
-        0
-    }
-}
@@ -1,86 +0,0 @@
-package eu.darken.capod.common.permissions
-
-import android.content.Context
-import android.content.pm.PackageManager
-import android.os.Build
-import android.os.PowerManager
-import androidx.annotation.StringRes
-import androidx.core.content.ContextCompat
-import eu.darken.capod.common.BuildConfigWrap
-import eu.darken.capod.common.R
-import eu.darken.capod.common.withinApiLevel
-
-enum class Permission(
-    val minApiLevel: Int,
-    val maxApiLevel: Int = Int.MAX_VALUE,
-    @StringRes val labelRes: Int,
-    @StringRes val descriptionRes: Int,
-    val permissionId: String,
-    val isGranted: (Context) -> Boolean = {
-        ContextCompat.checkSelfPermission(it, permissionId) == PackageManager.PERMISSION_GRANTED
-    },
-) {
-    BLUETOOTH(
-        minApiLevel = Build.VERSION_CODES.BASE,
-        maxApiLevel = Build.VERSION_CODES.R,
-        labelRes = R.string.permission_bluetooth_label,
-        descriptionRes = R.string.permission_bluetooth_description,
-        permissionId = "android.permission.BLUETOOTH",
-    ),
-    BLUETOOTH_CONNECT(
-        minApiLevel = Build.VERSION_CODES.S,
-        labelRes = R.string.permission_bluetooth_connect_label,
-        descriptionRes = R.string.permission_bluetooth_connect_description,
-        permissionId = "android.permission.BLUETOOTH_CONNECT",
-    ),
-    BLUETOOTH_SCAN(
-        minApiLevel = Build.VERSION_CODES.S,
-        labelRes = R.string.permission_bluetooth_scan_label,
-        descriptionRes = R.string.permission_bluetooth_scan_description,
-        permissionId = "android.permission.BLUETOOTH_SCAN",
-    ),
-    ACCESS_FINE_LOCATION(
-        minApiLevel = Build.VERSION_CODES.BASE,
-        maxApiLevel = Build.VERSION_CODES.R,
-        labelRes = R.string.permission_access_fine_location_label,
-        descriptionRes = R.string.permission_access_fine_location_description,
-        permissionId = "android.permission.ACCESS_FINE_LOCATION",
-    ),
-    ACCESS_BACKGROUND_LOCATION(
-        minApiLevel = Build.VERSION_CODES.Q,
-        maxApiLevel = Build.VERSION_CODES.R,
-        labelRes = R.string.permission_background_location_label,
-        descriptionRes = R.string.permission_background_location_description,
-        permissionId = "android.permission.ACCESS_BACKGROUND_LOCATION",
-    ),
-    IGNORE_BATTERY_OPTIMIZATION(
-        minApiLevel = Build.VERSION_CODES.BASE,
-        labelRes = R.string.permission_ignore_battery_optimizations_label,
-        descriptionRes = R.string.permission_ignore_battery_optimizations_description,
-        permissionId = "android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS",
-        isGranted = {
-            val pwm = it.getSystemService(Context.POWER_SERVICE) as PowerManager
-            pwm.isIgnoringBatteryOptimizations(BuildConfigWrap.APPLICATION_ID)
-        },
-    ),
-    SYSTEM_ALERT_WINDOW(
-        minApiLevel = Build.VERSION_CODES.BASE,
-        labelRes = R.string.permission_system_alert_window_label,
-        descriptionRes = R.string.permission_system_alert_window_description,
-        permissionId = "android.permission.SYSTEM_ALERT_WINDOW",
-        isGranted = {
-            android.provider.Settings.canDrawOverlays(it)
-        },
-    ),
-    POST_NOTIFICATIONS(
-        minApiLevel = Build.VERSION_CODES.S,
-        labelRes = R.string.permission_post_notifications_label,
-        descriptionRes = R.string.permission_post_notifications_description,
-        permissionId = "android.permission.POST_NOTIFICATIONS",
-    ),
-}
-
-fun Permission.isRequired(context: Context): Boolean = when {
-    !withinApiLevel(minApiLevel, maxApiLevel) -> false
-    else -> !isGranted(context)
-}
@@ -1,63 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import android.content.SharedPreferences
-import androidx.core.content.edit
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.log
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-
-class FlowPreference<T> constructor(
-    private val preferences: SharedPreferences,
-    val key: String,
-    val rawReader: (Any?) -> T,
-    val rawWriter: (T) -> Any?
-) {
-
-    private val flowInternal = MutableStateFlow(value)
-    val flow: Flow<T> = flowInternal
-
-    private val preferenceChangeListener =
-        SharedPreferences.OnSharedPreferenceChangeListener { changedPrefs, changedKey ->
-            if (changedKey != key) return@OnSharedPreferenceChangeListener
-
-            val newValue = rawReader(changedPrefs.all[key])
-
-            val currentValue = flowInternal.value
-            if (currentValue != newValue && flowInternal.compareAndSet(currentValue, newValue)) {
-                log(VERBOSE) { "$changedPrefs:$changedKey changed to $newValue" }
-            }
-        }
-
-    init {
-        preferences.registerOnSharedPreferenceChangeListener(preferenceChangeListener)
-    }
-
-    var value: T
-        get() = rawReader(valueRaw)
-        set(newVal) {
-            valueRaw = rawWriter(newVal)
-        }
-
-    var valueRaw: Any?
-        get() = preferences.all[key] ?: rawWriter(rawReader(null))
-        set(value) {
-            preferences.edit {
-                when (value) {
-                    is Boolean -> putBoolean(key, value)
-                    is String -> putString(key, value)
-                    is Int -> putInt(key, value)
-                    is Long -> putLong(key, value)
-                    is Float -> putFloat(key, value)
-                    null -> remove(key)
-                    else -> throw NotImplementedError()
-                }
-
-            }
-            flowInternal.value = rawReader(value)
-        }
-
-    fun update(update: (T) -> T) {
-        value = update(value)
-    }
-}
@@ -1,43 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import android.content.SharedPreferences
-
-
-inline fun <reified T> basicReader(defaultValue: T): (rawValue: Any?) -> T =
-    { rawValue ->
-        (rawValue ?: defaultValue) as T
-    }
-
-inline fun <reified T> basicWriter(): (T) -> Any? =
-    { value ->
-        when (value) {
-            is Boolean -> value
-            is String -> value
-            is Int -> value
-            is Long -> value
-            is Float -> value
-            null -> null
-            else -> throw NotImplementedError()
-        }
-    }
-
-inline fun <reified T : Any?> SharedPreferences.createFlowPreference(
-    key: String,
-    defaultValue: T = null as T
-) = FlowPreference(
-    preferences = this,
-    key = key,
-    rawReader = basicReader(defaultValue),
-    rawWriter = basicWriter()
-)
-
-inline fun <reified T : Any?> SharedPreferences.createFlowPreference(
-    key: String,
-    noinline reader: (rawValue: Any?) -> T,
-    noinline writer: (value: T) -> Any?
-) = FlowPreference(
-    preferences = this,
-    key = key,
-    rawReader = reader,
-    rawWriter = writer
-)
@@ -1,35 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import android.content.SharedPreferences
-import com.squareup.moshi.Moshi
-
-inline fun <reified T> moshiReader(
-    moshi: Moshi,
-    defaultValue: T,
-): (Any?) -> T {
-    val adapter = moshi.adapter(T::class.java)
-    return { rawValue ->
-        rawValue as String?
-        rawValue?.let { adapter.fromJson(it) } ?: defaultValue
-    }
-}
-
-inline fun <reified T> moshiWriter(
-    moshi: Moshi,
-): (T) -> Any? {
-    val adapter = moshi.adapter(T::class.java)
-    return { newValue: T ->
-        newValue?.let { adapter.toJson(it) }
-    }
-}
-
-inline fun <reified T : Any?> SharedPreferences.createFlowPreference(
-    key: String,
-    defaultValue: T = null as T,
-    moshi: Moshi,
-) = FlowPreference(
-    preferences = this,
-    key = key,
-    rawReader = moshiReader(moshi, defaultValue),
-    rawWriter = moshiWriter(moshi)
-)
@@ -1,14 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import android.content.Context
-import android.util.AttributeSet
-import androidx.preference.SwitchPreferenceCompat
-
-class MaterialSwitchPreference(context: Context, attrs: AttributeSet?) :
-    SwitchPreferenceCompat(context, attrs) {
-
-    init {
-        // Use material switch
-        widgetLayoutResource = eu.darken.capod.common.R.layout.preference_material_switch
-    }
-}
@@ -1,81 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import androidx.preference.PreferenceDataStore
-
-open class PreferenceStoreMapper(
-    private vararg val flowPreferences: FlowPreference<*>
-) : PreferenceDataStore() {
-
-    override fun getBoolean(key: String, defValue: Boolean): Boolean {
-        return flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw as Boolean
-        } ?: throw NotImplementedError("getBoolean(key=$key, defValue=$defValue)")
-    }
-
-    override fun putBoolean(key: String, value: Boolean) {
-        flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw = value
-        } ?: throw NotImplementedError("putBoolean(key=$key, defValue=$value)")
-    }
-
-    override fun getString(key: String, defValue: String?): String? {
-        val pref = flowPreferences.singleOrNull { it.key == key }
-            ?: throw NotImplementedError("getString(key=$key, defValue=$defValue)")
-
-        return pref.let { flowPref ->
-            flowPref.valueRaw as String?
-        }
-    }
-
-    override fun putString(key: String, value: String?) {
-        val pref = flowPreferences.singleOrNull { it.key == key }
-            ?: throw NotImplementedError("putString(key=$key, defValue=$value)")
-        pref.let { flowPref ->
-            flowPref.valueRaw = value
-        }
-    }
-
-    override fun getInt(key: String?, defValue: Int): Int {
-        return flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw as Int
-        } ?: throw NotImplementedError("getInt(key=$key, defValue=$defValue)")
-    }
-
-    override fun putInt(key: String?, value: Int) {
-        flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw = value
-        } ?: throw NotImplementedError("putInt(key=$key, defValue=$value)")
-    }
-
-    override fun getLong(key: String?, defValue: Long): Long {
-        return flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw as Long
-        } ?: throw NotImplementedError("getLong(key=$key, defValue=$defValue)")
-    }
-
-    override fun putLong(key: String?, value: Long) {
-        flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw = value
-        } ?: throw NotImplementedError("putLong(key=$key, defValue=$value)")
-    }
-
-    override fun getFloat(key: String?, defValue: Float): Float {
-        return flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw as Float
-        } ?: throw NotImplementedError("getFloat(key=$key, defValue=$defValue)")
-    }
-
-    override fun putFloat(key: String?, value: Float) {
-        flowPreferences.singleOrNull { it.key == key }?.let { flowPref ->
-            flowPref.valueRaw = value
-        } ?: throw NotImplementedError("putFloat(key=$key, defValue=$value)")
-    }
-
-    override fun putStringSet(key: String?, values: MutableSet<String>?) {
-        throw NotImplementedError("putStringSet(key=$key, defValue=$values)")
-    }
-
-    override fun getStringSet(key: String?, defValues: MutableSet<String>?): MutableSet<String> {
-        throw NotImplementedError("getStringSet(key=$key, defValue=$defValues)")
-    }
-}
@@ -1,12 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import android.content.SharedPreferences
-import androidx.preference.PreferenceDataStore
-
-abstract class Settings {
-
-    abstract val preferenceDataStore: PreferenceDataStore
-
-    abstract val preferences: SharedPreferences
-
-}
@@ -1,16 +0,0 @@
-package eu.darken.capod.common.preferences
-
-import android.content.SharedPreferences
-import androidx.core.content.edit
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.log
-
-fun SharedPreferences.clearAndNotify() {
-    val currentKeys = this.all.keys.toSet()
-    log(VERBOSE) { "$this clearAndNotify(): $currentKeys" }
-    edit {
-        currentKeys.forEach { remove(it) }
-    }
-    // Clear does not notify anyone using registerOnSharedPreferenceChangeListener
-    edit(commit = true) { clear() }
-}
@@ -1,16 +0,0 @@
-package eu.darken.capod.common.serialization
-
-import com.squareup.moshi.FromJson
-import com.squareup.moshi.ToJson
-import kotlin.io.encoding.Base64
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Suppress("unused")
-@OptIn(ExperimentalEncodingApi::class)
-class ByteArrayAdapter {
-    @ToJson
-    fun toJson(obj: ByteArray): String = Base64.encode(obj)
-
-    @FromJson
-    fun fromJson(base64: String): ByteArray? = Base64.decode(base64)
-}
@@ -1,13 +0,0 @@
-package eu.darken.capod.common.serialization
-
-import com.squareup.moshi.FromJson
-import com.squareup.moshi.ToJson
-import java.time.Instant
-
-class JavaInstantAdapter {
-    @ToJson
-    fun toJson(obj: Instant): Long = obj.toEpochMilli()
-
-    @FromJson
-    fun fromJson(epochMillis: Long): Instant = Instant.ofEpochMilli(epochMillis)
-}
@@ -1,21 +0,0 @@
-package eu.darken.capod.common.serialization
-
-import com.squareup.moshi.Moshi
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import javax.inject.Singleton
-
-@InstallIn(SingletonComponent::class)
-@Module
-class SerializationModule {
-
-    @Provides
-    @Singleton
-    fun moshi(): Moshi = Moshi.Builder()
-        .add(JavaInstantAdapter())
-        .add(ByteArrayAdapter())
-        .build()
-
-}
@@ -1,44 +0,0 @@
-package eu.darken.capod.common.uix
-
-import android.content.Intent
-import android.os.Bundle
-import androidx.appcompat.app.AppCompatActivity
-import androidx.lifecycle.LiveData
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-
-abstract class Activity2 : AppCompatActivity() {
-    internal val tag: String =
-        logTag("Activity", this.javaClass.simpleName + "(" + Integer.toHexString(hashCode()) + ")")
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        log(tag, VERBOSE) { "onCreate(savedInstanceState=$savedInstanceState)" }
-        super.onCreate(savedInstanceState)
-    }
-
-    override fun onResume() {
-        log(tag, VERBOSE) { "onResume()" }
-        super.onResume()
-    }
-
-    override fun onPause() {
-        log(tag, VERBOSE) { "onPause()" }
-        super.onPause()
-    }
-
-    override fun onDestroy() {
-        log(tag, VERBOSE) { "onDestroy()" }
-        super.onDestroy()
-    }
-
-    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        log(tag, VERBOSE) { "onActivityResult(requestCode=$requestCode, resultCode=$resultCode, data=$data)" }
-        super.onActivityResult(requestCode, resultCode, data)
-    }
-
-    fun <T> LiveData<T>.observe2(callback: (T) -> Unit) {
-        observe(this@Activity2) { callback.invoke(it) }
-    }
-
-}
@@ -1,80 +0,0 @@
-package eu.darken.capod.common.uix
-
-import android.content.Context
-import android.content.Intent
-import android.os.Bundle
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import androidx.annotation.LayoutRes
-import androidx.fragment.app.Fragment
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-
-
-abstract class Fragment2(@LayoutRes val layoutRes: Int?) : Fragment(layoutRes ?: 0) {
-
-    constructor() : this(null)
-
-    internal val tag: String =
-        logTag("Fragment", "${this.javaClass.simpleName}(${Integer.toHexString(hashCode())})")
-
-    override fun onAttach(context: Context) {
-        log(tag, VERBOSE) { "onAttach(context=$context)" }
-        super.onAttach(context)
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        log(tag, VERBOSE) { "onCreate(savedInstanceState=$savedInstanceState)" }
-        super.onCreate(savedInstanceState)
-    }
-
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
-        log(tag, VERBOSE) {
-            "onCreateView(inflater=$inflater, container=$container, savedInstanceState=$savedInstanceState"
-        }
-        return layoutRes?.let { inflater.inflate(it, container, false) }
-    }
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        log(tag, VERBOSE) { "onViewCreated(view=$view, savedInstanceState=$savedInstanceState)" }
-        super.onViewCreated(view, savedInstanceState)
-    }
-
-    override fun onActivityCreated(savedInstanceState: Bundle?) {
-        log(tag, VERBOSE) { "onActivityCreated(savedInstanceState=$savedInstanceState)" }
-        super.onActivityCreated(savedInstanceState)
-    }
-
-    override fun onResume() {
-        log(tag, VERBOSE) { "onResume()" }
-        super.onResume()
-    }
-
-    override fun onPause() {
-        log(tag, VERBOSE) { "onPause()" }
-        super.onPause()
-    }
-
-    override fun onDestroyView() {
-        log(tag, VERBOSE) { "onDestroyView()" }
-        super.onDestroyView()
-    }
-
-    override fun onDetach() {
-        log(tag, VERBOSE) { "onDetach()" }
-        super.onDetach()
-    }
-
-    override fun onDestroy() {
-        log(tag, VERBOSE) { "onDestroy()" }
-        super.onDestroy()
-    }
-
-    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
-        log(tag, VERBOSE) { "onActivityResult(requestCode=$requestCode, resultCode=$resultCode, data=$data)" }
-        super.onActivityResult(requestCode, resultCode, data)
-    }
-
-}
@@ -1,53 +0,0 @@
-package eu.darken.capod.common.uix
-
-import android.os.Bundle
-import android.view.View
-import androidx.annotation.LayoutRes
-import androidx.lifecycle.LiveData
-import androidx.viewbinding.ViewBinding
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.error.asErrorDialogBuilder
-import eu.darken.capod.common.navigation.doNavigate
-import eu.darken.capod.common.navigation.popBackStack
-
-
-abstract class Fragment3(@LayoutRes layoutRes: Int?) : Fragment2(layoutRes) {
-
-    constructor() : this(null)
-
-    abstract val ui: ViewBinding?
-    abstract val vm: ViewModel3
-
-    var onErrorEvent: ((Throwable) -> Boolean)? = null
-
-    var onFinishEvent: (() -> Unit)? = null
-
-    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
-        super.onViewCreated(view, savedInstanceState)
-
-        vm.navEvents.observe2(ui) {
-            log { "navEvents: $it" }
-
-            it?.run { doNavigate(this) } ?: onFinishEvent?.invoke() ?: popBackStack()
-        }
-
-        vm.errorEvents.observe2(ui) {
-            val showDialog = onErrorEvent?.invoke(it) ?: true
-            if (showDialog) it.asErrorDialogBuilder(requireContext()).show()
-        }
-    }
-
-    inline fun <T> LiveData<T>.observe2(
-        crossinline callback: (T) -> Unit
-    ) {
-        observe(viewLifecycleOwner) { callback.invoke(it) }
-    }
-
-    inline fun <T, reified VB : ViewBinding?> LiveData<T>.observe2(
-        ui: VB,
-        crossinline callback: VB.(T) -> Unit
-    ) {
-        observe(viewLifecycleOwner) { callback.invoke(ui, it) }
-    }
-
-}
@@ -1,20 +0,0 @@
-package eu.darken.capod.common.uix
-
-import androidx.annotation.CallSuper
-import androidx.lifecycle.ViewModel
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.debug.logging.logTag
-
-abstract class ViewModel1 : ViewModel() {
-    val TAG: String = logTag("VM", javaClass.simpleName)
-
-    init {
-        log(TAG) { "Initialized" }
-    }
-
-    @CallSuper
-    override fun onCleared() {
-        log(TAG) { "onCleared()" }
-        super.onCleared()
-    }
-}
@@ -1,63 +0,0 @@
-package eu.darken.capod.common.uix
-
-import androidx.lifecycle.asLiveData
-import androidx.lifecycle.viewModelScope
-import eu.darken.capod.common.coroutine.DefaultDispatcherProvider
-import eu.darken.capod.common.coroutine.DispatcherProvider
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.error.ErrorEventSource
-import eu.darken.capod.common.flow.DynamicStateFlow
-import kotlinx.coroutines.*
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.launchIn
-import kotlin.coroutines.CoroutineContext
-
-
-abstract class ViewModel2(
-    private val dispatcherProvider: DispatcherProvider = DefaultDispatcherProvider(),
-) : ViewModel1() {
-
-    val vmScope = viewModelScope + dispatcherProvider.Default
-
-    var launchErrorHandler: CoroutineExceptionHandler? = null
-
-    private fun getVDCContext(): CoroutineContext {
-        val dispatcher = dispatcherProvider.Default
-        return getErrorHandler()?.let { dispatcher + it } ?: dispatcher
-    }
-
-    private fun getErrorHandler(): CoroutineExceptionHandler? {
-        val handler = launchErrorHandler
-        if (handler != null) return handler
-
-        if (this is ErrorEventSource) {
-            return CoroutineExceptionHandler { _, ex ->
-                log(WARN) { "Error during launch: ${ex.asLog()}" }
-                errorEvents.postValue(ex)
-            }
-        }
-
-        return null
-    }
-
-    fun <T : Any> DynamicStateFlow<T>.asLiveData2() = flow.asLiveData2()
-
-    fun <T> Flow<T>.asLiveData2() = this.asLiveData(context = getVDCContext())
-
-    fun launch(
-        scope: CoroutineScope = viewModelScope,
-        context: CoroutineContext = getVDCContext(),
-        block: suspend CoroutineScope.() -> Unit
-    ) {
-        try {
-            scope.launch(context = context, block = block)
-        } catch (e: CancellationException) {
-            log(TAG, WARN) { "launch()ed coroutine was canceled (scope=$scope): ${e.asLog()}" }
-        }
-    }
-
-    open fun <T> Flow<T>.launchInViewModel() = this.launchIn(vmScope)
-
-}
@@ -1,38 +0,0 @@
-package eu.darken.capod.common.uix
-
-import androidx.navigation.NavDirections
-import eu.darken.capod.common.coroutine.DispatcherProvider
-import eu.darken.capod.common.debug.logging.asLog
-import eu.darken.capod.common.debug.logging.log
-import eu.darken.capod.common.error.ErrorEventSource
-import eu.darken.capod.common.flow.setupCommonEventHandlers
-import eu.darken.capod.common.livedata.SingleLiveEvent
-import eu.darken.capod.common.navigation.NavEventSource
-import eu.darken.capod.common.navigation.navVia
-import kotlinx.coroutines.CoroutineExceptionHandler
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.launchIn
-
-
-abstract class ViewModel3(
-    dispatcherProvider: DispatcherProvider,
-) : ViewModel2(dispatcherProvider), NavEventSource, ErrorEventSource {
-
-    override val navEvents = SingleLiveEvent<NavDirections?>()
-    override val errorEvents = SingleLiveEvent<Throwable>()
-
-    init {
-        launchErrorHandler = CoroutineExceptionHandler { _, ex ->
-            log(TAG) { "Error during launch: ${ex.asLog()}" }
-            errorEvents.postValue(ex)
-        }
-    }
-
-    override fun <T> Flow<T>.launchInViewModel() = this
-        .setupCommonEventHandlers(TAG) { "launchInViewModel()" }
-        .launchIn(vmScope)
-
-    fun NavDirections.navigate() {
-        navVia(navEvents)
-    }
-}
@@ -1,174 +0,0 @@
-package eu.darken.capod.common.uix
-
-/*
- * Copyright 2018 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-import androidx.activity.ComponentActivity
-import androidx.annotation.MainThread
-import androidx.fragment.app.Fragment
-import androidx.lifecycle.*
-import kotlin.reflect.KClass
-
-/**
- * Returns an existing ViewModel or creates a new one in the scope (usually, a fragment or
- * an activity), associated with this `ViewModelProvider`.
- *
- * @see ViewModelProvider.get(Class)
- */
-//@MainThread
-//inline fun <reified VM : ViewModel> ViewModelProvider.get() = get(VM::class.java)
-
-/**
- * An implementation of [Lazy] used by [androidx.fragment.app.Fragment.viewModels] and
- * [androidx.activity.ComponentActivity.viewmodels].
- *
- * [storeProducer] is a lambda that will be called during initialization, [VM] will be created
- * in the scope of returned [ViewModelStore].
- *
- * [factoryProducer] is a lambda that will be called during initialization,
- * returned [ViewModelProvider.Factory] will be used for creation of [VM]
- */
-class ViewModelLazyKeyed<VM : ViewModel>(
-    private val viewModelClass: KClass<VM>,
-    private val keyProducer: (() -> String)? = null,
-    private val storeProducer: () -> ViewModelStore,
-    private val factoryProducer: () -> ViewModelProvider.Factory
-) : Lazy<VM> {
-    private var cached: VM? = null
-
-    override val value: VM
-        get() {
-            val viewModel = cached
-            return if (viewModel == null) {
-                val factory = factoryProducer()
-                val store = storeProducer()
-                val key = keyProducer?.invoke() ?: "androidx.lifecycle.ViewModelProvider.DefaultKey"
-                ViewModelProvider(store, factory).get(
-                    key + ":" + viewModelClass.java.canonicalName,
-                    viewModelClass.java
-                ).also {
-                    cached = it
-                }
-            } else {
-                viewModel
-            }
-        }
-
-    override fun isInitialized() = cached != null
-}
-
-/**
- * Returns a property delegate to access [ViewModel] by **default** scoped to this [Fragment]:
- * ```
- * class MyFragment : Fragment() {
- *     val viewmodel: NYViewModel by viewmodels()
- * }
- * ```
- *
- * Custom [ViewModelProvider.Factory] can be defined via [factoryProducer] parameter,
- * factory returned by it will be used to create [ViewModel]:
- * ```
- * class MyFragment : Fragment() {
- *     val viewmodel: MYViewModel by viewmodels { myFactory }
- * }
- * ```
- *
- * Default scope may be overridden with parameter [ownerProducer]:
- * ```
- * class MyFragment : Fragment() {
- *     val viewmodel: MYViewModel by viewmodels ({requireParentFragment()})
- * }
- * ```
- *
- * This property can be accessed only after this Fragment is attached i.e., after
- * [Fragment.onAttach()], and access prior to that will result in IllegalArgumentException.
- */
-@MainThread
-inline fun <reified VM : ViewModel> Fragment.viewModelsKeyed(
-    noinline keyProducer: (() -> String)? = null,
-    noinline ownerProducer: () -> ViewModelStoreOwner = { this },
-    noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
-) = createViewModelLazyKeyed(VM::class, keyProducer, { ownerProducer().viewModelStore }, factoryProducer)
-
-/**
- * Returns a property delegate to access parent activity's [ViewModel],
- * if [factoryProducer] is specified then [ViewModelProvider.Factory]
- * returned by it will be used to create [ViewModel] first time.
- *
- * ```
- * class MyFragment : Fragment() {
- *     val viewmodel: MyViewModel by activityViewModels()
- * }
- * ```
- *
- * This property can be accessed only after this Fragment is attached i.e., after
- * [Fragment.onAttach()], and access prior to that will result in IllegalArgumentException.
- */
-@MainThread
-inline fun <reified VM : ViewModel> Fragment.activityViewModelsKeyed(
-    noinline keyProducer: (() -> String)? = null,
-    noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
-) = createViewModelLazyKeyed(VM::class, keyProducer, { requireActivity().viewModelStore }, factoryProducer)
-
-/**
- * Helper method for creation of [ViewModelLazy], that resolves `null` passed as [factoryProducer]
- * to default factory.
- */
-@MainThread
-fun <VM : ViewModel> Fragment.createViewModelLazyKeyed(
-    viewModelClass: KClass<VM>,
-    keyProducer: (() -> String)? = null,
-    storeProducer: () -> ViewModelStore,
-    factoryProducer: (() -> ViewModelProvider.Factory)? = null
-): Lazy<VM> {
-    val factoryPromise = factoryProducer ?: {
-        val application = activity?.application ?: throw IllegalStateException(
-            "ViewModel can be accessed only when Fragment is attached"
-        )
-        ViewModelProvider.AndroidViewModelFactory.getInstance(application)
-    }
-    return ViewModelLazyKeyed(viewModelClass, keyProducer, storeProducer, factoryPromise)
-}
-
-/**
- * Returns a [Lazy] delegate to access the ComponentActivity's ViewModel, if [factoryProducer]
- * is specified then [ViewModelProvider.Factory] returned by it will be used
- * to create [ViewModel] first time.
- *
- * ```
- * class MyComponentActivity : ComponentActivity() {
- *     val viewmodel: MyViewModel by viewmodels()
- * }
- * ```
- *
- * This property can be accessed only after the Activity is attached to the Application,
- * and access prior to that will result in IllegalArgumentException.
- */
-@MainThread
-inline fun <reified VM : ViewModel> ComponentActivity.viewModelsKeyed(
-    noinline keyProducer: (() -> String)? = null,
-    noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
-): Lazy<VM> {
-    val factoryPromise = factoryProducer ?: {
-        val application = application ?: throw IllegalArgumentException(
-            "ViewModel can be accessed only when Activity is attached"
-        )
-        ViewModelProvider.AndroidViewModelFactory.getInstance(application)
-    }
-
-    return ViewModelLazyKeyed(VM::class, keyProducer, { viewModelStore }, factoryPromise)
-}
@@ -1,28 +0,0 @@
-package eu.darken.capod.common.upgrade
-
-import android.app.Activity
-import kotlinx.coroutines.flow.Flow
-import java.time.Instant
-
-interface UpgradeRepo {
-    val upgradeInfo: Flow<Info>
-
-    fun launchBillingFlow(activity: Activity)
-
-    fun getSponsorUrl(): String? = null
-
-    interface Info {
-        val type: Type
-
-        val isPro: Boolean
-
-        val upgradedAt: Instant?
-
-        val error: Throwable?
-    }
-
-    enum class Type {
-        GPLAY,
-        FOSS
-    }
-}
@@ -1,6 +0,0 @@
-package eu.darken.capod.common.upgrade
-
-import kotlinx.coroutines.flow.first
-
-
-suspend fun UpgradeRepo.isPro(): Boolean = upgradeInfo.first().isPro
@@ -1,94 +0,0 @@
-package eu.darken.capod.common.viewbinding
-
-import android.os.Handler
-import android.os.Looper
-import android.view.View
-import androidx.annotation.MainThread
-import androidx.fragment.app.Fragment
-import androidx.lifecycle.DefaultLifecycleObserver
-import androidx.lifecycle.LifecycleOwner
-import androidx.viewbinding.ViewBinding
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
-import eu.darken.capod.common.debug.logging.log
-import kotlin.properties.ReadOnlyProperty
-import kotlin.reflect.KProperty
-
-inline fun <FragmentT : Fragment, reified BindingT : ViewBinding> FragmentT.viewBinding() =
-    this.viewBinding(
-        bindingProvider = {
-            val bindingMethod = BindingT::class.java.getMethod("bind", View::class.java)
-            bindingMethod(null, requireView()) as BindingT
-        },
-        lifecycleOwnerProvider = { viewLifecycleOwner }
-    )
-
-@Suppress("unused")
-fun <FragmentT : Fragment, BindingT : ViewBinding> FragmentT.viewBinding(
-    bindingProvider: FragmentT.() -> BindingT,
-    lifecycleOwnerProvider: FragmentT.() -> LifecycleOwner
-) = ViewBindingProperty(bindingProvider, lifecycleOwnerProvider)
-
-class ViewBindingProperty<ComponentT : LifecycleOwner, BindingT : ViewBinding>(
-    private val bindingProvider: (ComponentT) -> BindingT,
-    private val lifecycleOwnerProvider: ComponentT.() -> LifecycleOwner
-) : ReadOnlyProperty<ComponentT, BindingT> {
-
-    private val uiHandler = Handler(Looper.getMainLooper())
-    private var localRef: ComponentT? = null
-    private var viewBinding: BindingT? = null
-
-    private val onDestroyObserver = object : DefaultLifecycleObserver {
-        // Called right before Fragment.onDestroyView
-        override fun onDestroy(owner: LifecycleOwner) {
-            localRef?.lifecycle?.removeObserver(this) ?: return
-
-            localRef = null
-
-            uiHandler.post {
-                log(VERBOSE) { "Resetting viewBinding" }
-                viewBinding = null
-            }
-        }
-    }
-
-    @MainThread
-    override fun getValue(thisRef: ComponentT, property: KProperty<*>): BindingT {
-        if (localRef == null && viewBinding != null) {
-            log(WARN) { "Fragment.onDestroyView() was called, but the handler didn't execute our delayed reset." }
-            /**
-             * There is a fragment racecondition if you navigate to another fragment and quickly popBackStack().
-             * Our uiHandler.post { } will not have executed for some reason.
-             * In that case we manually null the old viewBinding, to allow for clean recreation.
-             */
-            viewBinding = null
-        }
-
-        /**
-         * When quickly navigating, a fragment may be created that was never visible to the user.
-         * It's possible that [Fragment.onDestroyView] is called, but [DefaultLifecycleObserver.onDestroy] is not.
-         * This means the ViewBinding will is not be set to `null` and it still holds the previous layout,
-         * instead of the new layout that the Fragment inflated when navigating back to it.
-         */
-        (localRef as? Fragment)?.view?.let {
-            if (it != viewBinding?.root && localRef === thisRef) {
-                log(WARN) { "Different view for the same fragment, resetting old viewBinding." }
-                viewBinding = null
-            }
-        }
-
-        viewBinding?.let {
-            // Only accessible from within the same component
-            require(localRef === thisRef)
-            return@getValue it
-        }
-
-        val lifecycle = lifecycleOwnerProvider(thisRef).lifecycle
-
-        return bindingProvider(thisRef).also {
-            viewBinding = it
-            localRef = thisRef
-            lifecycle.addObserver(onDestroyObserver)
-        }
-    }
-}
@@ -1,23 +0,0 @@
-package eu.darken.capod.devices.core
-
-import android.os.Parcelable
-import com.squareup.moshi.JsonClass
-import eu.darken.capod.common.bluetooth.BluetoothAddress
-import eu.darken.capod.pods.core.PodDevice
-import eu.darken.capod.pods.core.apple.protocol.IdentityResolvingKey
-import eu.darken.capod.pods.core.apple.protocol.ProximityEncryptionKey
-import kotlinx.parcelize.Parcelize
-import java.util.UUID
-
-@Parcelize
-@JsonClass(generateAdapter = true)
-data class DeviceProfile(
-    val id: String = UUID.randomUUID().toString(),
-    val name: String,
-    val address: BluetoothAddress? = null,
-    val model: PodDevice.Model = PodDevice.Model.UNKNOWN,
-    val identityKey: IdentityResolvingKey? = null,
-    val encryptionKey: ProximityEncryptionKey? = null,
-    val minimumSignalQuality: Float = 0.20f,
-    val isEnabled: Boolean = true
-) : Parcelable
@@ -1,87 +0,0 @@
-package eu.darken.capod.devices.core
-
-import android.content.Context
-import android.content.SharedPreferences
-import com.squareup.moshi.Moshi
-import com.squareup.moshi.Types
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
-import eu.darken.capod.common.debug.logging.log
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class DeviceProfilesRepo @Inject constructor(
-    @ApplicationContext private val context: Context,
-    private val moshi: Moshi,
-) {
-
-    private val preferences: SharedPreferences = context.getSharedPreferences("device_profiles", Context.MODE_PRIVATE)
-
-    private val _profiles = MutableStateFlow<List<DeviceProfile>>(emptyList())
-    val profiles: Flow<List<DeviceProfile>> = _profiles.asStateFlow()
-
-    private val listType = Types.newParameterizedType(List::class.java, DeviceProfile::class.java)
-    private val adapter = moshi.adapter<List<DeviceProfile>>(listType)
-
-    init {
-        loadProfiles()
-    }
-
-    private fun loadProfiles() {
-        val json = preferences.getString(KEY_PROFILES, null)
-        val loadedProfiles = if (json != null) {
-            try {
-                adapter.fromJson(json) ?: emptyList()
-            } catch (e: Exception) {
-                log(VERBOSE) { "Failed to load device profiles: $e" }
-                emptyList()
-            }
-        } else {
-            emptyList()
-        }
-        _profiles.value = loadedProfiles
-        log(VERBOSE) { "Loaded ${loadedProfiles.size} device profiles" }
-    }
-
-    private fun saveProfiles() {
-        val json = adapter.toJson(_profiles.value)
-        preferences.edit().putString(KEY_PROFILES, json).apply()
-        log(VERBOSE) { "Saved ${_profiles.value.size} device profiles" }
-    }
-
-    fun addProfile(profile: DeviceProfile) {
-        val updatedProfiles = _profiles.value.toMutableList()
-        updatedProfiles.add(profile)
-        _profiles.value = updatedProfiles
-        saveProfiles()
-    }
-
-    fun updateProfile(profile: DeviceProfile) {
-        val updatedProfiles = _profiles.value.toMutableList()
-        val index = updatedProfiles.indexOfFirst { it.id == profile.id }
-        if (index != -1) {
-            updatedProfiles[index] = profile
-            _profiles.value = updatedProfiles
-            saveProfiles()
-        }
-    }
-
-    fun removeProfile(profileId: String) {
-        val updatedProfiles = _profiles.value.toMutableList()
-        updatedProfiles.removeAll { it.id == profileId }
-        _profiles.value = updatedProfiles
-        saveProfiles()
-    }
-
-    fun getProfile(profileId: String): DeviceProfile? {
-        return _profiles.value.find { it.id == profileId }
-    }
-
-    companion object {
-        private const val KEY_PROFILES = "profiles"
-    }
-}
@@ -1,74 +0,0 @@
-package eu.darken.capod.main.core
-
-import android.content.Context
-import android.content.SharedPreferences
-import androidx.preference.PreferenceDataStore
-import com.squareup.moshi.Moshi
-import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.common.bluetooth.BluetoothAddress
-import eu.darken.capod.common.bluetooth.ScannerMode
-import eu.darken.capod.common.debug.DebugSettings
-import eu.darken.capod.common.preferences.PreferenceStoreMapper
-import eu.darken.capod.common.preferences.Settings
-import eu.darken.capod.common.preferences.createFlowPreference
-import eu.darken.capod.pods.core.PodDevice
-import eu.darken.capod.pods.core.apple.protocol.IdentityResolvingKey
-import eu.darken.capod.pods.core.apple.protocol.ProximityEncryptionKey
-import javax.inject.Inject
-import javax.inject.Singleton
-
-@Singleton
-class GeneralSettings @Inject constructor(
-    @ApplicationContext private val context: Context,
-    debugSettings: DebugSettings,
-    moshi: Moshi,
-) : Settings() {
-
-    override val preferences: SharedPreferences = context.getSharedPreferences("settings_general", Context.MODE_PRIVATE)
-
-    val monitorMode = preferences.createFlowPreference("core.monitor.mode", MonitorMode.AUTOMATIC, moshi)
-
-    val useExtraMonitorNotification = preferences.createFlowPreference("core.monitor.notification.connected", false)
-
-    val keepConnectedNotificationAfterDisconnect =
-        preferences.createFlowPreference("core.monitor.notification.connected.keepafterdisconnected", false)
-
-    val scannerMode = preferences.createFlowPreference("core.scanner.mode", ScannerMode.BALANCED, moshi)
-
-    val minimumSignalQuality = preferences.createFlowPreference("core.signal.minimum", 0.20f)
-
-    val mainDeviceAddress = preferences.createFlowPreference<BluetoothAddress?>("core.maindevice.address", null)
-    val mainDeviceModel = preferences.createFlowPreference("core.maindevice.model", PodDevice.Model.UNKNOWN, moshi)
-    val mainDeviceIdentityKey = preferences.createFlowPreference<IdentityResolvingKey?>(
-        "core.maindevice.identitykey",
-        null,
-        moshi
-    )
-    val mainDeviceEncryptionKey = preferences.createFlowPreference<ProximityEncryptionKey?>(
-        "core.maindevice.encryptionkey",
-        null,
-        moshi
-    )
-
-    val isOffloadedFilteringDisabled = preferences.createFlowPreference(
-        "core.compat.offloaded.filtering.disabled",
-        false
-    )
-    val isOffloadedBatchingDisabled = preferences.createFlowPreference("core.compat.offloaded.batching.disabled", false)
-    val useIndirectScanResultCallback = preferences.createFlowPreference("core.compat.indirectcallback.enabled", false)
-
-    val isOnboardingDone = preferences.createFlowPreference("core.onboarding.done", false)
-
-    override val preferenceDataStore: PreferenceDataStore = PreferenceStoreMapper(
-        monitorMode,
-        useExtraMonitorNotification,
-        keepConnectedNotificationAfterDisconnect,
-        scannerMode,
-        minimumSignalQuality,
-        mainDeviceAddress,
-        isOffloadedFilteringDisabled,
-        isOffloadedBatchingDisabled,
-        useIndirectScanResultCallback,
-        debugSettings.isAutoReportingEnabled,
-    )
-}
@@ -1,21 +0,0 @@
-package eu.darken.capod.main.core
-
-import androidx.annotation.StringRes
-import com.squareup.moshi.Json
-import com.squareup.moshi.JsonClass
-import eu.darken.capod.common.R
-
-@JsonClass(generateAdapter = false)
-enum class MonitorMode(
-    @StringRes val labelRes: Int
-) {
-    @Json(name = "monitor.mode.manual") MANUAL(
-        R.string.settings_monitor_mode_manual_label
-    ),
-    @Json(name = "monitor.mode.automatic") AUTOMATIC(
-        R.string.settings_monitor_mode_automatic_label
-    ),
-    @Json(name = "monitor.mode.always") ALWAYS(
-        R.string.settings_monitor_mode_always_label
-    ),
-}
--- a/Show More
+++ b/Show More