From f1f5bbc5e0e205a832cf0dd05eae3fd466e1df94 Mon Sep 17 00:00:00 2001 From: jack Date: Sun, 15 Jun 2025 20:08:56 -0500 Subject: [PATCH] Functionality restored, build successful --- README.md | 2 + app/src/main/AndroidManifest.xml | 16 +- .../club/clubk/ktag/konfigurator/AppState.kt | 12 + .../clubk/ktag/konfigurator/BleManager.kt | 322 +++++++++ .../konfigurator/ConfigurationProgress.kt | 7 + .../club/clubk/ktag/konfigurator/Device.kt | 24 + .../clubk/ktag/konfigurator/DeviceState.kt | 8 + .../clubk/ktag/konfigurator/GameConfig.kt | 9 + .../clubk/ktag/konfigurator/KTagPacket.kt | 365 ++++++++++ .../clubk/ktag/konfigurator/MainActivity.kt | 652 +++++++++++++++++- .../konfigurator/MultiDeviceConfigurator.kt | 116 ++++ .../club/clubk/ktag/konfigurator/Player.kt | 10 + .../clubk/ktag/konfigurator/SoundManager.kt | 57 ++ .../konfigurator/StateMachineViewModel.kt | 348 ++++++++++ app/src/main/konfigurator_icon-playstore.png | Bin 0 -> 37575 bytes app/src/main/res/drawable/konfigurator.png | Bin 0 -> 37284 bytes .../mipmap-anydpi-v26/konfigurator_icon.xml | 5 + .../konfigurator_icon_round.xml | 5 + .../res/mipmap-hdpi/konfigurator_icon.webp | Bin 0 -> 1374 bytes .../konfigurator_icon_foreground.webp | Bin 0 -> 2540 bytes .../mipmap-hdpi/konfigurator_icon_round.webp | Bin 0 -> 2446 bytes .../res/mipmap-mdpi/konfigurator_icon.webp | Bin 0 -> 980 bytes .../konfigurator_icon_foreground.webp | Bin 0 -> 1742 bytes .../mipmap-mdpi/konfigurator_icon_round.webp | Bin 0 -> 1610 bytes .../res/mipmap-xhdpi/konfigurator_icon.webp | Bin 0 -> 1902 bytes .../konfigurator_icon_foreground.webp | Bin 0 -> 3654 bytes .../mipmap-xhdpi/konfigurator_icon_round.webp | Bin 0 -> 3366 bytes .../res/mipmap-xxhdpi/konfigurator_icon.webp | Bin 0 -> 2976 bytes .../konfigurator_icon_foreground.webp | Bin 0 -> 5380 bytes .../konfigurator_icon_round.webp | Bin 0 -> 5362 bytes .../res/mipmap-xxxhdpi/konfigurator_icon.webp | Bin 0 -> 4544 bytes .../konfigurator_icon_foreground.webp | Bin 0 -> 7804 bytes .../konfigurator_icon_round.webp | Bin 0 -> 8102 bytes app/src/main/res/raw/double_chirp.wav | Bin 0 -> 17684 bytes .../values/konfigurator_icon_background.xml | 4 + konfigurator.png | Bin 0 -> 37284 bytes 36 files changed, 1938 insertions(+), 24 deletions(-) create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/AppState.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/BleManager.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/ConfigurationProgress.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/Device.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/DeviceState.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/GameConfig.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/KTagPacket.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/MultiDeviceConfigurator.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/Player.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/SoundManager.kt create mode 100644 app/src/main/java/club/clubk/ktag/konfigurator/StateMachineViewModel.kt create mode 100644 app/src/main/konfigurator_icon-playstore.png create mode 100644 app/src/main/res/drawable/konfigurator.png create mode 100644 app/src/main/res/mipmap-anydpi-v26/konfigurator_icon.xml create mode 100644 app/src/main/res/mipmap-anydpi-v26/konfigurator_icon_round.xml create mode 100644 app/src/main/res/mipmap-hdpi/konfigurator_icon.webp create mode 100644 app/src/main/res/mipmap-hdpi/konfigurator_icon_foreground.webp create mode 100644 app/src/main/res/mipmap-hdpi/konfigurator_icon_round.webp create mode 100644 app/src/main/res/mipmap-mdpi/konfigurator_icon.webp create mode 100644 app/src/main/res/mipmap-mdpi/konfigurator_icon_foreground.webp create mode 100644 app/src/main/res/mipmap-mdpi/konfigurator_icon_round.webp create mode 100644 app/src/main/res/mipmap-xhdpi/konfigurator_icon.webp create mode 100644 app/src/main/res/mipmap-xhdpi/konfigurator_icon_foreground.webp create mode 100644 app/src/main/res/mipmap-xhdpi/konfigurator_icon_round.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/konfigurator_icon.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/konfigurator_icon_foreground.webp create mode 100644 app/src/main/res/mipmap-xxhdpi/konfigurator_icon_round.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/konfigurator_icon.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/konfigurator_icon_foreground.webp create mode 100644 app/src/main/res/mipmap-xxxhdpi/konfigurator_icon_round.webp create mode 100644 app/src/main/res/raw/double_chirp.wav create mode 100644 app/src/main/res/values/konfigurator_icon_background.xml create mode 100644 konfigurator.png diff --git a/README.md b/README.md index 8f71fde..0ab5659 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,7 @@ # Android Konfigurator + + ## Overview This software is used for configuring and initiating KTag games. diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index 61d3699..c33ad3a 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -2,13 +2,25 @@ + + + + + + + + + + diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/AppState.kt b/app/src/main/java/club/clubk/ktag/konfigurator/AppState.kt new file mode 100644 index 0000000..9088331 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/AppState.kt @@ -0,0 +1,12 @@ +package club.clubk.ktag.konfigurator + +sealed class AppState { + object TitleScreen : AppState() + object GameSettings : AppState() + object TeamSettings : AppState() + object PregameTimer : AppState() + object Countdown : AppState() + object GameTimer : AppState() + object GameOver : AppState() + object WrapUp : AppState() +} \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/BleManager.kt b/app/src/main/java/club/clubk/ktag/konfigurator/BleManager.kt new file mode 100644 index 0000000..4a4035e --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/BleManager.kt @@ -0,0 +1,322 @@ +package club.clubk.ktag.konfigurator + +import android.annotation.SuppressLint +import android.content.Context +import android.bluetooth.BluetoothAdapter +import android.bluetooth.BluetoothManager +import android.bluetooth.le.AdvertiseData +import android.bluetooth.le.AdvertiseSettings +import android.bluetooth.le.ScanFilter +import android.bluetooth.le.ScanSettings +import android.util.Log +import android.bluetooth.le.AdvertiseCallback +import android.bluetooth.le.ScanCallback +import android.bluetooth.le.ScanResult +import kotlinx.coroutines.CompletableDeferred +import kotlinx.coroutines.TimeoutCancellationException +import kotlinx.coroutines.withTimeout +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.Job +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +private const val TAG_BLE_SCAN = "BLE Scanner" +private const val TAG_BLE_AD = "BLE Advertiser" + +private const val SCAN_HOLDOFF_PERIOD_MS: Long = 5000 // 5 seconds + +class BleManager private constructor(context: Context) { + // Use applicationContext to prevent memory leaks + private val appContext: Context = context.applicationContext + + // Bluetooth-related properties + private val bluetoothManager: BluetoothManager = + appContext.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager + private val bluetoothAdapter: BluetoothAdapter? = bluetoothManager.adapter + private val bluetoothLeAdvertiser = bluetoothAdapter?.bluetoothLeAdvertiser + private val bluetoothLeScanner = bluetoothAdapter?.bluetoothLeScanner + private var currentAdvertiseCallback: AdvertiseCallback? = null + private var currentScanCallback: ScanCallback? = null + private var isAdvertising: Boolean = false + private var isScanning: Boolean = false + + // Timestamp for the last scan stop + @Volatile + private var lastScanStopTimeMs: Long = 0 + + // Coroutine scope for managing delays + private val bleManagerScope = CoroutineScope(Dispatchers.Main + Job()) // Use Main dispatcher for UI-related callbacks if needed, or Default for background work + private var scanStartJob: Job? = null + + + // Singleton instance + companion object { + @Volatile + private var instance: BleManager? = null + + /** + * Gets or creates the BleManager instance + * + * @param context The context used to get the application context + * @return BleManager instance + */ + fun getInstance(context: Context): BleManager { + // Double-checked locking pattern + return instance ?: synchronized(this) { + instance ?: BleManager(context).also { instance = it } + } + } + } + + // Utility function to check if Bluetooth is available and enabled + private fun isBluetoothAvailable(): Boolean { + return bluetoothAdapter != null && bluetoothAdapter.isEnabled + } + + @SuppressLint("MissingPermission") + fun startAdvertising(data: ByteArray, advertiseCallback: AdvertiseCallback) { + stopAdvertising() + if (!isBluetoothAvailable()) { + Log.e(TAG_BLE_AD, "Bluetooth is not enabled!") + throw IllegalStateException("Bluetooth is not enabled!") + } + + currentAdvertiseCallback = advertiseCallback + + val settings = AdvertiseSettings.Builder() + .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY) + .setConnectable(false) + .setTimeout(0) + .setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_HIGH) + .build() + + // Calculate available space for manufacturer data + // 2 bytes for manufacturer ID + // Maximum total payload is 31 bytes + // Format: [Length (1 byte)] [Type (1 byte)] [Manufacturer ID (2 bytes)] [Data (remaining bytes)] + val maxManufacturerDataSize = 27 // 31 - 4 bytes overhead + + val truncatedData = if (data.size > maxManufacturerDataSize) { + Log.w( + TAG_BLE_AD, + "Data exceeded maximum size (${data.size} > $maxManufacturerDataSize bytes), truncating..." + ) + data.copyOfRange(0, maxManufacturerDataSize) + } else { + data + } + + Log.d(TAG_BLE_AD, "Advertisement structure:") + Log.d(TAG_BLE_AD, "- Total payload max: 31 bytes") + Log.d(TAG_BLE_AD, "- Overhead: 4 bytes (Length: 1, Type: 1, Manufacturer ID: 2)") + Log.d(TAG_BLE_AD, "- Available for manufacturer data: $maxManufacturerDataSize bytes") + Log.d(TAG_BLE_AD, "- Actual data size: ${truncatedData.size} bytes") + Log.d(TAG_BLE_AD, "- Data: ${truncatedData.joinToString(" ") { String.format("%02X", it) }}") + + val advertiseData = AdvertiseData.Builder() + .addManufacturerData(0xFFFF, truncatedData) + .build() + + Log.i( + TAG_BLE_AD, "Starting advertisement with settings: Mode=${settings.mode}, " + + "TxPower=${settings.txPowerLevel}, Connectable=${settings.isConnectable}" + ) + + try { + bluetoothLeAdvertiser?.startAdvertising(settings, advertiseData, advertiseCallback) + isAdvertising = true + } catch (e: SecurityException) { + Log.e(TAG_BLE_AD, "Permission missing for starting advertisement", e) + advertiseCallback.onStartFailure(AdvertiseCallback.ADVERTISE_FAILED_INTERNAL_ERROR) // Notify caller + } + } + + @SuppressLint("MissingPermission") + fun stopAdvertising() { + Log.d(TAG_BLE_AD, "Attempting to stop advertising...") + currentAdvertiseCallback?.let { callback -> + try { + bluetoothLeAdvertiser?.stopAdvertising(callback) + Log.i(TAG_BLE_AD, "Advertisement stopping process initiated.") + } catch (e: SecurityException) { + Log.e(TAG_BLE_AD, "Permission missing for stopping advertisement", e) + } finally { + currentAdvertiseCallback = null // Clear callback regardless of success/failure to stop + isAdvertising = false + } + } ?: Log.d(TAG_BLE_AD, "No active advertisement to stop or advertiser is null.") + // isAdvertising should be reliably set to false when stop is called or if no active ad + if (currentAdvertiseCallback == null) isAdvertising = false + } + + + @SuppressLint("MissingPermission") + fun startScanning(scanCallback: ScanCallback) { + // Cancel any pending scan start operation + scanStartJob?.cancel() + + scanStartJob = bleManagerScope.launch { + val currentTimeMs = System.currentTimeMillis() + val timeSinceLastScanStopMs = currentTimeMs - lastScanStopTimeMs + + if (isScanning) { // If already scanning with a *different* callback, stop it first + Log.d(TAG_BLE_SCAN, "Already scanning, but a new scan request received. Stopping current scan first.") + internalStopScan() // Use an internal stop that doesn't update lastScanStopTimeMs yet + } + + if (lastScanStopTimeMs > 0 && timeSinceLastScanStopMs < SCAN_HOLDOFF_PERIOD_MS) { + val delayNeededMs = SCAN_HOLDOFF_PERIOD_MS - timeSinceLastScanStopMs + Log.i(TAG_BLE_SCAN, "Scan holdoff active. Delaying scan start by ${delayNeededMs}ms") + delay(delayNeededMs) + } + + // After potential delay, stop any existing scan (e.g. if one was running with a different callback) + // This also ensures that if stopScanning() was called very recently, we respect that. + if (currentScanCallback != null && currentScanCallback != scanCallback) { + internalStopScan() // Stop previous scan if a new one is requested with different callback + } + + + currentScanCallback = scanCallback // Set the new callback + + val filter = ScanFilter.Builder() + .setManufacturerData( + 0xFFFF, // Manufacturer ID + byteArrayOf(0x4B, 0x54, 0x61, 0x67) // "KTag" + ) + .build() + val settings = ScanSettings.Builder().setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build() + + if (!isBluetoothAvailable()) { + Log.e(TAG_BLE_SCAN, "Bluetooth is not enabled! Cannot start scan.") + scanCallback.onScanFailed(ScanCallback.SCAN_FAILED_INTERNAL_ERROR) // Notify caller + return@launch + } + + Log.i(TAG_BLE_SCAN, "Starting scan...") + try { + bluetoothLeScanner?.startScan(listOf(filter), settings, scanCallback) + isScanning = true + } catch (e: SecurityException) { + Log.e(TAG_BLE_SCAN, "Permission missing for starting scan", e) + scanCallback.onScanFailed(ScanCallback.SCAN_FAILED_INTERNAL_ERROR) // Notify caller + isScanning = false // Ensure state is correct + } + } + } + + @SuppressLint("MissingPermission") + fun stopScanning() { + // Cancel any pending scan start job, as we are now explicitly stopping. + scanStartJob?.cancel() + internalStopScan() + } + + // Internal stop scan function to avoid recursive calls and manage state correctly + @SuppressLint("MissingPermission") + private fun internalStopScan() { + Log.d(TAG_BLE_SCAN, "Attempting to stop scanning (internal)...") + currentScanCallback?.let { callback -> + try { + bluetoothLeScanner?.stopScan(callback) + Log.i(TAG_BLE_SCAN, "Scan stopping process initiated.") + } catch (e: SecurityException) { + Log.e(TAG_BLE_SCAN, "Permission missing for stopping scan", e) + } finally { + // This is a good place to record the stop time + lastScanStopTimeMs = System.currentTimeMillis() + currentScanCallback = null // Clear callback + isScanning = false // Update scanning state + } + } ?: Log.d(TAG_BLE_SCAN, "No active scan to stop or scanner is null.") + // Ensure scanning state is false if no callback + if (currentScanCallback == null) isScanning = false + } + + + suspend fun configureDevice(configPacket: ParametersPacket): Boolean { + // Ensure configureDevice uses the managed startScanning/stopScanning + return withTimeout(5000) { // Timeout for the whole configuration operation + val advertisementDetected = CompletableDeferred() + var tempAdvertiseCallback: AdvertiseCallback? = null + var tempScanCallback: ScanCallback? = null + + try { + tempAdvertiseCallback = object : AdvertiseCallback() { + override fun onStartSuccess(settingsInEffect: AdvertiseSettings?) { + super.onStartSuccess(settingsInEffect) + Log.d(TAG_BLE_AD,"Config advertisement started successfully.") + // Only start scanning AFTER advertisement has successfully started + tempScanCallback = object : ScanCallback() { + override fun onScanResult(callbackType: Int, result: ScanResult) { + Log.d(TAG_BLE_SCAN, ">>> ScanCallback.onScanResult ENTERED") + result.scanRecord?.manufacturerSpecificData?.get(0xFFFF)?.let { data -> + if (data.size >= 4 && + data[0] == 0x4B.toByte() && // K + data[1] == 0x54.toByte() && // T + data[2] == 0x61.toByte() && // a + data[3] == 0x67.toByte() // g + ) { + Log.d(TAG_BLE_SCAN, "KTag packet scanned, checking for parameter packet..." + data[4].toString() + " " + data[12].toString()) + val scannedPacket = byteArrayToKTagPacket(data) + if (scannedPacket is ParametersPacket) { + Log.d(TAG_BLE_SCAN, "Parameter packet scanned, checking for parameter match...") + if (result.device.address == configPacket.targetAddress + && scannedPacket.subtype == 3 // Ensure this is the ACK subtype + && scannedPacket.key1 == configPacket.key1 // Example: check relevant params + && scannedPacket.value1 == configPacket.value1 + && scannedPacket.key2 == configPacket.key2 + && scannedPacket.value2 == configPacket.value2 + ) { + Log.i(TAG_BLE_SCAN, "Parameters match, configuration successful for ${result.device.address}!") + if (!advertisementDetected.isCompleted) { + advertisementDetected.complete(true) + } + } + } + } + } + } + + override fun onScanFailed(errorCode: Int) { + Log.e(TAG_BLE_SCAN, "Config scan failed with error: $errorCode") + if (!advertisementDetected.isCompleted) { + advertisementDetected.complete(false) + } + } + } + // Use the main startScanning function which includes holdoff logic + this@BleManager.startScanning(tempScanCallback!!) + } + + override fun onStartFailure(errorCode: Int) { + super.onStartFailure(errorCode) + Log.e(TAG_BLE_AD, "Failed to start config advertisement, error: $errorCode") + if (!advertisementDetected.isCompleted) { + advertisementDetected.complete(false) + } + } + } + + Log.d(TAG_BLE_AD, "Sending configuration packet to ${configPacket.targetAddress}...") + this@BleManager.startAdvertising(kTagPacketToByteArray(configPacket), + tempAdvertiseCallback + ) + + val success = advertisementDetected.await() // Wait for scan result or ad failure + success + + } catch (e: TimeoutCancellationException) { + Log.e(TAG_BLE_SCAN, "Config confirmation timed out for ${configPacket.targetAddress}") + false + } finally { + Log.d(TAG_BLE_SCAN, "Cleaning up configureDevice resources for ${configPacket.targetAddress}") + // Stop the specific advertising and scanning session for this configuration attempt + // Check callbacks before stopping to ensure they were set + tempAdvertiseCallback?.let { this@BleManager.stopAdvertising() } // Uses the main stop which clears currentAdvertiseCallback + tempScanCallback?.let { this@BleManager.stopScanning() } // Uses the main stop which clears currentScanCallback and sets holdoff time + } + } + } +} \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/ConfigurationProgress.kt b/app/src/main/java/club/clubk/ktag/konfigurator/ConfigurationProgress.kt new file mode 100644 index 0000000..14badb2 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/ConfigurationProgress.kt @@ -0,0 +1,7 @@ +package club.clubk.ktag.konfigurator + +data class ConfigurationProgress( + val configuredCount: Int, + val totalCount: Int, + val isComplete: Boolean +) diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/Device.kt b/app/src/main/java/club/clubk/ktag/konfigurator/Device.kt new file mode 100644 index 0000000..8b607aa --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/Device.kt @@ -0,0 +1,24 @@ +package club.clubk.ktag.konfigurator + +import java.util.UUID + +data class Device(val uuid: UUID = UUID.randomUUID(), + var name: String = "Unknown Device", + var address: String = "FF:FF:FF:FF:FF:FF", + var deviceType : Int? = null, + var team : Int? = null, + var playerID : Int? = null, + var deviceState: DeviceState? = null + ) { + + fun deviceTypeName(): String { + return when(deviceType) { + 0 -> "Little Boy BLuE" + 1 -> "2020TPC" + 2 -> "Mobile App" + 3 -> "32ESPecial" + else -> "Unknown Device Type" + } + } +} + diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/DeviceState.kt b/app/src/main/java/club/clubk/ktag/konfigurator/DeviceState.kt new file mode 100644 index 0000000..22ea035 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/DeviceState.kt @@ -0,0 +1,8 @@ +package club.clubk.ktag.konfigurator + +sealed class DeviceState { + object Configurable : DeviceState() + object Ready : DeviceState() + object Playing : DeviceState() + object WrapUp : DeviceState() +} \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/GameConfig.kt b/app/src/main/java/club/clubk/ktag/konfigurator/GameConfig.kt new file mode 100644 index 0000000..ccf6988 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/GameConfig.kt @@ -0,0 +1,9 @@ +package club.clubk.ktag.konfigurator + +data class GameConfig(var name: String = "Default", + var gameLength: Int = 600000, + var pregameLength: Int = 60000, + var numRounds: Int = 2, + var maxHealth: Int = 10, + var numBombs: Int = 1 // Special Weapons Received on Game Reentry +) diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/KTagPacket.kt b/app/src/main/java/club/clubk/ktag/konfigurator/KTagPacket.kt new file mode 100644 index 0000000..b6a293c --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/KTagPacket.kt @@ -0,0 +1,365 @@ +package club.clubk.ktag.konfigurator + +val kTagByte = byteArrayOf( + 0x4B.toByte(), // K + 0x54.toByte(), // T + 0x61.toByte(), // a + 0x67.toByte() // g +) + +// Data classes for packet parsing +sealed class KTagPacket { + abstract val type: Int + abstract val typeName: String + abstract val eventNumber: Int +} + +data class InstigateGamePacket( + override val type: Int, + override val typeName: String = "Instigate Game", + override val eventNumber: Int, + val gameLength: Int, + val countdownTime: Int +) : KTagPacket() + +data class EventPacket( + override val type: Int, + override val typeName: String = "Event", + override val eventNumber: Int, + val targetAddress: String, + val eventId: Int, + val eventData: Int +) : KTagPacket() + +data class TagPacket( + override val type: Int, + override val typeName: String = "Tag", + override val eventNumber: Int, + val txPower: Int, + val protocol: Int, + val teamId: Int, + val playerId: Int, + val damage: Int, + val color: Int, + val targetAddress: String +) : KTagPacket() + +data class ConsolePacket( + override val type: Int, + override val typeName: String = "Console", + override val eventNumber: Int, + val consoleString: String +) : KTagPacket() + +data class StatusPacket( + override val type: Int, + override val typeName: String = "Status", + override val eventNumber: Int, + val txPower: Int, + val protocol: Int, + val teamId: Int, + val playerId: Int, + val health: Int, + val maxHealth: Int, + val primaryColor: Int, + val secondaryColor: Int, + val systemKState: Int +) : KTagPacket() + +data class ParametersPacket( + override val type: Int, + override val typeName: String = "Parameters", + override val eventNumber: Int, + val targetAddress: String, + val subtype: Int, + val key1: Int, + val value1: Int, + val key2: Int, + val value2: Int +) : KTagPacket() + +data class HelloPacket( + override val type: Int, + override val typeName: String = "Hello", + override val eventNumber: Int, + val majorVersion: Int, + val minorVersion: Int, + val deviceType: Int, + val teamId: Int, + val deviceName: String +) : KTagPacket() + +fun byteArrayToKTagPacket(data: ByteArray): KTagPacket { + val type = data[4].toInt() + val eventNumber = data[5].toInt() + + return when (type) { + 0x01 -> InstigateGamePacket( + type = type, + eventNumber = eventNumber, + gameLength = bytesToInt(data, 6, 4), + countdownTime = bytesToInt(data, 10, 4) + ) + + 0x02 -> EventPacket( + type = type, + eventNumber = eventNumber, + targetAddress = bytesToMacAddress(data, 6), + eventId = bytesToInt(data, 12, 4), + eventData = bytesToInt(data, 16, 4) + ) + + 0x03 -> TagPacket( + type = type, + eventNumber = eventNumber, + txPower = data[6].toInt(), + protocol = data[7].toInt(), + teamId = data[8].toInt(), + playerId = data[9].toInt(), + damage = bytesToInt(data, 10, 2), + color = bytesToInt(data, 12, 4), + targetAddress = bytesToMacAddress(data, 16) + ) + + 0x04 -> ConsolePacket( + type = type, + eventNumber = eventNumber, + consoleString = data.slice(6..26).toByteArray().let { bytes -> + // Find the position of the first null byte if any + val nullPos = bytes.indexOfFirst { it == 0.toByte() } + // If there's a null byte, take only up to that position, otherwise take all bytes + if (nullPos >= 0) { + bytes.slice(0 until nullPos).toByteArray() + } else { + bytes + }.toString(Charsets.US_ASCII).trim() + } + ) + + 0x05 -> StatusPacket( + type = type, + eventNumber = eventNumber, + txPower = data[6].toInt(), + protocol = data[7].toInt(), + teamId = data[8].toInt(), + playerId = data[8].toInt(), + health = bytesToInt(data, 10, 2), + maxHealth = bytesToInt(data, 12, 2), + primaryColor = bytesToInt(data, 14, 4), + secondaryColor = bytesToInt(data, 18, 4), + systemKState = data[22].toInt() + ) + + 0x06 -> ParametersPacket( + type = type, + eventNumber = eventNumber, + targetAddress = bytesToMacAddress(data, 6), + subtype = data[12].toInt(), + key1 = bytesToInt(data, 13, 2), + value1 = bytesToInt(data, 15, 4), + key2 = bytesToInt(data, 19, 2), + value2 = bytesToInt(data, 21, 4) + ) + + 0x07 -> HelloPacket( + type = type, + eventNumber = eventNumber, + majorVersion = data[6].toInt(), + minorVersion = data[7].toInt(), + deviceType = bytesToInt(data, 8, 2), + teamId = data[10].toInt(), + deviceName = data.slice(11..26).toByteArray().let { bytes -> + // Find the position of the first null byte if any + val nullPos = bytes.indexOfFirst { it == 0.toByte() } + // If there's a null byte, take only up to that position, otherwise take all bytes + if (nullPos >= 0) { + bytes.slice(0 until nullPos).toByteArray() + } else { + bytes + }.toString(Charsets.US_ASCII).trim() + } + ) + + else -> StatusPacket( + type = type, + typeName = "Unknown", + eventNumber = eventNumber, + txPower = 0, + protocol = 0, + teamId = 0, + playerId = 0, + health = 0, + maxHealth = 0, + primaryColor = 0, + secondaryColor = 0, + systemKState = 0 + ) + } +} + +fun kTagPacketToByteArray(kTagPacket: KTagPacket): ByteArray { + var payload: ByteArray = byteArrayOf(0x00.toByte()) + when (kTagPacket) { + is ParametersPacket -> { + val addressBytes = macAddressToBytes(kTagPacket.targetAddress) + payload = byteArrayOf( + 0x06.toByte(), // Packet Type: Parameter + (kTagPacket.eventNumber and 0xFF).toByte(), // Event counter + + *addressBytes, + + (kTagPacket.subtype and 0xFF).toByte(), + + (kTagPacket.key1 and 0xFF).toByte(), + ((kTagPacket.key1 shr 8) and 0xFF).toByte(), + + (kTagPacket.value1 and 0xFF).toByte(), + ((kTagPacket.value1 shr 8) and 0xFF).toByte(), + ((kTagPacket.value1 shr 16) and 0xFF).toByte(), + ((kTagPacket.value1 shr 24) and 0xFF).toByte(), + + (kTagPacket.key2 and 0xFF).toByte(), + ((kTagPacket.key2 shr 8) and 0xFF).toByte(), + + (kTagPacket.value2 and 0xFF).toByte(), + ((kTagPacket.value2 shr 8) and 0xFF).toByte(), + ((kTagPacket.value2 shr 16) and 0xFF).toByte(), + ((kTagPacket.value2 shr 24) and 0xFF).toByte() + ) + ByteArray(2) { 0xFF.toByte() } + } + is ConsolePacket -> { + // something + } + is EventPacket -> { + val addressBytes = macAddressToBytes(kTagPacket.targetAddress) + payload = byteArrayOf( + 0x02.toByte(), // Packet Type: Event + (kTagPacket.eventNumber and 0xFF).toByte(), // Event counter + + *addressBytes, + + (kTagPacket.eventId and 0xFF).toByte(), + ((kTagPacket.eventId shr 8) and 0xFF).toByte(), + ((kTagPacket.eventId shr 16) and 0xFF).toByte(), + ((kTagPacket.eventId shr 24) and 0xFF).toByte(), // Event ID + + (kTagPacket.eventData and 0xFF).toByte(), + ((kTagPacket.eventData shr 8) and 0xFF).toByte(), + ((kTagPacket.eventData shr 16) and 0xFF).toByte(), + ((kTagPacket.eventData shr 24) and 0xFF).toByte() // Event data + ) + ByteArray(7) { 0xFF.toByte() } + } + is HelloPacket -> { + // something + } + is InstigateGamePacket -> { + payload = byteArrayOf( + 0x01.toByte(), // Packet Type: Instigate Game + (kTagPacket.eventNumber and 0xFF).toByte(), // Event counter + + (kTagPacket.gameLength and 0xFF).toByte(), + ((kTagPacket.gameLength shr 8) and 0xFF).toByte(), + ((kTagPacket.gameLength shr 16) and 0xFF).toByte(), + ((kTagPacket.gameLength shr 24) and 0xFF).toByte(), // Game length + + (kTagPacket.countdownTime and 0xFF).toByte(), + ((kTagPacket.countdownTime shr 8) and 0xFF).toByte(), + ((kTagPacket.countdownTime shr 16) and 0xFF).toByte(), + ((kTagPacket.countdownTime shr 24) and 0xFF).toByte() // Time until countdown + ) + ByteArray(21) { 0xFF.toByte() } + } + is StatusPacket -> { + // something + } + is TagPacket -> { + // something + } + } + return kTagByte + payload +} + +// Helper function to convert bytes to integers +private fun bytesToInt(data: ByteArray, offset: Int, length: Int): Int { + var result = 0 + for (i in 0 until length) { + result = result or ((data[offset + i].toInt() and 0xFF) shl (8 * i)) + } + return result +} + +// Helper function to convert bytes to MAC address string +private fun bytesToMacAddress(data: ByteArray, offset: Int): String { + return (0..5).joinToString(":") { + String.format("%02X", data[offset + it]) + } +} + +private fun macAddressToBytes(address: String): ByteArray { + val cleanAddress = address.replace(":", "").replace("-", "") + + // Check if the address is valid (12 hex characters = 6 bytes) + if (cleanAddress.length != 12) { + throw IllegalArgumentException("Invalid BLE address length") + } + + // Convert the hex string to bytes. Reverse the bytes to little-endian format. + val bytes = ByteArray(6) + var j = 5 + for (i in 0 until 6) { + val hexByte = cleanAddress.substring(i * 2, i * 2 + 2) + bytes[j] = hexByte.toInt(16).toByte() + j-- + } + + return bytes +} + +class InstigatePacketGenerator { + private var eventCount = 0 + + fun generatePacket(gameLength: Int, timeUntilCountdown: Int): InstigateGamePacket { + val newInstigateGamePacket = InstigateGamePacket( + type = 1, // instigate + eventNumber = eventCount, + gameLength = gameLength, + countdownTime = timeUntilCountdown + ) + eventCount++ + return newInstigateGamePacket + } +} + +class EventPacketGenerator { + private var eventCount = 0 + + fun generatePacket(targetAddress: String, eventId: Int = 0, eventData: Int = 0): EventPacket { + val newEventPacket = EventPacket( + type = 2, // event + eventNumber = eventCount, + targetAddress = targetAddress, + eventId = eventId, + eventData = eventData + ) + eventCount++ + return newEventPacket + } +} + +class ParametersPacketGenerator { + private var eventCount = 0 + + fun generatePacket(targetAddress: String, subtype: Int, + key1: Int = 0, value1: Int = 0, + key2: Int = 0, value2: Int = 0): ParametersPacket { + val newParametersPacket = ParametersPacket( + type = 6, // parameters + eventNumber = eventCount, + targetAddress = targetAddress, + subtype = subtype, + key1 = key1, value1 = value1, + key2 = key2, value2 = value2 + ) + eventCount++ + return newParametersPacket + } +} \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/MainActivity.kt b/app/src/main/java/club/clubk/ktag/konfigurator/MainActivity.kt index 27b07de..d67932b 100644 --- a/app/src/main/java/club/clubk/ktag/konfigurator/MainActivity.kt +++ b/app/src/main/java/club/clubk/ktag/konfigurator/MainActivity.kt @@ -1,47 +1,655 @@ package club.clubk.ktag.konfigurator +import android.Manifest +import android.bluetooth.BluetoothManager +import android.content.Context +import android.content.pm.PackageManager +import android.os.Build import android.os.Bundle +import android.util.Log import androidx.activity.ComponentActivity import androidx.activity.compose.setContent -import androidx.activity.enableEdgeToEdge -import androidx.compose.foundation.layout.fillMaxSize -import androidx.compose.foundation.layout.padding -import androidx.compose.material3.Scaffold -import androidx.compose.material3.Text -import androidx.compose.runtime.Composable +import androidx.activity.result.contract.ActivityResultContracts +import androidx.compose.foundation.layout.* +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.material.icons.filled.Check +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.core.content.ContextCompat +// import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier -import androidx.compose.ui.tooling.preview.Preview +import androidx.compose.ui.graphics.Color +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.res.painterResource +import androidx.compose.ui.text.font.FontWeight +import androidx.compose.ui.text.input.KeyboardType +import androidx.compose.ui.text.style.TextAlign +import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp import club.clubk.ktag.konfigurator.ui.theme.KonfiguratorTheme +import kotlinx.coroutines.delay +import kotlinx.coroutines.launch + +private const val TAG = "Konfigurator" class MainActivity : ComponentActivity() { + private val requiredPermissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) { + arrayOf( + Manifest.permission.BLUETOOTH_ADVERTISE, + Manifest.permission.BLUETOOTH_CONNECT, + Manifest.permission.BLUETOOTH_SCAN, + Manifest.permission.ACCESS_FINE_LOCATION, // Required for BLE operations + Manifest.permission.ACCESS_COARSE_LOCATION // Required for BLE operations + ) + } else { + arrayOf( + Manifest.permission.BLUETOOTH, + Manifest.permission.BLUETOOTH_ADMIN, + Manifest.permission.ACCESS_FINE_LOCATION, + Manifest.permission.ACCESS_COARSE_LOCATION + ) + } + + private val permissionLauncher = registerForActivityResult( + ActivityResultContracts.RequestMultiplePermissions() + ) { permissions -> + val allGranted = permissions.entries.all { it.value } + Log.d(TAG, "Permission results: ${permissions.map { "${it.key}: ${it.value}" }}") + + if (allGranted) { + Log.i(TAG, "All permissions granted") + mainScreen() + } else { + // Show which permissions were denied + val deniedPermissions = permissions.filter { !it.value }.keys + Log.w(TAG, "Some permissions denied: $deniedPermissions") + setContent { + MaterialTheme { + Surface( + modifier = Modifier.fillMaxSize(), + color = MaterialTheme.colorScheme.background + ) { + PermissionDeniedScreen( + deniedPermissions = deniedPermissions.toList() + ) { requestPermissions() } + } + } + } + } + } + + private fun checkAndRequestPermissions() { + Log.d(TAG, "Checking permissions: ${requiredPermissions.joinToString()}") + if (hasRequiredPermissions()) { + Log.i(TAG, "All required permissions already granted") + mainScreen() + } else { + Log.i(TAG, "Requesting permissions") + requestPermissions() + } + } + + private fun hasRequiredPermissions(): Boolean { + return requiredPermissions.all { permission -> + ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED + } + } + + private fun requestPermissions() { + Log.d(TAG, "Launching permission request") + permissionLauncher.launch(requiredPermissions) + } + override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) - enableEdgeToEdge() + checkAndRequestPermissions() + // enableEdgeToEdge() + } + + private fun mainScreen() { setContent { KonfiguratorTheme { - Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding -> - Greeting( - name = "Android", - modifier = Modifier.padding(innerPadding) - ) - } + StateMachine(StateMachineViewModel(applicationContext)) } } } } @Composable -fun Greeting(name: String, modifier: Modifier = Modifier) { - Text( - text = "Hello $name!", - modifier = modifier +fun PermissionDeniedScreen( + deniedPermissions: List, + onRequestPermissions: () -> Unit +) { + Log.d(TAG, "Showing permission denied screen for permissions: $deniedPermissions") + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.Center + ) { + Text( + text = "The following permissions are required:", + style = MaterialTheme.typography.bodyLarge, + textAlign = TextAlign.Center, + modifier = Modifier.padding(bottom = 8.dp) + ) + deniedPermissions.forEach { permission -> + Text( + text = "• ${permission.split(".").last()}", + style = MaterialTheme.typography.bodyMedium, + textAlign = TextAlign.Center, + modifier = Modifier.padding(vertical = 4.dp) + ) + } + Button( + onClick = { + Log.d(TAG, "Permission request button clicked") + onRequestPermissions() + }, + modifier = Modifier.padding(top = 16.dp) + ) { + Text("Grant Permissions") + } + } +} + +@Composable +fun StateMachine(stateMachine: StateMachineViewModel) { // stateMachine: StateMachineViewModel = viewModel() + val appState by stateMachine.appState.collectAsState() + + Surface( + modifier = Modifier.fillMaxSize() + ) { + Column( + modifier = Modifier + .fillMaxSize() + .padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally, + verticalArrangement = Arrangement.spacedBy(16.dp) + ) { + when (appState) { + AppState.TitleScreen -> TitleScreen(stateMachine) + AppState.GameSettings -> GameSettingsScreen(stateMachine) + AppState.TeamSettings -> TeamSettingsScreen(stateMachine) + AppState.PregameTimer -> PregameTimerScreen(stateMachine) + AppState.Countdown -> CountdownScreen(stateMachine) + AppState.GameTimer -> GameTimerScreen(stateMachine) + AppState.GameOver -> GameOverScreen(stateMachine) + AppState.WrapUp -> Text("Wrap Up") + } + } + } +} + +// ------------ +// TITLE SCREEN +// + +@Composable +fun BigLogo() { + Icon( + painter = painterResource(id = R.drawable.konfigurator), + contentDescription = "Konfigurator Logo", + modifier = Modifier.size(192.dp), + tint = Color.Unspecified ) } -@Preview(showBackground = true) @Composable -fun GreetingPreview() { - KonfiguratorTheme { - Greeting("Android") +fun TitleScreen(stateMachine: StateMachineViewModel) { + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text("Konfigurator", style = MaterialTheme.typography.headlineMedium) + BigLogo() + } + Spacer(modifier = Modifier.height(16.dp)) + Button( + onClick = { stateMachine.nextState() }, + modifier = Modifier.fillMaxWidth() + ) { + Text("New Game") + } +} + +// ------------- +// GAME SETTINGS +// ------------- + +@Composable +fun GameSettingsScreen(stateMachine: StateMachineViewModel) { + val currentGameConfig by stateMachine.currentGameConfig.collectAsState() + + Column( + modifier = Modifier.fillMaxSize(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text( + text = "Game Settings", + style = MaterialTheme.typography.headlineMedium, + modifier = Modifier.padding(16.dp) + ) + GameConfigEditor(oldGameConfig = currentGameConfig, + onSave = { + stateMachine.updateGameConfig(it) + stateMachine.nextState() + }) + } +} + +@Composable +fun GameConfigEditor(oldGameConfig: GameConfig, + onSave: (GameConfig) -> Unit, + modifier: Modifier = Modifier) { + key(oldGameConfig) { + var name by rememberSaveable(oldGameConfig.name) { mutableStateOf(oldGameConfig.name) } + var gameLength by rememberSaveable(oldGameConfig.gameLength) { mutableStateOf(oldGameConfig.gameLength.toString()) } + var pregameLength by rememberSaveable(oldGameConfig.pregameLength) { mutableStateOf(oldGameConfig.pregameLength.toString()) } + var numRounds by rememberSaveable(oldGameConfig.numRounds) { mutableStateOf(oldGameConfig.numRounds.toString()) } + var maxHealth by rememberSaveable(oldGameConfig.maxHealth) { mutableStateOf(oldGameConfig.maxHealth.toString()) } + var numBombs by rememberSaveable(oldGameConfig.numBombs) { mutableStateOf(oldGameConfig.numBombs.toString()) } + + // For tracking validation errors + var gameLengthError by rememberSaveable { mutableStateOf(false) } + var pregameLengthError by rememberSaveable { mutableStateOf(false) } + var numRoundsError by rememberSaveable { mutableStateOf(false) } + var maxHealthError by rememberSaveable { mutableStateOf(false) } + var numBombsError by rememberSaveable { mutableStateOf(false) } + + // Function to validate the form + fun validateForm(): Boolean { + gameLengthError = !isValidInteger(gameLength) + pregameLengthError = !isValidInteger(pregameLength) + numRoundsError = !isValidInteger(numRounds) + maxHealthError = !isValidInteger(maxHealth) + numBombsError = !isValidInteger(numBombs) + + return !gameLengthError && !pregameLengthError && !numRoundsError && !maxHealthError && !numBombsError + } + + // Function to update the data class when values change + fun saveGameConfig() { + // Only update if all integer fields are valid + if (validateForm()) { + val newGameConfig = GameConfig( + name = name, + gameLength = gameLength.toIntOrNull() ?: oldGameConfig.gameLength, + pregameLength = pregameLength.toIntOrNull() ?: oldGameConfig.pregameLength, + numRounds = numRounds.toIntOrNull() ?: oldGameConfig.numRounds, + maxHealth = maxHealth.toIntOrNull() ?: oldGameConfig.maxHealth, + numBombs = numBombs.toIntOrNull() ?: oldGameConfig.numBombs + ) + onSave(newGameConfig) + } + } + + Column( + modifier = modifier + .fillMaxWidth() + .padding(16.dp), + verticalArrangement = Arrangement.spacedBy(8.dp) + ) { + // String value field + OutlinedTextField( + value = name, + onValueChange = { + name = it + }, + label = { Text("Name") }, + modifier = Modifier.fillMaxWidth() + ) + + // Integer value fields + IntegerTextField( + value = gameLength, + onValueChange = { + gameLength = it + // gameLengthError = !isValidInteger(it) + }, + label = "Game Length", + isError = gameLengthError + ) + + IntegerTextField( + value = pregameLength, + onValueChange = { + pregameLength = it + // pregameLengthError = !isValidInteger(it) + }, + label = "Pregame Length", + isError = pregameLengthError + ) + + IntegerTextField( + value = numRounds, + onValueChange = { + numRounds = it + // numRoundsError = !isValidInteger(it) + }, + label = "Number Of Rounds", + isError = numRoundsError + ) + + IntegerTextField( + value = maxHealth, + onValueChange = { + maxHealth = it + // maxHealthError = !isValidInteger(it) + }, + label = "Max Health", + isError = maxHealthError + ) + + IntegerTextField( + value = numBombs, + onValueChange = { + numBombs = it + // numBombsError = !isValidInteger(it) + }, + label = "Number Of Bombs", + isError = numBombsError + ) + } + + Spacer(modifier = Modifier.height(8.dp)) + Button( // Save button + onClick = { saveGameConfig() }, + modifier = Modifier.fillMaxWidth() + ) { + Text("Confirm") + } + } +} + +// Helper function to validate integer input +private fun isValidInteger(input: String): Boolean { + return input.toIntOrNull() != null || input.isEmpty() +} + +// Helper composable for integer input fields +@Composable +private fun IntegerTextField( + value: String, + onValueChange: (String) -> Unit, + label: String, + isError: Boolean +) { + OutlinedTextField( + value = value, + onValueChange = onValueChange, + label = { Text(label) }, + keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Number), + isError = isError, + supportingText = if (isError) { + { Text("Please enter a valid integer") } + } else null, + modifier = Modifier.fillMaxWidth() + ) +} + +// ------------- +// TEAM SETTINGS +// ------------- + +@Composable +fun TeamSettingsScreen(stateMachine: StateMachineViewModel) { + Log.d("MAINACTIVITY", "recomposing team setting screen") + val coroutineScope = rememberCoroutineScope() + val devices by stateMachine.devices.collectAsState() + val allDevicesReady by stateMachine.allDevicesReady.collectAsState() + Scaffold( + // Bottom bar that stays fixed at the bottom + bottomBar = { + BottomAppBar( + containerColor = MaterialTheme.colorScheme.surface, + tonalElevation = 8.dp + ) { + Box( + modifier = Modifier.fillMaxWidth(), + contentAlignment = Alignment.Center + ) { + if (allDevicesReady) { + Button( + onClick = { stateMachine.nextState() }, + modifier = Modifier.fillMaxWidth() + ) { + Text("Start Game") + } + } else { + SideBySideButtons( + "Apply", + "Ready", + onLeftButtonClick = { coroutineScope.launch { stateMachine.configureDevices() } }, + onRightButtonClick = { stateMachine.readyAllDevices() } + ) + } + } + } + } + ) { paddingValues -> + DeviceList(stateMachine, devices, Modifier.fillMaxSize().padding(paddingValues)) + } +} + +@Composable +fun DeviceList(stateMachine: StateMachineViewModel, devices: List, modifier: Modifier) { + LazyColumn(modifier = modifier) { + items(devices) { device -> + DeviceCard(stateMachine, device) + } + } +} + +@Composable +fun SideBySideButtons( + leftButtonText: String, + rightButtonText: String, + onLeftButtonClick: () -> Unit, + onRightButtonClick: () -> Unit, + modifier: Modifier = Modifier +) { + Row( + modifier = modifier + .fillMaxWidth() + .padding(16.dp), + horizontalArrangement = Arrangement.spacedBy(8.dp) // Add space between buttons + ) { + Button( + onClick = onLeftButtonClick, + modifier = Modifier.weight(1f) // Takes up half of the available width + ) { + Text(text = leftButtonText) + } + + Button( + onClick = onRightButtonClick, + modifier = Modifier.weight(1f) // Takes up half of the available width + ) { + Text(text = rightButtonText) + } + } +} + +@Composable +fun DeviceCard(stateMachine: StateMachineViewModel, device: Device) { + val backgroundColor = when (device.team) { + 0 -> Color.Magenta + 1 -> Color.Red + 2 -> Color.Blue + else -> MaterialTheme.colorScheme.surface // Default color + } + Card(modifier = Modifier + .fillMaxWidth() + .padding(vertical = 4.dp), + onClick = { stateMachine.cycleDeviceTeam(device) }, + colors = CardDefaults.cardColors( + containerColor = backgroundColor + )) { + Text(device.name + " | " + device.deviceTypeName()) + Text(if(device.deviceState == DeviceState.Ready) {"READY"} else {"NOT READY"}) + } +} + +// ------------- +// PREGAME TIMER +// ------------- + +fun formatTimeToMinutesSeconds(remainingSeconds: Int): String { + val minutes = remainingSeconds / 60 + val seconds = remainingSeconds % 60 + + // Format to ensure seconds always shows with two digits (e.g., "01" instead of "1") + return "$minutes:${seconds.toString().padStart(2, '0')}" +} + +@Composable +fun CountdownTimer(timeInMillis: Long, onCountdownComplete: () -> Unit) { + // Store remaining time as state + var remainingTime by remember { mutableLongStateOf(timeInMillis) } + val initialTime = remember { timeInMillis } + + // Use LaunchedEffect to create a coroutine that runs the countdown + LaunchedEffect(key1 = timeInMillis) { + // Reset the timer if the input time changes + remainingTime = timeInMillis + + // Continue counting down until we reach zero + while (remainingTime > 0) { + delay(1000) // Update every second + remainingTime -= 1000 + Log.d("CountdownTimer", "Remaining time: ${remainingTime / 1000} seconds") + } + + // Log when countdown reaches zero + Log.d("CountdownTimer", "Countdown finished!") + onCountdownComplete() + } + + val remainingSeconds = (remainingTime / 1000).toInt() + val progress = if (initialTime > 0) remainingTime.toFloat() / initialTime.toFloat() else 0f + val formattedTime = formatTimeToMinutesSeconds(remainingSeconds) + + // UI to display the countdown + Column( + modifier = Modifier + .fillMaxWidth() + .padding(16.dp), + horizontalAlignment = Alignment.CenterHorizontally + ) { + // Display remaining time in seconds + Text( + text = formattedTime, + fontSize = 36.sp, + fontWeight = FontWeight.Bold, + modifier = Modifier.padding(bottom = 8.dp) + ) + + // Display progress bar + LinearProgressIndicator( + progress = { progress }, + modifier = Modifier.fillMaxWidth(), + ) + } +} + +@Composable +fun PregameTimerScreen(stateMachine: StateMachineViewModel) { + val currentGameConfig by stateMachine.currentGameConfig.collectAsState() + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text( + text = "Game Starts In", + style = MaterialTheme.typography.headlineMedium + ) + CountdownTimer(currentGameConfig.pregameLength.toLong(), onCountdownComplete = { + stateMachine.nextState() + }) + } +} + +// --------- +// COUNTDOWN +// --------- + +@Composable +fun CountdownScreen(stateMachine: StateMachineViewModel) { + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + CountdownTimer(6000.toLong(), onCountdownComplete = { + stateMachine.nextState() + }) + } +} + +// ---------- +// GAME TIMER +// ---------- + +@Composable +fun GameTimerScreen(stateMachine: StateMachineViewModel) { + val currentGameConfig by stateMachine.currentGameConfig.collectAsState() + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text( + text = "Game In Progress", + style = MaterialTheme.typography.headlineMedium + ) + + CountdownTimer(currentGameConfig.gameLength.toLong(), onCountdownComplete = { + stateMachine.nextState() + }) + + Button( + onClick = { stateMachine.nextState() }, + modifier = Modifier.fillMaxWidth() + ) { + Text("End Game") + } + } +} + +// --------- +// GAME OVER +// --------- + +@Composable +fun GameOverScreen(stateMachine: StateMachineViewModel) { + Column( + modifier = Modifier.fillMaxWidth(), + horizontalAlignment = Alignment.CenterHorizontally + ) { + Text( + text = "Game Over", + style = MaterialTheme.typography.headlineMedium + ) + + Spacer(modifier = Modifier.height(24.dp)) + + Icon( + imageVector = androidx.compose.material.icons.Icons.Default.Check, + contentDescription = null, + modifier = Modifier.size(100.dp), + tint = MaterialTheme.colorScheme.primary + ) + + Spacer(modifier = Modifier.height(16.dp)) + Button( + onClick = { stateMachine.nextState() }, + modifier = Modifier.fillMaxWidth() + ) { + Text("Play Again") + } } } \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/MultiDeviceConfigurator.kt b/app/src/main/java/club/clubk/ktag/konfigurator/MultiDeviceConfigurator.kt new file mode 100644 index 0000000..088a7e7 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/MultiDeviceConfigurator.kt @@ -0,0 +1,116 @@ +package club.clubk.ktag.konfigurator + +import android.util.Log +import kotlinx.coroutines.* +import kotlinx.coroutines.sync.Mutex +import kotlinx.coroutines.sync.withLock + +// Assuming ParametersPacket and BleManager are defined as in your existing code + +class MultiDeviceConfigurator(private val bleManager: BleManager) { + + // Mutex to ensure only one device configuration (advertise + scan for ack) happens at a time + private val bleOperationMutex = Mutex() + + /** + * Configures a list of devices sequentially in terms of BLE operations, + * but the overall process can be managed as part of a larger concurrent workflow. + * + * @param deviceConfigs List of ParametersPacket for each device to configure. + * @param onDeviceConfigured A callback invoked for each device with its address and success status. + * @param onProgressUpdate A callback to report overall progress (e.g., "Configuring device X of Y"). + * @return A map of device addresses to their configuration success status. + */ + suspend fun configureMultipleDevices( + deviceConfigs: List, + onDeviceConfigured: suspend (deviceAddress: String, success: Boolean) -> Unit, + onProgressUpdate: suspend (configuredCount: Int, totalCount: Int) -> Unit + ): Map { + val results = mutableMapOf() + var configuredCount = 0 + val totalCount = deviceConfigs.size + + onProgressUpdate(configuredCount, totalCount) + + for (configPacket in deviceConfigs) { + // Ensure only one BLE configuration operation (advertising + specific scan) + // happens at a time across all calls that might use this shared BleManager. + // If configureDevice itself manages a Mutex for its specific startAdvertising/startScanning, + // this outer Mutex might be redundant for that part, but it's good for clarity + // if other BLE operations could interfere. + // For now, let's assume configureDevice is a self-contained operation. + // The critical part is that `bleManager.configureDevice` itself does a full + // advertise -> scan -> stop cycle. + + var success = false + try { + // The bleOperationMutex ensures that if multiple coroutines call + // configureMultipleDevices, or if other parts of your app try to use + // bleManager for advertising/scanning, they don't interfere with the + // current device's configuration sequence. + bleOperationMutex.withLock { + Log.i( + "MultiDeviceConfigurator", + "Attempting to configure ${configPacket.targetAddress}" + ) + // The existing configureDevice already has its own timeout. + success = bleManager.configureDevice(configPacket) + } + } catch (e: Exception) { + // Catch any unexpected exceptions during the configuration of a single device + Log.e( + "MultiDeviceConfigurator", + "Exception configuring ${configPacket.targetAddress}", + e + ) + success = false + } + + results[configPacket.targetAddress] = success + configuredCount++ + onDeviceConfigured(configPacket.targetAddress, success) + onProgressUpdate(configuredCount, totalCount) + + if (success) { + Log.i( + "MultiDeviceConfigurator", + "Successfully configured ${configPacket.targetAddress}" + ) + } else { + Log.w( + "MultiDeviceConfigurator", + "Failed to configure ${configPacket.targetAddress}" + ) + } + + // Optional: Add a small delay between configuring devices if peripherals need time + // delay(100) + } + return results + } +} + +// --- Example Usage (e.g., in a ViewModel or a Service) --- +suspend fun exampleUsage(bleManager: BleManager, allDeviceConfigs: List) { + val configurator = MultiDeviceConfigurator(bleManager) + + Log.d("App", "Starting configuration for ${allDeviceConfigs.size} devices...") + + // This whole block can be launched in a specific coroutine scope (e.g., viewModelScope) + // The configureMultipleDevices function itself is sequential for BLE ops, + // but the call to it can be non-blocking for the UI. + val configurationResults = configurator.configureMultipleDevices( + deviceConfigs = allDeviceConfigs, + onDeviceConfigured = { deviceAddress, success -> + Log.d("App", "Device $deviceAddress configuration result: $success") + // Update UI for this specific device + }, + onProgressUpdate = { configured, total -> + Log.d("App", "Progress: $configured / $total devices configured.") + // Update overall progress UI + } + ) + + Log.d("App", "All device configurations attempted. Results: $configurationResults") + // Process overall results +} \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/Player.kt b/app/src/main/java/club/clubk/ktag/konfigurator/Player.kt new file mode 100644 index 0000000..1a6da53 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/Player.kt @@ -0,0 +1,10 @@ +package club.clubk.ktag.konfigurator + +import java.util.UUID + +data class Player(val uuid: UUID = UUID.randomUUID()) { + var name : String = "Anonymous" + var id : Int = 0 + var numWins : Int = 0 + var numLosses : Int = 0 +} diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/SoundManager.kt b/app/src/main/java/club/clubk/ktag/konfigurator/SoundManager.kt new file mode 100644 index 0000000..743491c --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/SoundManager.kt @@ -0,0 +1,57 @@ +package club.clubk.ktag.konfigurator + +import android.content.Context +import android.media.AudioAttributes +import android.media.AudioManager +import android.media.SoundPool +import android.os.Build +import android.util.Log + +class SoundManager(private val context: Context) { + private var soundPool: SoundPool? = null + private var doubleChirpID: Int = 0 + private var isLoaded = false + + init { + // Initialize the SoundPool + soundPool = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) { + SoundPool.Builder() + .setMaxStreams(3) // Allow up to 3 simultaneous sounds + .setAudioAttributes( + AudioAttributes.Builder() + .setUsage(AudioAttributes.USAGE_MEDIA) + .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION) + .build() + ) + .build() + } else { + @Suppress("DEPRECATION") + SoundPool(3, AudioManager.STREAM_MUSIC, 0) + } + + // Set up load listener to know when sound is ready to play + soundPool?.setOnLoadCompleteListener { _, _, status -> + isLoaded = status == 0 + } + + // Load the click sound (place your click.wav file in res/raw) + doubleChirpID = soundPool?.load(context, R.raw.double_chirp, 1) ?: 0 + } + + fun playDoubleChirp() { + if (isLoaded) { + // Play the sound with: + // leftVolume, rightVolume (1f = full volume) + // priority (0 = lowest) + // loop (0 = no loop) + // rate (1f = normal playback speed) + soundPool?.play(doubleChirpID, 1f, 1f, 0, 0, 1f) + } + } + + // Important: Release resources when no longer needed + fun release() { + soundPool?.release() + soundPool = null + } +} \ No newline at end of file diff --git a/app/src/main/java/club/clubk/ktag/konfigurator/StateMachineViewModel.kt b/app/src/main/java/club/clubk/ktag/konfigurator/StateMachineViewModel.kt new file mode 100644 index 0000000..aeedd61 --- /dev/null +++ b/app/src/main/java/club/clubk/ktag/konfigurator/StateMachineViewModel.kt @@ -0,0 +1,348 @@ +package club.clubk.ktag.konfigurator + +import android.annotation.SuppressLint +import android.bluetooth.le.AdvertiseCallback +import android.bluetooth.le.AdvertiseSettings +import android.bluetooth.le.ScanCallback +import android.bluetooth.le.ScanResult +import android.content.Context +import android.util.Log +import androidx.lifecycle.ViewModel +import androidx.lifecycle.viewModelScope +import kotlinx.coroutines.launch +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.StateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update + +private const val TAG_BLE_SCAN = "BLE Scanner" +private const val TAG_BLE_AD = "BLE Advertiser" +private const val TAG_STATE_MACHINE = "StateMachineVM" + +class StateMachineViewModel(context: Context) : ViewModel() { + + private val _appState = MutableStateFlow(AppState.TitleScreen) + val appState: StateFlow = _appState.asStateFlow() + + private val _devices = MutableStateFlow>(emptyList()) + val devices: StateFlow> = _devices.asStateFlow() + + private val _allDevicesReady = MutableStateFlow(false) + val allDevicesReady = _allDevicesReady.asStateFlow() + + private val _currentGameConfig = MutableStateFlow(GameConfig()) + val currentGameConfig = _currentGameConfig.asStateFlow() + + // State for configuration progress + private val _configurationProgress = MutableStateFlow(null) + val configurationProgress: StateFlow = _configurationProgress.asStateFlow() + + // State for individual device configuration status + private val _deviceConfigStatus = MutableStateFlow>(emptyMap()) + val deviceConfigStatus: StateFlow> = _deviceConfigStatus.asStateFlow() + + private val bleManager = BleManager.getInstance(context) + private val instigatePacketGenerator = InstigatePacketGenerator() + private val eventPacketGenerator = EventPacketGenerator() + private val parameterPacketGenerator = ParametersPacketGenerator() + private val multiDeviceConfigurator = MultiDeviceConfigurator(bleManager) + + private val soundManager = SoundManager(context) + + override fun onCleared() { + soundManager.release() + super.onCleared() + } + + @SuppressLint("MissingPermission") + private val scanCallbackDefault = object : ScanCallback() { + override fun onScanResult(callbackType: Int, result: ScanResult) { + result.scanRecord?.manufacturerSpecificData?.get(0xFFFF)?.let { data -> + if (data.size >= 4 && + data[0] == 0x4B.toByte() && // K + data[1] == 0x54.toByte() && // T + data[2] == 0x61.toByte() && // a + data[3] == 0x67.toByte() // g + ) { + val packet = byteArrayToKTagPacket(data) + val scannedDevice = Device(address = result.device.address) + when (packet) { + is HelloPacket -> { + // Log.d(TAG_BLE_SCAN, "HelloPacket scanned") + scannedDevice.name = packet.deviceName + scannedDevice.deviceType = packet.deviceType + scannedDevice.team = packet.teamId + scannedDevice.deviceState = DeviceState.Configurable + addOrRefreshDevice(scannedDevice) + } + is ConsolePacket -> { + // Log.d(TAG_BLE_SCAN, "ConsolePacket scanned") + } + is EventPacket -> { + // Log.d(TAG_BLE_SCAN, "EventPacket scanned") + } + is InstigateGamePacket -> { + // Log.d(TAG_BLE_SCAN, "InstigateGamePacket scanned") + } + is ParametersPacket -> { + // Log.d(TAG_BLE_SCAN, "ParametersPacket scanned") + } + is StatusPacket -> { + when (packet.systemKState) { + 3 -> scannedDevice.deviceState = DeviceState.Ready + 7 -> scannedDevice.deviceState = DeviceState.Playing + 9 -> scannedDevice.deviceState = DeviceState.WrapUp + } + addOrRefreshDevice(scannedDevice) + } + is TagPacket -> { + // Log.d(TAG_BLE_SCAN, "TagPacket scanned") + } + } + } + } + } + + override fun onScanFailed(errorCode: Int) { + val errorMessage = when (errorCode) { + SCAN_FAILED_ALREADY_STARTED -> "Already started" + SCAN_FAILED_APPLICATION_REGISTRATION_FAILED -> "App registration failed" + SCAN_FAILED_FEATURE_UNSUPPORTED -> "Feature unsupported" + SCAN_FAILED_INTERNAL_ERROR -> "Internal error" + else -> "Unknown error $errorCode" + } + Log.e(TAG_BLE_SCAN, "BLE Scan failed: $errorMessage") + } + } + + private val advertisingCallbackDefault = object : AdvertiseCallback() { + override fun onStartSuccess(settingsInEffect: AdvertiseSettings) { + super.onStartSuccess(settingsInEffect) + Log.i( + TAG_BLE_AD, "Advertisement started successfully with settings: " + + "Mode=${settingsInEffect.mode}, TxPower=${settingsInEffect.txPowerLevel}" + ) + } + + override fun onStartFailure(errorCode: Int) { + super.onStartFailure(errorCode) + val errorMessage = when (errorCode) { + ADVERTISE_FAILED_ALREADY_STARTED -> "Already started" + ADVERTISE_FAILED_DATA_TOO_LARGE -> "Data too large" + ADVERTISE_FAILED_TOO_MANY_ADVERTISERS -> "Too many advertisers" + ADVERTISE_FAILED_INTERNAL_ERROR -> "Internal error" + ADVERTISE_FAILED_FEATURE_UNSUPPORTED -> "Feature unsupported" + else -> "Unknown error $errorCode" + } + Log.e(TAG_BLE_AD, "Failed to start advertising: $errorMessage") + } + } + + private fun addOrRefreshDevice(newDevice: Device) { + val currentDevices = _devices.value.toMutableList() + val index = currentDevices.indexOfFirst { it.address == newDevice.address } + if (index == -1) { + currentDevices += newDevice + } + else { + var oldDevice = currentDevices[index] + newDevice.name = oldDevice.name + newDevice.deviceType = oldDevice.deviceType ?: newDevice.deviceType + newDevice.team = oldDevice.team ?: newDevice.team + newDevice.playerID = oldDevice.playerID ?: newDevice.playerID + newDevice.deviceState = newDevice.deviceState ?: oldDevice.deviceState + currentDevices[index] = newDevice + } + _devices.value = currentDevices + Log.d("AddRefresh", _devices.value.toString()) + _allDevicesReady.value = allDevicesReady() + Log.d("AddRefresh", _allDevicesReady.value.toString()) + } + + private fun updateDevice(newDevice: Device) { + val currentDevices = _devices.value.toMutableList() + val index = currentDevices.indexOfFirst { it.address == newDevice.address } + if (index == -1) { return } + var oldDevice = currentDevices[index] + newDevice.deviceType = newDevice.deviceType ?: oldDevice.deviceType + newDevice.team = newDevice.team ?: oldDevice.team + newDevice.playerID = newDevice.playerID ?: oldDevice.playerID + currentDevices[index] = newDevice + _devices.value = currentDevices + _allDevicesReady.value = allDevicesReady() + } + + fun updateDeviceTeam(deviceAddress: String, newTeam: Int) { + _devices.update { currentList -> + currentList.map { device -> + if (device.address == deviceAddress) { + device.copy(team = newTeam) // Creates a new Device instance + } else { + device + } + } + } + _allDevicesReady.value = allDevicesReady() + } + + fun cycleDeviceTeam(device: Device) { + Log.d("STATEMACHINE", "cycling device team") + var newTeam = device.team ?: -1 + newTeam++ + if (newTeam > 2) { + newTeam = 0 + } + updateDeviceTeam(device.address, newTeam) + } + + private fun allDevicesReady(): Boolean { + if (_devices.value.isEmpty()) { return false } + for (device in _devices.value) { + if (device.deviceState != DeviceState.Ready) { + return false + } + } + return true + } + + fun readyAllDevices() { + val eventPacket = eventPacketGenerator.generatePacket(targetAddress = "FF:FF:FF:FF:FF:FF", eventId = 2) + bleManager.startAdvertising(kTagPacketToByteArray(eventPacket), advertisingCallbackDefault) + bleManager.startScanning(scanCallbackDefault) + } + + fun updateGameConfig(newGameConfig: GameConfig) { + _currentGameConfig.value = newGameConfig + } + + /** + * Initiates the configuration of all devices using the MultiDeviceConfigurator. + */ + fun configureDevices() { + val currentDevicesToConfigure = _devices.value.filter { + // Refine this filter as needed. For example: + // it.deviceState == DeviceState.Configurable || it.needsReconfiguration + true // For now, assuming all devices in the list should be configured + } + val gameCfg = _currentGameConfig.value + + if (currentDevicesToConfigure.isEmpty()) { + Log.i(TAG_STATE_MACHINE, "No devices eligible for configuration.") + _configurationProgress.value = ConfigurationProgress(0, 0, true) + return + } + + // 1. Prepare the list of ParametersPacket (this part is similar to what you had, + // but now it collects all packets for all devices first) + val deviceConfigPackets = currentDevicesToConfigure.mapNotNull { device -> + val teamId = device.team ?: 0 // Default to team 0 if not set + + // Create your ParametersPacket. + // If a device can have multiple configuration packets, generate them all here + // and return a List from this lambda, then use flatMapNotNull. + // For now, assuming one packet per device for simplicity. + parameterPacketGenerator.generatePacket( + targetAddress = device.address, + subtype = 2, // Request Parameter Change + key1 = 1, value1 = teamId, // Key 1 is Team ID + key2 = 4, value2 = gameCfg.maxHealth // Key 2 is Max Health + ) + // If a device for some reason can't be configured (e.g. missing address), + // you could return null here, and mapNotNull will filter it out. + } + + if (deviceConfigPackets.isEmpty() && currentDevicesToConfigure.isNotEmpty()) { + Log.w(TAG_STATE_MACHINE, "Could not generate config packets for any selected device.") + _configurationProgress.value = ConfigurationProgress(0, currentDevicesToConfigure.size, true) + return + } + + Log.i(TAG_STATE_MACHINE, "Starting configuration for ${deviceConfigPackets.size} devices.") + _deviceConfigStatus.value = emptyMap() // Reset status for the new session + _configurationProgress.value = ConfigurationProgress(0, deviceConfigPackets.size, false) + + viewModelScope.launch { + // Optional: Stop general scanning if it might interfere with the + // specific scan/advertise sequence within bleManager.configureDevice() + // Log.d(TAG_STATE_MACHINE, "Stopping general BLE scan for configuration.") + // bleManager.stopScanning() + + // 2. THIS IS THE REPLACEMENT: Call your MultiDeviceConfigurator + val results = multiDeviceConfigurator.configureMultipleDevices( + deviceConfigs = deviceConfigPackets, + onDeviceConfigured = { deviceAddress, success -> + // This callback is invoked by your MultiDeviceConfigurator for each device + Log.i(TAG_STATE_MACHINE, "Device $deviceAddress configured (from callback): $success") + _deviceConfigStatus.update { currentStatus -> + currentStatus + (deviceAddress to success) + } + // You could also update the Device object in _devices if needed: + // _devices.update { list -> + // list.map { if (it.address == deviceAddress) it.copy(isConfigured = success) else it } + // } + }, + onProgressUpdate = { configuredCount, totalCount -> + // This callback is invoked by your MultiDeviceConfigurator on progress + Log.i(TAG_STATE_MACHINE, "Configuration progress (from callback): $configuredCount/$totalCount") + _configurationProgress.value = ConfigurationProgress(configuredCount, totalCount, configuredCount == totalCount) + } + ) + + // 3. Process overall results (optional, as callbacks already update state) + Log.i(TAG_STATE_MACHINE, "All device configurations attempted by MultiDeviceConfigurator. Final Results map: $results") + val allSucceeded = results.values.all { it } + if (allSucceeded) { + Log.i(TAG_STATE_MACHINE, "All devices configured successfully (overall check).") + } else { + Log.w(TAG_STATE_MACHINE, "One or more devices failed to configure (overall check).") + } + + // Optional: Restart general scanning if it was stopped earlier + // Log.d(TAG_STATE_MACHINE, "Restarting general BLE scan after configuration.") + // bleManager.startScanning(scanCallbackDefault) + } + } + + fun nextState() { + soundManager.playDoubleChirp() + when (_appState.value) { + is AppState.TitleScreen -> { + _appState.value = AppState.GameSettings + } + is AppState.GameSettings -> { + _appState.value = AppState.TeamSettings + bleManager.startScanning(scanCallbackDefault) + } + is AppState.TeamSettings -> { + _appState.value = AppState.PregameTimer + val instigatePacket = instigatePacketGenerator.generatePacket( + _currentGameConfig.value.gameLength, + _currentGameConfig.value.pregameLength + ) + bleManager.stopScanning() + bleManager.startAdvertising(kTagPacketToByteArray(instigatePacket), advertisingCallbackDefault) + } + is AppState.PregameTimer -> { + _appState.value = AppState.Countdown + bleManager.stopAdvertising() + } + is AppState.Countdown -> { + _appState.value = AppState.GameTimer + } + is AppState.GameTimer -> { + _appState.value = AppState.GameOver + val gameOverPacket = eventPacketGenerator.generatePacket(targetAddress = "FF:FF:FF:FF:FF:FF", eventId = 4) + bleManager.startAdvertising(kTagPacketToByteArray(gameOverPacket), advertisingCallbackDefault) + } + AppState.GameOver -> { + _appState.value = AppState.GameSettings + val wrapupCompletePacket = eventPacketGenerator.generatePacket(targetAddress = "FF:FF:FF:FF:FF:FF", eventId = 3, eventData = 2) + bleManager.startAdvertising(kTagPacketToByteArray(wrapupCompletePacket), advertisingCallbackDefault) + } + AppState.WrapUp -> { + _appState.value = AppState.GameSettings + } + } + } +} + diff --git a/app/src/main/konfigurator_icon-playstore.png b/app/src/main/konfigurator_icon-playstore.png new file mode 100644 index 0000000000000000000000000000000000000000..5a1964feb930527a8c1d6a0a5c3e6df0a782455e GIT binary patch literal 37575 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�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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/drawable/konfigurator.png b/app/src/main/res/drawable/konfigurator.png new file mode 100644 index 0000000000000000000000000000000000000000..759f86e0e4636598c1ae02002134b044dc2ae489 GIT binary patch literal 37284 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

X~)_niDBbFbj;Ja{3ldGX{E>rQR2XxY|jdTI}q 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 qT~PH$RDp$>p5 + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-anydpi-v26/konfigurator_icon_round.xml b/app/src/main/res/mipmap-anydpi-v26/konfigurator_icon_round.xml new file mode 100644 index 0000000..1be151a --- /dev/null +++ b/app/src/main/res/mipmap-anydpi-v26/konfigurator_icon_round.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/app/src/main/res/mipmap-hdpi/konfigurator_icon.webp b/app/src/main/res/mipmap-hdpi/konfigurator_icon.webp new file mode 100644 index 0000000000000000000000000000000000000000..73f884e9d6ddf405732f4dadae239dfac488aa09 GIT binary patch literal 1374 zcmV-k1)=&*G+!G*e+qScj_1|ymnJLz`ZQHhO+qP}nwr$(SXpLc+`%{uZC!+ro zK>zPds7lrXr%HJvPGn@_*rB7M9Xd8KBH|4=DS1bg-j#@FF(Mx@uM)mEu^b_?1#?ts z4%;M@#q8DNjOB6XA%T`eamVw7Tm%?uUA^AGm`F~ArkzgL0xN0la zkoTm|N51Z9PbiN?m>b;iQvNz}Y_LrCnTm#_BIVofB4f7a0CMbzAtRTk6G_4`Et2HJ zdJ+Ig^&XK7>uK~qbEgj^zmKp&(>f`Fly6qk`Il7roQrgB%qby`x-xrRWYnfS{*-;i zFVcOXx(P~~UKpS>H+bNq@5{K<{$lI<&PVT~4mKzQTAX*-_Ej-JnPyTj>3Pt`;t%>t z=RA~yr)7jvS8{K3MDmQ0zZPT{03a3H{-1OnET#(^V(cIC|HdK`l(rFJWJK~DQIucw zutRBTbkjqIj~XXx4maJ`YUrUf);RAb`9FD{D3YEFl?+fiM*kq?L!y=-cN(D-nYOt} zGG?3EzCM~HV^^n9KoodOo)fhTIUY(=pPwY@JzWw2N}cnOWN1eNl=J=I7|LT*N`;Z+ z$Bt>DpHF$%r~Ci^wyg&QOyisqhKeyEBIbO)1ZIC-2rXD8xGQl&A~HaR7?!ZWL(k zHp(iQOa_I~WHJQQY?~rk$4yxQv4cD&>I!lKfU*%$r>jDs`rW(p093nt_d-=b)Vbme z$p?u2I`N)XDMj-Gf8JZsu%RfDzB??lIMdO)<$p4X1gN*=m zztv#R7}Oz5UGYRC>np|%GC&!k5yvtfYP2M0>!JFQ3@zY)_u|qE>L19kBydNgF?rCY z_9D8Wz+Jc-5rJ>$4$|v#)EmPa~+IAnE0I} z-7l=kUdklp$1TiIN=0vzM?@XqA-|4H1*KGAYb42tN~zH5pX85uqHMii zk)B)40-!WExaMI*@~Te89xg5cfXFs8nDm@3*Gm*c)`dUGsNE%WP^KOe{NGV6`f+C~ zl*#+O@KOHM*N(3v08!>pB>8PtMgag)kqtowhNOeiSo5-n{IfPEv||86!y9hO?|NFH zlmt|ztQ(x9>ta<2eggy!2qk&9h7NHI=pRPP?>d zaMi?4J$8kJbC^KgH_WSqKP>^vA%UDVf2h*GO*tXT7t=88j=h?hdMn!0%xiaSs3A@b gnS`3Qj&AWf+NzSQ36Zdzl1lMPa>CRqtC0Rv0XR97-~a#s literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/konfigurator_icon_foreground.webp b/app/src/main/res/mipmap-hdpi/konfigurator_icon_foreground.webp new file mode 100644 index 0000000000000000000000000000000000000000..22d2f815d830ea6616e5554fa522165601a67730 GIT binary patch literal 2540 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 CG5uBm literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-hdpi/konfigurator_icon_round.webp b/app/src/main/res/mipmap-hdpi/konfigurator_icon_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..b87de75f395154cf2928d578139eddb53d8d5819 GIT binary patch literal 2446 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 C=fb7{ literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-mdpi/konfigurator_icon_foreground.webp b/app/src/main/res/mipmap-mdpi/konfigurator_icon_foreground.webp new file mode 100644 index 0000000000000000000000000000000000000000..557712c233144706985156ef1f99c037a7b13399 GIT binary patch literal 1742 zcmV;<1~K_kNk&G-1^@t8MM6+kP&iDv1^@srYrq;11ufdPP2179h;7?t+qP}nwr$(S zOWBU|V%tt$Y~4FP&OWzrPJXLJ$boFzw5|1R+qP}nk!@tQ&FqEWw(ZD2vTfVAJpsi3 z4J9K>c*im_ZYpTY0{}dv?IwXdY#@Os3D%N3^+?W8-T}zkTowRc)1PGNMs>~rz*c(E z06PKzPEjt!$W9V}0o3-S^(1Zdj9LKjiv?szDN-<$HvqCuH;cm49VG(*59va(G@=2Q z0APDPNm9`gihiX%0AMf0Q-}Pl<3E5VUbBHDO>&r=V@xJVE8V3U0DNOAX;X#NjO8~ADRd)N}fTk1iQioVqW021t`SW1we z4I}`x@tGn?n&)g8h|f6BVv@Aly{ZGicV?0<1xU?kJ^`ra4l7C01}~@&rML1UMW;Ac z1_18SnPf?$DVG6c9AP3wd)OBKcE*9qDf)x10Dwc3O%#RL$bSGGeWOT{COcIYV)NpF zyvr;mNozf+E&%*u8CerUMrQIAKy~+8O_G+lMrDX?r_6z{ttZtH0-AYGfh5gyfgAw5 zVkD`O!BAcRz>y}Cq=Gj!f!G@Ex0()uqiL2CWrTn|458>Cy8!^M(=HJ_1JJ@(6zyXd zh(FR4k`98?Ncu%LG03@81xYG+MLhtxo0Pp(kff=Omx0)--k|6~a1KdY=W%s}fQDYN zktEG_j0Am0(kl0=0kL@(n@uqnib%7ZAu9yzVhBl^EkWg^v06j?9)?i3!d9@GSprfI zTZ=(u_bLi-FDau*A3F(+ zd?z4HvWJ*&Bx?rgbup({CNSHvP-4buDg+816!WWO%_hAe1|9rP(q|e%=}mp6NSf?$ zi0wz31>k;C=91nLc-_7-kaeD!u9tzoeW30xRTc7%ccZ{a(hLcjPkKjSsiGeC2IK*C zo$q|-+e0Mp4Cg!F`L+N68OIw(g9Ij#CP`2Q>3t!o=zCQF=tk0O0A#&Q($A^^(7-Pw z4HlS28V=w=Qtt4%-tHGC)lo{u3ncxbIsiC~O8Ci4gWMrOB?f9KA>(0^ep3UY+lUMi z2&Y7KCEQNZA8J6bqsUO{Q&n6iMbcktLb#Q`$HR1}ByMw(_JP=DBEzIkL0)NlOSuh7 z*o>s-WW==a_jr^F>*T~$@)b$KjQ?KY`w)GmdcbVa|rMmY?Sx0$#VkeqR(?*)K%z9UI%+^Uk2wpLD( zin?nC;ohXB5;T$Yi>7(n(h}FI zBm~s;oDBkxk+jSevJktSKPcMA7LXLykO0uwYc`Uk(e@VuY_FWOKRiJNA7}xw&AhEZ zk`}pG4gfwfF%bkUxC#K<`imqLb=N@*axS;TK5(C&c7fO`ZnTUfZSRknrG{QdqPGvV(Mv~TgLR|p($$T;ri6=RIc>w@> z8A*}~-ql!1dm2H}?{x(L?57lwiezE|KLAv6y=5e6k&EQSH1d`rNgC@g0KhHU6RAlt zw(%c8a~~*>q&~J0$vR&JNm}AMl>y*0<4HrLDGfLS0DBrhlGb}%E$He`lC;qqngYN- z){vh_S(4M8M*wopHHRck^{mw-slS~802io7q%awn!w&$pJ!Tz+7r8_Z0NyZ!6ht~x zf_(tc&2J(_?`Z-6e@P-6k=}IT9)OHf&88_11^}Fq9-FBn2{;(vz%079e+egFUf literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-mdpi/konfigurator_icon_round.webp b/app/src/main/res/mipmap-mdpi/konfigurator_icon_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..add2efb3e8048e8f947bcc10498c9bb644a237d8 GIT binary patch literal 1610 zcmV-Q2DSN8Nk&FO1^@t8MM6+kP&iCB1^@srFTe{BWhhA7fLZ<9-jfg!6Ce-pv65?Bu;hgV%-sgM&1`(32Z8Ie4&&-Idwrz7Y_RP+< zZEI)q0&LGM*l6zyy&l_>8SyG?+qQ9%?griN4HRwLHX~T;rd(~?wr$(CZQHhO+jzF! zwr!P@oTsF^e<1=v+qU5kWCL&=UOO{z+end@@%SD=dWFNId8CqV2plq`aH-%)nqt+e z6-x_4ptwV)G+5@0C*t1u;){3Uo;YKfhT#%)=hq^4{Xi;yxNDKrZa{6|@Ce6RQ2;EH z2n#^eS`MK&4d4-CkT!r3FaUsQ0H7L%HiNohwV16!FhT$Trr6?=GnN?u0DzEz(AG}- z%_%^@B4C3H9{J&$d-fRt00341IMb(GLKsl{K1w>H-C%g(6F2DITB9%}ZW{`glPZT0 zr{fYl>iSxg?oZA56}456>5_gDQQ{(;<&eY~MQo`|Q`A9W;=U;o1K?EK&kW*gjcDQ` zY$sH*-v$a{OIb{DkLk62igN(~Ad^|{F}$!|Ar7_(p`nDX8)<_8fJ=RU(1|~_=LbMh z0KlQNqjchmQQQDP03BSyjb+w=VWBDS1cSJ!KQ{m_O>B|DK>Z{Ez^T4p>BJdr`2j2g z8wnL+DWVV}wQ(LWJhfPU8bHZst(PvyV6A}D%JBk}OeVWcytY? z8vwjUdQ6D0FIC|MC6@(WGKqj=G69gq zO%?`zXeB(FSOFHm84;}j@aW0RT|j*F@B5xd6!OE(=&#PiP)-9t?nUtgMP5 zaw=$^3KGjG4F@2ljM7M}mnO1lt2-cvX96k%z`&Jq**p*UOHf-tM`35Qr9lI~*exX# zcgj!tb3-9Vh3x_4^3rqV1$foDk|rKdLoa##PbUs@LKotU^m4f>Y6~A=AR+#j%y8YM z5TI8!Axgak0|0={K@OIRz7e%aasWCKVlMyy0=!d2h+3a}aDc|rpZHNm0MOcp_@apr z^?le!u?!%-l1iL?-cKtbD!l8#ZZ@@C5Hy7sfc8F=d9Rib*|AAyGZbU9lT8Mdy!6g+ z4nR+~DM|FzLmIJ(0zyQ*2>41wd;g2Mr30XqyFQhM($sm^HK9Q<-!g4yy(b~n1Za~& zD9Yu4??rV6G_hWBDO8h63Pt7N0;fER$|i|QGRkh5Ie={Li>V>N4Vt1kHiBh=pT%?s zXq?LXQpA@^Qvd)cW-r}k19&B3Qyt3a?BLKmqK|LkoX7M9Ah{i)gm_?Ix zi1|(~u!L0wF!0^r^1@2<2m;_whN+wYq%zK324VQia6Z-jKqpKu&6bVr%X=)q_8oaD zlW@8Uo4~U8g?MA3>;NE(6<)Kx(>;U;*rg!FcIr2XJBkW|hlWeeHrqZ)RD8!2>w*A40=-;i(rr|d0w57LHvmc=n}vvHR!ao{1kj_b zdWtC#Q~d)0pyapQGlp9xOD}Gt6neSL5O7*GJ^(=ApIIVw{SM1=1RMnbmukLc5Z`M? z0iY@E6A|LPUi<(6l!FtpsEpE-B(#uNcjp;Gb|^}d%_6UvZkr^f_x$JGQIc{rmsZUK z2mnBn%TkY-E}833F#)@jsG>3BW!ZT8$bN;zyV`qJmro$k)*70 zplalVzhJAx9H(4!&N>4CAPmLdk&~)w%PRRw%+pnd707tNJR^h>rVLz{1xon579Quz z);w}h3;>u!06=WykQUke#_tF%qDY^Sou2xNRDAVxWT!rg>iuphq$MlVXu`-IceIIn zh--6aWRD4&6iTLt{JGFF6spp!pHW5|ZIphRRVkD~Q+2An0mbLjlBG(QE>$wk IryD*X1o7X}ga7~l literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xhdpi/konfigurator_icon.webp b/app/src/main/res/mipmap-xhdpi/konfigurator_icon.webp new file mode 100644 index 0000000000000000000000000000000000000000..c108489975f93ea235c0757095dbf08a9ede802f GIT binary patch literal 1902 zcmV-!2a)(vNk&Fy2LJ$9MM6+kP&iCk2LJ#sU%(d-WhiLdhDrIu-ah~$VgeYIYxE*+ z4nx&#+enhc-M#$N?&`-nD*}$TZN{B<=9`Ia+qTPG*?_T{bEQn5I#se7Tb1p@`SDHw z{cZctM)s)QByFdij%}W6Z5uPYdu-dbZQHibS=-iN&9QB^Gt=h%Dc_{KnMU+~0^rY@ zCI`|Tgusb}#25fpjV6uDHK}0%m=FO4BKExb_2YN7AHUx0i6{UPVL+ElJkq5eU;+db zxk4!(|3ID;x>gD#VFNiKo+#wdW`G9i4v>#W^3jPLpeqD4`ar=I0`#d1NQu(pe}>&= z4pF02jn+Ft8S&R2;}tXbH%8Zp{t02vHIwbHhMPdt1lgcme3-(+=gNL*?9x8!x_-^@ zKXLChsU$mp{kxl_TJ>14e{tSk;2}A%b+$EN?zRDv{d*TF{=+(Vqnjkl9*+Qkh$qTO zvg3zgvVV|=eBMHmoxhKfA(Y4b-bIonk3{){$Oj8a(vx>t01Vo%Ie2J$!J#ZXMD59Itk4a5^k?AtE36_Q;++nXR9BCa2EowZT_oA`awJYp1wZ}y2`ZwyQy6R9H+K> z@pxGPNE4R1NUB@Sw3zJuG!wc~+J`L^djEv9*`p!rUyhdqK;RvvBoCTtBUzLT-JqLJ zQm9tFl@27nQl)Ch{L367;QTg|?IKS^iKJnR`zh@HbvT40{_GLZ^>ex;N-Z(je)3qj zD0Dl8>X8d9(6wB4O4X2gNuu;pljR%1kTojFzW2glIO>Z5P0@vtXjqlW4w1(qG?Afz zkjEo6*A>5-2088ZVK{?9*~yAL{_BF7n#nC> zj+u^;C!#esdpxBtBtZh=7H{49X9xiKuFYGwE*=2@sUOy>-E%cF+Q}VeI!d055s{vq zfdJC#$dX7vx~-LLzF7f~k?$qD=LtH#;n@(A6zu^Q{U1OlqZG@^^oJ zkYy%=g0esZ(xMi!^)?H%=hPeU(R`(Ly{OssWc%$F2oq~G^ZkKMFKIRDx?O=drb?6L z2TCk@$s5Sr5a>o}di+6=Vl2l%WThtC4;1*&I72VGN|WUWP8x{5qmMi_Q75jNWcOf^ zEJlvYdXcv0z2t$>qLf9ip{@;7&u}Cw$DA}?jeF&j|+*xvajv_9rI*Ox)PV z&gpukl8M%n1qp(lUFTY$gekD3W@e@+01%v!nVIf@HAF_pleKN*^~%h&nJh}ujKA0c zDfaz}r>*c+ivRB9VkCOCC&9sdyN!0+bUSCdfd5RCVn`=p)yxan@rWhvLNtR`Z z5|;K;TYZPafHZEkhuXgH0*#zD(;l*Nh{*X?r+|H%vMi#ccN$d+k6tJnIcBCDvVN=x zw(Kn)4cWfr+(01Ykpd5e&F>{kFmljL2gtrh>>?oIu2TZC^9$gUehS?yrdy#Ka$g6T zW2VC-yZ#y{iy)moUjn{6f~d#jry4_)pQ0ghWwdCAoX>?Hek%#$FtjQF{SB%9ueg_!{7okd=f z1IxxKA|UazPOgNr(_8UiFvL>KYfU8CziFBTlL66hb&_P~2QfO3X6{~wfQt9yp=-Ud zfZB>%17LUxkp6Q&Nmf7T6afL_Aw@uc`gSi#_Pi4gALqa_bE}8sK>pis(GdvGc+83=PS^h{E zq#?ibkn|SZ;lvqV0ATt$7fH|dnRix_R9ilZ$64F~>($4+B>PEnVEtsA)g?ga^UV~N z-eiMcf;8ms0n+tZoCH4w*e}l6nPtUU7oh)$fe}D>C`>3oQIiQ>K4+LyfW8dZXrk09 z@~_~dE7dh%<=a9|c!Q8b+wxhc$uZ&%IiBD^9)})G$dy*3(=gXPK#0of|PVsTJ-&$5Ms!%MOr65ibhF#AP3jRw003Qdo(*OVf literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xhdpi/konfigurator_icon_foreground.webp b/app/src/main/res/mipmap-xhdpi/konfigurator_icon_foreground.webp new file mode 100644 index 0000000000000000000000000000000000000000..310ffad92858767fbf8dd2e1937f3ccd31d98e3e GIT binary patch literal 3654 zcmV-M4!QACNk&FK4gdgGMM6+kP&iC64gdfz*T6LpWiWEvHj?!JXSa2d&T@{33E&r6 z&5EM7?OO~>=6yIz9?-CEl)Cu<6W&BbNc3=CkRw}}&ov51I-yhXp( z`Fs(QXxldJ=-eOMPRh1z+qP}nwr!&q+ez6*E4GchCcqkPZOfcy*Ec5IGqRkpDV+tbem zW&yS*YSY_JHelPSZ1elh2_RShU;Y38>`X22MY8404n#Y#G(d~j{xn!RtQ;4WIl}5B zDE)oIJAK!WItGqzsKUEdy2S1b7?~**AC_bi!vUZIClG)|{KtM2uE)X-d;@)~K3a>R z0l+8gm@da)sBh3a8ry?hhjiej0eGz&HJdt~szEMkrT`)$*HV?}pu$BCo3XH20dlm# zt|4uT*Tm8QQp{q!7a|Sz8QJl$ja($%tS%jB!CJ0`GVE82T++7!$S~U!`Dp;^g8n`Wg^)1h zq;p(4q7-Ar(*WQrCXgKYaKtwJ1brTFxr3w!HRBhnyORV&2Q}l+0N^&7sco2AC>``( z-JC+w6mN1EIH0-;YoR|trXXv3iad^KzmrWVUWjy6~ll4hBq7%(hhnk)he zS?WPLsPR(6J#>;lBR^pa67Nx;1B@LF>?R;e@s2neK!IJ%x8UlEYS5Q8PY_A3dxalZ z^&9Rc0ntevcxV9d5M79h9GI9d4LQ~@*O4^nd*y)jd;P;DppX?3=m7t580C?IF5;0L zP3=SC1DbF^F8aJAnSdzWc=>1m@D0;Qi3GU1q!PK3Uj&i#h7n>xE?2geOF(o=7hW0w zJVq~~+cC008gi_0ZX;>PeC0syN9kY?-b<%NHc z^oEIw0Gs*Q0;npHOF*YTRivaZZTOov`tJDQHMYX*s829CL8I2&G;P&HxUSx1oZ0nK@V(4(cpOo&#i$_!o*#{QtH�j9 zxXAQ|Vf?@_+8gdLp-iL2_)uSAERpJACKc^Pra`}`2rNG6FD?V34et5KKw)ehOO4%O zaz=X&ug5{2aZhuA>13*{!qIlBN0|ZCv5msDL{X5-B`px3xZ^$X!2Bz!%@o4A?4){v zWPk)73Wznz9Yon)=Lfm&@w6RWlIikrdlr??WJl&L=>{lvwU)ZBOi~uL!aLmNr>n>lHaHjDTH^~ zPxTZ7qL4(7$)Rm%BXt5ne!tjAJzqS5S5IeAPSHP9D}|$jRL?LX3RbDl7h?rdpY{xLE2&63jbshgRN-g~m!df< zRDrcJst!z_BA6xeDZoZU0i;Y)0~kLclFG+MC#1ZrHZXsf;FV7kwL>1c z@D8w8m*9Cz#Eem>KS{0;L_LAlDcUlP3vgiFj^_Vg(Xhq@aKom^2rO zIARp!XXQFeP{(Zw3hKq66TwW@#C92EqkT@f>Xu}WvT~IzXd;z@(zPcWKroG@uf^t@ z>LX+I^nh^mF;X^SC5fLc=q8(jQaw#Hmf#zb$w+xfIQpFGX;v<<2SWuZ=(Z5SvEF^Ih`i`mcVv3*HJg>$4DT`NXc@%&4$;1;=9bI>cn8bHay^8 z^g(}d5xp)lm`~N6)Wyw| zi74F*ymIex+Yr%tFN%@_pn!3zvv36z`iZI^iPoo|Ye>0Rak*5`7lKH6NDCf048tV~ z30)Rb4Pkb_zqm+yMsto_aI|y+>4Sb&jMnn8X?F4w44UP?)t+<_ID2b^SOj zofeLMqk5fz#|mV6UUz<0q788knPzLo(lH8&UH+sR%>XLf&xBm7)MTN)&B*wgZXA{l z3P*`l?=gWqK9R+MC}56z7$o?Ci%f%lQW6+z_6SF7sXk)_P~T=Q1ELh)sm!4(=}W1| z_=L8+z}j{SuexlYTEYVO^>u*>QNU8q@KW@30~sfKM?A2p*(4lop}M353jl>omdb=E z$b_=`PQ3fX#fyxq{UH2rph; z*iA#OUsYiP98DZx!|xb_)B5uPoB52Cg!I2tc->_`9Z{;u3a|i>$1t~;#koe5VX}h2 zX0!oLBVovR;i#X>1Vm@`=4An(thoYA^2sFGsur;6)6qdBJ+CcCID%rnmO((S)#|YU z9u4j0k`?08rJEoYSoC_I$x@Zs|uvpjxX-JylO>sc4 z#_bmBdY~o%9sm@VBg>bH0gFD*IftaKKU4vFTC4$#S`ebQ z*9oA4`2qwKvQR}90P>n34bgi5pr8;6S*{weS>GlkKBX%U(EDpD18K_K61>)dM?)LA zbVRqjC7uO<8rE>V2>{~Vw%Id0z+ySGWFu*+@d^MveqxyoY0J$el>xw~r;`Lk$93jm z0sQ*w0|310^8t&|hPi>HuH_PdP@;~cFr}RcwE-aBNY@F-wa%j)W&jSb?0DK=!mk+QI-YUWh@Xt(qyCM1$xOAu_wLRIHE`gP|IpA9Z{;u zin=SJz2X*=Hun4!zG|hpD7|2{QA0t zq^Ukq2dAY=$y_xY}K$DNnO9G41_p}8bm~rI*X(OKoQ@_ zA|U!*WmXFKP&Sh8*8&KAH;f`%GB(x!1dc~-pBUNcM_(95%l71@)O z9r6Q!Uw=siL?A-m5KE)r&$swB{>a+f#RR2?@}1b||`kWN4W^OPotG29&_bgfp8 z1GKbPx>ICU9RwwS+Ex<~T{V!8>QUQ}^t2v)KrhV#res;lFkIDvM|(#Ih&HMN01Em{ z00~o!7Z3FKferR#T_j)(FEs#pjdqiO(oIo73&)W#WSPo9j{v99fQW^Wg$?}F0F*XM z79G)5E)pKm8VK`>4P3f_FBJuPxi+#Oi&IAXoxp2= z%T)W+2YOZR@+7OXv0qUDC}FxRL}}g^545ybdQxO~%>*OV06gv&vsD3lyt0HT*`5)G z@JuJhFYH1t*`I^6DnBMlXL5$xOZb2kb0~6(%&d|34wWu(B`2vqU;2_)x|73XWU3?p Y3T4cYQiNk&E<4FCXFMM6+kP&iBx4FCWyU%(d-m48RrzJfwiUP4D#f1voFza=uldH-br(n!Aq@ZkGu66Vw`$8;&)NEH+qP}nwr$%s ze?8l_ZG|zkZ57tVnj+qSlrNyRZQB`1dJE}l+jjTZwr#I%+qP}n-W}U!+qPZR`SRv@ zpJe{Q*7Va>ME@a5vKqEIS&1qe7fA>qA0a3&M&cHbWf3RG*<{JD4e%V8gmNIBu|y1BOV&~Y~dqe1%>g0P12JmNDVDq!f-q|Eq4v=ifa?bTarMk<&~ z(NTk#m!2J>)1(gU7Bu)RT8d~e8!~2+~WH;`+N+6W? zLbMKlCc@l`2-XN>M0p$Vd9oOk%=;FiQZ{NGdl8(3mU9|4@-UrzQl9F1CaiKA)S@6asM9t+eVCC^(=_dZVa zOvC0mwpd3_`~wP=euRzQ2sKP=MJM2VDfW2*O4WToRF5ra)3-Ir#Cc1mvNwZJq4jaV zf+^#U9_-6?pp3Ios?1}<+S3-`CN9h|VNxLJ-%4m{okuZc}JL8AomV>Tv##!&T-bDes$sDCZQpXCol0}3R&|yJZlZQQkv6YIh?5?K|cw1 zlULZOxa|$u!WBPGqnsQRwVVKy!h|Rx zqL4Ea5M6QdJ})AhxqYNDxwJ@3*YZZ%Nk6~~oUG6i!kmtoQtXJqi%`s&1F4kFskcMJ zjM{g!r{^+Y$^*Cc^z`hS(GINei6V=9${+B$VjjV00N`*!06L~S!5u2h6CtYK10EZy zIP!adHoN$nD;~CCoX7)w3W~e|R6rL8PavQ#HQ|01;r`fn+Ye2`pei>N!gnZ*y#o&Q z3J@TjhTN8ueDFy}6#o$zuNeTY*z%TUuyb~mP&!?3e0Q0-Dt8G!bwVAAowt{(iBKdG zFKg@3QL@qN2P7OP6ko-wwmc!KKe$EV3^o{qBTrxo8l`BSO|Zx4|6cKS!d)VYs0IXR zV}x?n1R#@|jj+Xt%;XZ!U>+m{a8@&Fbp#WztKWtS2_rg-sBi*92s}?T=$7E%*oZQt zD&sK%0Oz!$J1haq#!QJSm6z!eg3k93om0?ntWt#Hb%cm=CL)BMC(1ce@RzfVQ9cSA zb5Y9iP_} zOBLXS?^h9?e-~EOPe;kdAzGvO_2V&+sdX~u>@GiZc*h4`xL+a$UyFtY*S#WqTX4Tk zWZtb;!FXAzOwGFn!s>I)oMXO#+m%Tgjp8|8qRoL2_6F};#P1|$p@_BWtpU&jmDIMi z-2nobdn()7s{e9fz41_lRp_=t`U zsK0(lM@L7iyP(f48S)-agxUe6mSG7tJlQv&I;kolAda&VhDg7y@=&&ZA3W!x?F1+C zwI_S^tZ(=yU%Oz$7G-yR;83b%A`?+UU;<|y>>v{nxj#}MTfPd_fOPp8xi{%%Cq_0A zeF)VtC5Yn(rIINYksBohC37xiLb6?P4#xaf_N+z0}u=Hm+_Mua|6f+s|Gj1;)$ zmE^kMRL)f*R}_f>;%6g_=vM!s6fv4i>cAx`@%zd|4c;-zKAD<^7i8WI_vh zD+vpLA!z1vO;K)a+=OaOVb4~|$iAli8yV7ca0zN_&X*lAbJ9anw2;PxD4qPCHIQR-K=@VN5!_4lmoc(&Zo*_Cul@5<~_N{TivI+x;=1EtK@c27Z+?)-gegP3DrQPd`Z10~ler${%k{a|0)4m0DH{>1O;1=iAw<&^<@cQ0_BOdz-W! zPMO+|V^vmU89EZr^tFhemFVCpdbg{OgF^M6(;S$#qzivO7f99bUERs>a@fQVzpv|^ zh-ti86)ysxgxmS@FC*HuV7v0Ha3FYxCnJ?_pJ<3H6lVZ}LKoSqiZjEAZ>pjHdDu^V z)tUGw+%Olu7OrPFTxhv^^c61I>6=KP`CRJ)n9HSc!2dVwo?(Ye`P~oC5^A>enbgBA zF3SWG)oCsva@y%6x-XSk7()79Oe zw(93$My8&*!(aAae6U{cO(c+0aFr+b`{Bt|#dCpEH$tf$^9)Q=7N%2Hsj>)@j8Z2d zb!G=C_ETlOpvJgDC0pa~*7W1a7$IC&%J*4kyH>(0U@XXgUVKP`E~Nqs(n);4;w2itU7dvI438lpcc=BLEZ z1!&5n#b-LtMn#r~O+=Ch%hzJr)rE^T{x(CewN}owjOEc5+ujbIfRgFb+xz8JRIQ~Z z8%?!sMEH2=%k)jSlj*R-kOJt~r;Sq4F$Qn!;ND|INSijFkLPVaGdhTkqG7&vpDrt1 zX42S-(cTeCr>jrqpY!*%t6>#S;DhZlY`Uiey%<-w*o7MxIzq{G|7*nYxPLmZ^JRix zGAai4%h2h9q;$eoe4+Ok>GYR0UAzouXLykP!utM(?Hh`EuwA=O>%5bfe}Tn~j8i%m zxyR$$jg5i&L}KWGYgo@@Ti`kAI%Or?szpXJw$~PlBjO?c5y}E}1|YT1Hm( ztMl6F+U?T!GURK_*SPaFE`7fH)ydBKrlq-);bQ&ys~sK0yd#My1W;1b&@nK+nIhif w@pJorb|U2c%rC(F1td7mjewXGMKQZ`#0~lVEYkiGQgUzSoLzEnXFpm4090_NGynhq literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/konfigurator_icon.webp b/app/src/main/res/mipmap-xxhdpi/konfigurator_icon.webp new file mode 100644 index 0000000000000000000000000000000000000000..7c836f0704e6bf21ac5adb9ed877806df7f04507 GIT binary patch literal 2976 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/konfigurator_icon_foreground.webp b/app/src/main/res/mipmap-xxhdpi/konfigurator_icon_foreground.webp new file mode 100644 index 0000000000000000000000000000000000000000..cefca04464886c6228d952ff9d43a564d82f923a GIT binary patch literal 5380 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 literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxhdpi/konfigurator_icon_round.webp b/app/src/main/res/mipmap-xxhdpi/konfigurator_icon_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..128415f0e6456498c9a7c7d8b8cdea900d341946 GIT binary patch literal 5362 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 Q?w*%l&b!!w)~;<^0HqssH2?qr literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/konfigurator_icon.webp b/app/src/main/res/mipmap-xxxhdpi/konfigurator_icon.webp new file mode 100644 index 0000000000000000000000000000000000000000..16075c02a0a8f11033cf1400e33d241e45ee297e GIT binary patch literal 4544 zcmV;x5kKxyNk&Gv5dZ*JMM6+kP&iDi5dZ)$zrZgLm3YJUe~lXd{~j5^i`3nz(r#s4 z-qhQby0`1rb$54ncXxMR*1g{D`(1Z8pvVBp>((T%ya<`x{CqOZ6EaL-CPL0_ZO0yc z@B4m^ow04(w(9B3%J%#L^>#JW*|t^Lb)4)8u>XIX2oNETM95D>5Y!kq5wR^|B;nQs zH(}ehjY{-DuaNJe(zb0ofxvJG9oxou9Kc z+Kq_W5kp068#{>z4VDm%wrvv;b|GdXGLU22I6%~dCbEptCL$a{fS6+#*Kx6v(1ZrE zly;P`-*sH0BwUOILIYV$n+Vg~gh5=}!3}C6%h^P@j|2kO7zr1Xh@#dbN`!eX5(bIj zFrk4gs7*K)Nf-iwg9IK}6}&*!ag30NpbfrR75qf^h-(BST?|BxRS9F9iybuKeQrFC;noFH|}K ztlr|5MAE{=)?s)RYn>?*XnPFxfpQ!~jpxhZSdV0r{Egu*^Nh}b-<@j(1qab@#!6x_ zoCCZofZ>(>X}B2ZZsl(K@lcsp_2F2Fw(hc*g5llh66rvs$AP|7iG#x1T_=ZSNOOw+ zkukhQp3{d12#%a?HH8+Dv%qx8EP>B|e69?`EBo1aX+V5zfY+7dAlmOOgT+E#thYz( z#PBNCxJ+9TsMbtpsN*5p>?WN!p{=EJEhl4m3q5B5FR1SL5N{~LLskAVM$I?GM!^1 zhF7uIqjE{Wz&S2eui&8Y3a3jKa(qVlje_AV^}2(^KxC>~VMMuJQI3O%ev!{Bq)7UD zT{(ug(np4hfyh)d6*y4Pai&Tqf_z5%i-Ly&UYAD_I$F5eW(tNgyjUy+i1awhXUgnS z7xbKR-?C!@NYdOzw&J1icDHITM5LJHZxt9$#Rk`C14KHxp0t~Si3T|zVQ8m&btHhu z!+usF4x&oSoi0-dkPPsuI)=B%O9t@)k=ZV=l8hlWuL2BFr3L0lC4i`QobLp15S9AU zFdk;t+GRFSFq{EDnjjsBOpNk9n+aC?0~1{0eM9*OAZqCx%gH#1cDh?95;IFOOo1v4 zXKa}ZwFV+RdU@0yjJk@?A}T~%+^h?U0CFM^*^Y-4^UajOys}*>#&9Y&yHOVs5Lr9J z5( zGHjuTs{CRE9|1(^&a;8ZWm!b+PXqXX(3Y;Xk%G~^PJcj@;!WlB5EXh-E)nE)fKSOx zt%ViTZsGwV6BGQQ0;7AICk)~PM3kYSK!6^St#y$W1Q50I8dGa)9ksK7KuKTE+KbV> z$MX)64Ah-g&ajY72T{4NjN~JL4ijKzU2LRwA^{mrvx1D#8}O}>QUR|=H+R@Z57Bma z>OeqOyO>$7&D5sTCF$vH6&Ss;70!|g^m-iTQ)To}(_hB$)78l~X4c16YLn<1U@=B_ zq37k2fWUO;SVN(MsL=Hq^mMV4nf14gs6(xx&{1W+OBYW0R2Z`)E{O_L+zqA4NohhwBZC1 zWjfiv6bx-QTMDRtr>*O37G_F)X}k;&?9_JD$TNnHlCq&VPxyvBaasZ`}ETwA)`7D z1;={3+iFcrg^75Mr;#wFL+qh8mkuJ?dbjE+2E2n@Lwy{FBh_3@>Q@;h7NqL5bGcO% z3{hkfo>OVu#FP%Rm)ePR5z#7F>LkW-Dn|VY94RhWf>Biz=mWGfOz|ff6U=uOjVqYa z;WSPrf@DjKRULj8D8i^Jev%8c+j>?hM!nKxJm*jgJEn95jZ+CBx=uBCoURC?{+pga z+qs#75i*ZjxtUCfG3vkT40vzEGX+mX#t>E5qp?3zB1z1z znGSmBC5xadiJNX8M*VLc0r!cjh)FTbY)-y@+Dj%eCy`v25#=0hA4XO2yRLx$IF+=j zOvO{ZW_K|`9;0o+s49My3v}kIU^Olz#u;WUMpaSQ59mEqDUNBZ!Fhx@M_7SW6+g=Z zx(`&uYMetzs*jPX;#YY<{~&v4$t=P=Ledpb`%4}WIM7ZU(^-SlRm&wnjkLLUi0|r8*C4&F`W>|^tehYw9`qvbR`OLOk)Y0sl-qVual|Jc2hZe4pBm@ zN{Dgdj+hFQ38L1%qDI?{BGGZAfY9S}xT$K-b){R}Z!kdK(o@A{i8M zsGUYcxi<{rQym@?ZK0<4SuPIh>`A56N{l7q3yv8z_b;`x=#$MiT{_^MZ3p$cX_41l zYwe)A-D}$5pfocrr3flEl87&Pm{AKWsGUcmL$SpjI&y$J#{lZ>5vO0S0o41+z(bDx zykZQ|K1T@^Ev=?@5kAFkuQ-?&sQR_jf{GE7wUs1@$erpRm6)9lBH}Bi)XExam*E*? zzLyM>gj9X{x!3>vY%s?VUVS`ixd#m77ev(7EjC&wCgMwu8MU>R+EqL_(zM}4>dn<} z#1O4BmX86loNqIRXq!8A5(}bOo^ZX0&w&}Wx1QSdc(f&>{Y}9H2iz)4b;S<%qcEeo z!FkdI>DBs#DRmN2yM=&uo>qp@RQ&2tv1)1UE=3q^+3$vniTjW#b+M7!oxJpG2qA1wEwL<3)}{Kr5G9PsZqN`r1H_sF#^iZ(FE6%|{10eSDyd4kE<{x9G}4 zN48o1REg0W-sDO-K)2R&OsTJ})L!SOhp3r(mW$~ik}Y$&o_sjc9pf{l7~T7Q=n!5Y z?n$PUXFIj8rO-#z!vkUp9YnH~?lMp+70CdvD#Ylnw8)8?0g+mdFs1koYHPJ2f;7EifY1ylS*!}fc^y+4WGfC*?Dec(L=gGq`${E!gYCn$ z+pXG>fXF11{i+a*D-ddX7|#qe_8%ejqa0NM9(y z@UC*UEMQ7REzPrpLW`)vFUCtFf;@V-#|~P%1dX(xR{VAyNI;<1P|w+e;Vt!wfxN)1 zDAwKGw&5Tu^s1qJ1P~<|=5ysV4g^GFl~8N?TD~X<^yuyu8z>k~*@L^&?Eo=l4<@|nZ=2q5w} z#_uXI@qvISUoocfO$U*HK(D@D7QpbzRys!ps8$mpNq3JZ!a-ExF&&5?%5jaIw&@Ru zhS=p>qxgWx=B~FB!(Hqloj^6436W%ww^ZOD+U^orL=g4&fNp>&(_#ETWU@K_#c(S= zHk1TH2~n~UzE_2VVhhccP6YXQkZ7;SXUZ|WilwGY1=VjhkG zKHDi6-mPxbo&%wW$m!%Jn{bd~w^tm*%OL4auuK((cb^vx;sb^>AtIkcyrGB|kz$Lx zbs;f;&w<`mhT$#uoe9!_K~0IMnHm08NsCCa$Q+rfOVYvhHeq;W|8=fbz_2Do)Yc6) zQ)m$dyzdZ6swKl@e+V<2;hpZ)jRZm-c?|NgG8{zP+@u|eFt0qX+K=Ha^@&5pz{uuB zl5ndzAr(k$Dxl}eVy19|Z zVDG8GL5dwNmrhq#&nd(37JF2860jCTX(suTOpB;e?Py83vYcl<1;ZKekwZkG2AUp8 z+PT6897KCOp%+KP=O|w&!*I$Lm?aa`Nb@7|>gPp!aggj^XUL|~(H*u@FxuhuZqS|s zR)r|Z7+)x*MO5Y!NAiOd6aA?Q!@1AP2J?WL8XAbQoo=B@TBO+O76Uw`5W^YplS$G* z%?%Yq9o=LTnFf(!FX9ZZcZn9DCWj94$n&xiTHIyqz9e9ch`h#HK%Zi%wbcY<_ahM|WfZCq+C1w%!i&`S)g z8IjjO&syUf$4Nsb8Ip*6ddNVgX(%!gQ#B4UO&Eo0tAZNLXsR~?(#Szi{IDwcgP~0^ z10X~aIVi(Zt0KKai!f4-0T4%i6i2NJE=21RhCo3S3yIKVJ)$JRYLubS2yOy7C`DU5 zA=Fuq29n;QLnCq%t^p7sgL1UOA|f03}h>%7BD$yC;{e3)ZrS}rDjE?ldv))B_bVg-39zkFP8zB75NtdM0(toKI4X6+Cwp8cDrOTcz{=qJKp=%5!VI&YDW=I5xkU}2H&`(gpX=K7(S}+?2#jI7h$CGWtw%@nKwp19f8U6| zzXgmq5%hB#>Z5gW#1Ys=L70fwp%l&07M;))z0eo^F#rQYd@PPWk!T&-qIo0okxn2q zjO{uJq>zgul%oaOpj`txp>xQuYe2g=T128vwF$>X%($+D2uWm+7i~m2nxT0-*ML@c1=IIe5gT-O5H|JOzKzHGJt literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/konfigurator_icon_foreground.webp b/app/src/main/res/mipmap-xxxhdpi/konfigurator_icon_foreground.webp new file mode 100644 index 0000000000000000000000000000000000000000..f062fddc658e08d67d6ce1bb76bd236289eb5332 GIT binary patch literal 7804 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 Ozuf=j{xA1`Ii~@U&(gpE literal 0 HcmV?d00001 diff --git a/app/src/main/res/mipmap-xxxhdpi/konfigurator_icon_round.webp b/app/src/main/res/mipmap-xxxhdpi/konfigurator_icon_round.webp new file mode 100644 index 0000000000000000000000000000000000000000..a4c6f5407abe74ea2e6763c02c384a8af4dc2da5 GIT binary patch literal 8102 zcmV;XA6ej1Nk&GV9{>PXMM6+kP&iDI9{>O^zrZgL)rNw$ZKQ-h?frKEB4PrlIt??# zQlcsUbnH!sJja|2%YqxW6hQikEhQGLC|Mk+6cZ=0?GOJyRZjc=dz>T-M6ecjcb9sB zy1TpKZuJ(|dU2=j?(K^gR`(WncL^>fye-)?^PD;P^DW^88wgFBc^}-igrG@aA%rGS zwvC_wNwR6%dS@SB+qQk5t#8}5ZQHhO+qP}nxMsqFBq^#?z=|B>`IrIG{rA7^|6fS* z|6TV){{O#u9*NX9{2UX-_!bX6jPD|JYS~K5Au6BcBwr$(C zUuWC4ZQHi(yV>?ZV%tWN6!*+z9LIg4x@WK6cffyBa0ns5x{r-7`u%lYJN=x9hS+Jl zwC-o7w%IxCAuM@OFaVJQ;eZF;1bqK{x<)DBF7vaiP11GW1Rfw2HCT>qa5S#MLwFe< z<46315sYIB)1Z^$=ReEwzuo=4{#U=*3OrB;Ky6`6-*p0yh8SjY5bxu+XeHo^`kx%! z5RLjCDD=&`X7sP!zAb62>(Zq?2#dy~m5bK9^5sah2fw<(W4rb)a`i{w?T3gf)44{w zb`dhZG&(GdzD$xrEtqE!;%$95^(=RFj}#^kf(&Qo@Q4v_t$3kVplabQHD|v*Gta_T zueZ`6rHWfFQ-ppsSy^G>5^;vqm9MMSJI99|w0eE@hrnxFpC0pSv|gJafcW6Ly9dje zk0RWoW%!r|fmv6Z4^)bI>FPsFD}!CK)UWty4}Y|6t{w) zN=A@=9^|C()F<;tk^hjK2YJ6b*b|quPLy{AL3bGGsR~GyAz&S&TK}yp5PxfZ33_VP zDxD>rA6mcUq-#38N2LRTz`Q0vnz2>O*PBZ;OLx+=8kf6oe4IYI)K z;S%|^Toh4BNuCU-#KwjiT>WD)8{U(i8kt^0qx@o;_g%jqE!B`7DH55oGGVRslFcVIn?NZn+7CA?!UQ^bXS z=nO~YZgDL(b{HLXIF_Vp5X{_e5h?DEFfx~HVz!D6|3`vwV zNGz|hi`uK%b+ul2JM)ur+)4Eq#43h*rvp9sRbudTg`RvBC6j5|%ERvxM+pzQLFBq`6t$#tfX;<{wS%-5pK? z0{Zc<6ie5hQh7h)UCueWIfDlQwe+aTIFaC<&f-Oq6^#EdU%C$oKnC8DQYfsXhG+j$PixK+;gC(o{&ue(clvdbugZ4ru+I<$&1 zd@sIqcd5@r@O8<*lpL4R&dGQ?ysNWfTu4~pC)7wR;|M^28-;_b6Fp-FUafIj%gl{D z)4qfbM&WEDVx$LUpb_`D17UfaayqbyZ*wo$+TCL~UTnS(ok?z&BJc#AaLi$Ia}QSu z5{x8DVLNGy5C;nJnc&jHO}@ozy&?{l5u{{0i_`VM>zT*ArG$7y7x)t84yPm#;A}CC z6Lykk@vd3y2o3qxlJ7L>)G$meXZLqMDTg>g?So4Zgh)!mEDQ=sOs0X+Opf!`%HQO} zjoTvn+b!Z1Jf&s+tUNDb0x^UoQUp32cHAeDmRLFcm>f4*dwIB^Tk>6WrLnS!m*z&^ zwfN5Q1)jYb@r}zQB$R~5oDPSKG;APHCxH{aW;<8Y1d)f6G~u-jvU!yiB~8~yMagKW zdzVQaLvc0lrsDRARKYe9lI#v7@iKjx(nH4K87YHRaV&b%e5J4WY9(u~u*BT_mXhq` zO8LEHHj}3S8VDCy;7z0>gg{v1+p#@)8Cu%^FT#n9^{DVTa?^5#w{0*@9rinHHci`9 z56g~R$=!KAwg9ivU}YsoUtk{uhzT!|hPR1Q_N`v)&1Ad3K6E;=eH-blZyX;ci>j;`JRvzjKqnY1w#tr`Q4!qLic>nSfJbxg33?r12(pe{e`O}L2iQWDV(pTMNA5hF?oYdZRBA= zZZ1!AbQWIQ)JaNQq7}xmiinVq5L`%+a?|r^Xl|&2t;qN}m^FTL> zmhy(LhADs|1lNUx2;`$2-%+?&5Q9nD%R;0FzREOB8gAO6Jc9V`0(1i_t;g*X20x*J zF2osvok^u{q;HUd-g73pQ52ZX!$$Ez#-bgQ;^I0fh+N6j<@Sd%Ar;0!2vZ9qut(t$ zlH>|>hY?ZF-vS-Ea{NY=2rLj|wQ`YxNIPX)S5;Dq>au7ff(fNCp4o%IPFldvj|l$30G85Lqny}Z(WV@?rlXHcD4mAWe1?>| z>up;CiRN$%lTj-9Sa-98C<6Z_L|B-@@rXo`))B+~M2o!x9e-p*ps;nMd$GTp&@EzD zrNod<^L%X`;PZEPENH8Eid5Mdf*O2Jqziqgo~#dDWSVXxS=%4N-{svlb@nxDD3Fm zM3`N%38zv=YhIuy6Gd`4bv75%&U?%X8IMP+8;-47-&BmExKswxF;qT^=y3^R{23Vt zhaiC`siS2t5kw_%i`AQThCyGxGG#c6;@+lzLK-?)MJZ@VWUxcW5P2!$Dqcn!-*$02 zQTGRxSLpbiWASchbl~g-bT*Gwv7jRCN|H;cIKit9W%Pj14;{I zQqVX$2FZ;^n2N@xh;HKLL~X)>zeUIDo&39bkssBtLSM;C0?Hs~ zPpy$5e3cQ85~k46Uv@xU#T`gE5%54dULf-h{cj)}%C9k|pK`)^*Yh?V>D+ZR?1rof z{qA&dCr&eMR@H}ftMeu{aZ@pLH5r})@GxLdj_=95N8bi5p|vJ4z1=Jk4Rd(yDW=Y~ z;DR}1*wtpeVjAj9t~eII-a-#zbGGSpd}l8inovb?3T6w;#Q-_^0}Q*DgrAu1&LK<+ z4u-kXUnzFQU~fA!m?n*Lc+>HPE#zbd2;Q`bT@pMvfk#yz(J@?3RLsS;iIPxzb204n zl9+K19WlFGZzKNsP_Uv_)D*5n5+OEs>_;E0*H3>PAr~@cCxUoth|!PUagIpE;uzmB zS-gXoye3SMJ+qH+=p1ks{aKHv63jyg|XHC??<#;A10s3>}L*Ou(2*bq-2jwz>!w z?~@K+QMZx>mS8(5@STx7f=u8w7z43G_~w#E<{UZVV9LUTe~hFlGNmyls9nUBB5{-XjD%h+Mv?=L7&MYbgqh@0is-Jl zi^Yee!w{CUxkJPSBSumm9Z~CBU5m*_q{9eSUB8FLVTwD(jie4?`XO_*xr~Hytg(JQ z1FTeF%t#(&7*}EPG3jjg#m?Xk2{#NI$YS>~jNc7qEmmK?hsB|VbC7}fxQ8$U(W3Hxm4aUN+!bi13k-R6|DN{G8sh^>)8~6v_!TQt#sn zG%r8G0!#}wUNex*RnYBT&GCMu?;1^an|KIRw%JJVK1!D(#$*a>sgYD7(r-FNf2KZq z3s-!$`!Le(#Y>wh7@x?ofqcSEbUdV!MGkosbi7hZT1zIh0ukc2jHi!|wm*_bWF7Q= zQ)Dt*l1j{ryD*IicmNh;lluh}m^hQpMZVPEFyl-!!))Klgvuz2K1yO| zS~SBf@{(0FCOJe7Vc2sA#XlfH$0GbkUacThbllSHYm4Z(UpyNa<9@$$o&#pp9V_EG zM5fw8UdR7f=M335u!7J)Bfch6*=E6Uzql4Mh!h@oP3$j*g83TfMojNfGwJDy$aH6* zt4(w@Ag=Sk@5Bie#dwB1a8}hK){K%DiTOTpp&+H0bTF6BJ&JiYlY821y1kj>Bbjj8 z)EoUocU3wHq~YyMM3ySNfr_y@ZTbab%TS0b$<*LO*X|ZTV6nk!<64BSPH-)qD@vo7 z{&M==xmq3^0ruZour?lJcrUmKVr*1U(E3c1%uCag712OFdz2Oao|${`&S9EZ)l8Y|9%HFG*9*j!qMOrOH) zk$eQd3u$L6n`zo+ zs3Q$&cj~#i@oUIq<2ouLOy?6hO*&Lcq2_Q8(HSWSvq6A3a!`y@sTuX@XK7J&n1|bJ zv+3-|w-um~LMn|+#dwZV4|DDvRqs%9*bE1#lNvoDII5UZ6 zdO<;gB32AKB&gY3r zeBqynp-nM7hX~^wkCdY|3wyBdAw2AeAqz!VjNfUCmUPT@5z2L}X)KfCCi*=u3krd` zJSvhlzw<-+1&T0QF|?(05pjgEusZ^H8AwAus_-~XXj}U3-IYlCuek1LQ)VZtD?1JU zEx8AcVveh^AKzg^|zMu{=pVVYEy&S4+ipZnrvAdVcAU@`6CPiOk0tVPjWU_M<;N4g&) z271!r_;khNS=-$_Ch6pU9ypk z_L^hd;#0KSamJD|`df+(OlFebJ8-ep2PM4YOz{cWHT5iK{0^eBp&&nS?A1N4gjFcL32R;xuQOS0 zsL})sldSf5qvGy)gd4h>i$&56`ehBVUvT?bW)#>n=|OSdlUCs%B#0h@e+%c0yj244 zcYC6qj%lDNa~ zyrUWJE-8?YJTjB!#5dmS|( z%!A2a8A^;TQtV0+Y;lrz@hrX>o|2b_97(Di)|=3;@*})I2H&|JxwUhVUnkR;9Cx@Z zFEo?Oj)RZ_etECCh=pMx+=iEF#@B{x^|lbF(nxh>ME~(0Y+)iDFY_alfpoh%%Duu} zP-D3?!t1`+CTJ@>j@V(<-a*S8cA1)37}^}Q*d5a}>-~F06TCOe7U=C#0&nh~?@J3< z@d7{g4`6*CzJxq7qKUZ~*C-49^Af~EO0-PTctOQ7N@@10J;Myf8 z2_#33QOgKcgQ-@7lYRM}<(@7=t`!&44cG7-<}PG&EY$JpkK;=&v6auzM=ge1@{FHs6xcQqxdvl;S#=#>P38NwytcMSs{JqZFkG zk;T>dl->uLa3}o{iso2%Sk3!jNruR{=Gk~o#tM<63Q5wmD{2NW;ZbR^ln%GZW z&Ye|(>?7}WL0=HRB-t0I4|?YD>2z) z@`_VdkVl(}%L%fzWT9+iqVy0t@wV7^W8&fVGZq`Knf)4&?(8Y-9f{kGdfz!LloEh( zE$=X002`jV&_bCY7d6q?R&*AUy9<0`0nRptxW^jVk;HEBlL%hy8`lwhZ=}#NMk%T$ z%$8qWMEAhEpke15Lupc~Z4l0JhlbxO8JQ7_!`xaCW7Kg_{Nr=h;UV(lo6b4RXXpUf zp}@#n)--0au5QB{w=+>vJkm(zKHM>o8J<>@DnKz`d zz(-245Uq8m(QI7PfufaY<~j&U#J)Y^RiMI6w_!QHm*JI%i$!oM`Iw-wgBk(6oTHby zcpG`iiQFkELH-f4O`l_*9`P!QLV!lJxa=xvDq#xS$Ky3&-?>5pWHM=iSIhR5n;exi z$wh{(+5i;-#d-dEr?e!LZ9|*OX-bY)IdD(MLa#fC3z`{I-WWFCMk-4}Nec4cS{-iz zeK=W3UvLm_f!OC>zsPV0F4WT;yiV1+bTou-<-Ln%GY3AYAUASClC0%;v_&%5NlFv5 zAECiZ(SUHR++4f`tYief?_H(1Qj!9bTJD0nXH1>FC@~2l45e|L zc=k#I+6M$4F%IXl&eB0)kqi>L-p_u)X&!&Qob`}~90~HKLduH*&zZU^VX@4DaRuGBKHu|pf%QTRdPho{$G z=X1PH)%(uiml#vY7~C-v?q}!(ja_N7<6^Y!jh{$v8K?t9F_7y<_*tTlOyzF<#B%ze z&17eBrgw2v&4y2$$BU8~q{U8+B1CY;<-g@BImtkP1{X2<-&{At&+;;ra#K(TYi;Z? z)-SX+j*at)#@hVUyu@5-wbOy3{js6WIOVUB1stFsCusZ4brbCeCG(#wMV{&vA|Jk= zs+|nv{wpReO?GM&Pmbq8IWc#d_7mX?Cl{Hpx2B{$(ifg zSAv6!wy}*6qbRO0WRgGUSg{6-U8-wR`DdpfKq0Zm7^{>2zD=SCE~U%uV_V zH5VD7j#Q+luI0WRl7phY9nTQKxDS8f8*s5hJvyA0ZkLO-A;6T}M3uq)x_ek58p)}J zmO*Q?V+1xR+Rw&o=W37wZNNr|9LP8ZJ4fE?_rCd+o5Up7N*LGjU*6mKkpW8QTbJ#j z2SZF4@K9i3ixeG*gE|h@E*a9glJ8rmwG7+)9H%(Tn~&2@B%FT1|9Eha0pRaZW)9*Q z>^ym{-?d44E%`4mt)eIg4fpT?t}Fdh2!edA<_I0`JVl>5sAINPOG{Ke zympEXgM&IoJ6CSVm@B9(#Yt}21t#w1Y5Tal`g{1ZQqzVaQ38X;j?t=;hcfOam6Ij% z$f_~%5*Vdo8`D?H{7VC_$mbjx8j#pAIHsoD{^?#_7a#APX#G>}q?zg(Ugl55`V80p zHE|3RJ|g63mkts+MmtYVONV#OKk81U54L3n<&9@^=6yLMqX#YLfeH|9w;jRj%vSjeMrKo_rDlvU)rks;6pSrA6 z6v-R*c6sgd_r;oRM>-~zb%9Z(w?}#AKB_9&tlCIXq6P5~B`>SUS}Rw7OP|jcdKtc3 z^ZGlm)>*|RZ{so{c>wA9WwO#uJdx9 zJ!f|Ir(;&N=njImNcZ2zdgJPsRa*iEJjAh*BUHo?xa%0>C^BYQa_?KE)*NfSeN?V$ zuW271*1pqz)PB|e(EeQhinpWR^5#pf*hf0n+_@cD@^H+?M3IA)%PA53e@OG#?b4VBZB#Da!JEtJ472tAPQZDOd*Pc;kF3V%j7oi9XIv!xTP3B zeJvms;32lgjUT7MarKzDZ~IB}lBVfMK{;KTll`qdf2@v!(~riuHN7wVnc6^jN}a>> z3Z-%0)lZuN+~aYzTJ?HLcRW4^n^S#vZhT#*hmNP_!_*GKQ}Rgfhr_gWy?%|y4G+fS zuj{onJsj>Hty}YBYLL{^YO*X_EEXLP7K=reWybA&Nn5*0uALWsg|bD+^SmN!0Y`qL AGynhq literal 0 HcmV?d00001 diff --git a/app/src/main/res/raw/double_chirp.wav b/app/src/main/res/raw/double_chirp.wav new file mode 100644 index 0000000000000000000000000000000000000000..1f543fe16de3abb84e85efb31d3987de3bb67fda GIT binary patch literal 17684 zcmZwO1ymc`7clxHXpn>$NpJ}k+}*vDLh+VTq3*qPcei`%w}!Nowm^%!ySpT42m}Zk z+-LHgKdJ`GSbh{!As^A4R!s)+0Lx$9zA)qXs)lZA%Kif3v3E-hYYM z{q;z(mHlvN@A$6|yupUxLvGJ%PDGXp1?)xY%%uz^Tu`aq$G}C#C>I>H7~Cbb_VDw` z#yWRQi1?`W$0L22TNi!Adrp6>8NDBT)U%}Z{HM9;quZ~$7Bw1t&X`jU&2mX=)clN| zo!+M4{<-z9Phu1If_82G)?M;(g01TN#b1LP^2xj{(e*}X(279RVkyF`ZO=TW_lIJt zp;Fi0N)1GIdW?_Yww*M`-sY@NWRAy{>>#tb)X2M~D5K(VX_=eJ5%=^t@=#KgNcgamcP*k=^WVZuL{eXG0mIj=9>^+woV z;x7_P=5#>AAAuZSn*mnJ)EZPUN#w#IH>P#6{e0EPE`6a3l|1`+3LISC}urv zf*8H?qRaMyvyoqm2Wap1j9CP{{qJ*>=GInj|>=2)eWY(Ko4d^Gp89*%a*MvLC?eYd?u;dt%ksN{ka z%pw1jkY<_cs?$*mg@>``{=AUuauT)OQQSONu{9rJ=x^2iEkR%C8Jqac9ur|X`sZ1X zW1WA+PMO#k?9#CxoE=JJ#{_iV*8Drv+vhI{?P6qfTk(v9hEH^;3Vln@r`WNCma$wj z)tyN9aYSHFMznb42iz;)neBFTt3ItCRdG5Te|?!9ge|8qspW_-k=b{kJ}0}K<#vwC zu^I2aSXJpu5w=L|$TKt={q+07H(YCq>~nwfZMU^3Y?Jt;?-!X@l{N*A2NN}}vu5Hr z-+LLbf=obXNEBU#6a7mp_DZuF`L~ZtXo9f`&noTCSG9^#(W7oQVRa7Ei0?(~U)Y&# za}H*Kp__d2DAMhFe(a3P?R1rQ-+FAjy2+PW<1Fj1#|s{=wOf^k-t>+nXS84cY4>xv zEkt_H=E=}QwiXD9Qu`QGYR$+gP3gde;4=Na)8Dh=zwXRcpMPQWDnvWrnT841HqAcf zeWBgTvZ?R3e!niYO(R}uyJC_GkV}Eaav?tgQt6i_Q?m?Wkl7KF`{-%`yF-qecC7v^ z`RAKSQf05HjFQ*(&~@icSjD#P_`>hL)vBl!OQmgZ{cNu|{X5N5stWo^=SKQP3bAop**MkKELi9tH_m;i*-kCsZ zVTh{Q91D^1x71r%VwRzQI3`pzS_?&4tOZF1wi!R*Kdr5cv-oLLS-5gRFUaq9$hciQ z=2<5?#W{9!PXDlz+(-AOZC^K+(k!RVidVnO{Yq<~A*GF9_&*OGvkk@Obcd!Li#?OE z)OP?MYhMyPl%>Z}=} zw-smDi_~q2N;>o1FFU#a25!oxH*g~0jMYO-aGzt=-`~l}J_+Q_2<6_ZA-S%0# ze<&rn*RL#P(IVY11k3uy8h=J>_Oi2Ae-!_Ys=hVbp&;X|5G3rMXZ4hDW+b-wSNvRD zL}4gr7JJQHYioK?o!c!np|zf7k+kw3*(u?T1xunTVlFv>3_ll}U1Y&YtIGc0u|MOo zf|$n0RIO_s$AixJ&Y7p;O-E7X?!Oh{4rM=QK1T#=in=obZ*Nt${!NzSxz%h-j`~@X z=Fvo6T$J~zjHwP9;US`urGH>MtV&ub@DCAH3Btb#Pv! zWju3xeCBWS;v=j#0vHVw=T*O>{*f;3TGxeN3`mq6Ptu6jPXD`3dU8oB)9{<;<$z

OtpjAdz+_9mso-%d-fW{xn? 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 M_=Y)I<0BCN2do*H=l}o! literal 0 HcmV?d00001 diff --git a/app/src/main/res/values/konfigurator_icon_background.xml b/app/src/main/res/values/konfigurator_icon_background.xml new file mode 100644 index 0000000..11b27bf --- /dev/null +++ b/app/src/main/res/values/konfigurator_icon_background.xml @@ -0,0 +1,4 @@ + + + #000000 + \ No newline at end of file diff --git a/konfigurator.png b/konfigurator.png new file mode 100644 index 0000000000000000000000000000000000000000..759f86e0e4636598c1ae02002134b044dc2ae489 GIT binary patch literal 37284 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

X~)_niDBbFbj;Ja{3ldGX{E>rQR2XxY|jdTI}q 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 qT~PH$RDp$>p5