android: add gradle jvm properties file

no idea why this is the first time it showed up, but it's supposed to be checked out, so...

README.md

@@ -1,8 +1,8 @@
->[!IMPORTANT]
-Development paused due to lack of time until June 2026 (JEE Advanced). PRs and issues might not be responded to until then.
-
----
-
+> [!WARNING]
+> librepods.org is not an official website of the LibrePods project. It inaccurately claims to be the official website of the project by claiming copyrights and using the LibrePods logo in the footer. And at the same time, they say that the project is not affiliated with the LibrePods project or its developers.
+> 
+> Please report any other such websites to [me@kavish.xyz](mailto:me@kavish.xyz)
+ 
 <picture>
   <source media="(prefers-color-scheme: dark)" srcset="./imgs/banner-dark.png" />
   <source media="(prefers-color-scheme: light)" srcset="./imgs/banner.png" />
@@ -224,11 +224,11 @@ A huge thank you to everyone supporting the project!
 
 # Star History
 
-<a href="https://www.star-history.com/#kavishdevar/librepods&type=date&legend=top-left">
+<a href="https://www.star-history.com/?repos=librepods-org%2Flibrepods&type=date&legend=top-left">
  <picture>
-   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/svg?repos=kavishdevar/librepods&type=date&theme=dark&legend=top-left" />
-   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/svg?repos=kavishdevar/librepods&type=date&legend=top-left" />
-   <img alt="Star History Chart" src="https://api.star-history.com/svg?repos=kavishdevar/librepods&type=date&legend=top-left" />
+   <source media="(prefers-color-scheme: dark)" srcset="https://api.star-history.com/chart?repos=librepods-org/librepods&type=date&theme=dark&legend=top-left&sealed_token=CS9QF2Wcx-_EN6M7lBhwvTa2WBd5eB8FbQa5FWt3SV14v1OcQdy2aCGsXxHoytVaoylP_pTxj1h2U-odoXDV_EwTqMxM-MQwG_WpvV_1g_yH-Jh3ux2BuWCmS98LxLqfox2ibLOlFDHu_-geTLFsTmqTc1SjX6-NYxVHXF5DaqnxFOAyjLPL5_WtXVew" />
+   <source media="(prefers-color-scheme: light)" srcset="https://api.star-history.com/chart?repos=librepods-org/librepods&type=date&legend=top-left&sealed_token=CS9QF2Wcx-_EN6M7lBhwvTa2WBd5eB8FbQa5FWt3SV14v1OcQdy2aCGsXxHoytVaoylP_pTxj1h2U-odoXDV_EwTqMxM-MQwG_WpvV_1g_yH-Jh3ux2BuWCmS98LxLqfox2ibLOlFDHu_-geTLFsTmqTc1SjX6-NYxVHXF5DaqnxFOAyjLPL5_WtXVew" />
+   <img alt="Star History Chart" src="https://api.star-history.com/chart?repos=librepods-org/librepods&type=date&legend=top-left&sealed_token=CS9QF2Wcx-_EN6M7lBhwvTa2WBd5eB8FbQa5FWt3SV14v1OcQdy2aCGsXxHoytVaoylP_pTxj1h2U-odoXDV_EwTqMxM-MQwG_WpvV_1g_yH-Jh3ux2BuWCmS98LxLqfox2ibLOlFDHu_-geTLFsTmqTc1SjX6-NYxVHXF5DaqnxFOAyjLPL5_WtXVew" />
  </picture>
 </a>
 
@@ -250,4 +250,12 @@ GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
-All trademarks, logos, and brand names are the property of their respective owners. Use of them does not imply any affiliation with or endorsement by them. All AirPods images, symbols, and the SF Pro font are the property of Apple Inc.
+# Trademark Notice
+
+The GPL does not grant any rights to use the LibrePods name, logo, or branding. The LibrePods name and logo may not be used for software, websites, domains, products, services, or other projects in a manner that suggests affiliation with, endorsement by, or association with the official LibrePods project without prior permission.
+
+If you see any misuse of the LibrePods name or logo, please report it to [me@kavish.xyz](mailto:me@kavish.xyz).
+
+The SF Pro font used in the Android app is the property of Apple Inc.. This will be removed in future versions of the app and replaced with an open alternative soon.
+
+AirPods, AirPods Pro, AirPods Max, and the AirPods logo are trademarks of Apple Inc. The LibrePods project is not affiliated with or endorsed by Apple Inc. in any way.

android/app/build.gradle.kts

@@ -1,11 +1,15 @@
 import java.util.Properties
 
-val appVersionName = "0.2.9"
+val appVersionName = "1.0.0-rc2"
 
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
     alias(libs.plugins.aboutLibraries)
+    alias(libs.plugins.ksp)
+    alias(libs.plugins.kotlin.serialization)
+    alias(libs.plugins.room3)
+    alias(libs.plugins.protobuf)
 //    alias(libs.plugins.hilt)
     id("kotlin-parcelize")
 }
@@ -24,6 +28,38 @@ val releaseSigningAvailable = listOf(
     "RELEASE_KEY_PASSWORD"
 ).all { props[it]?.toString()?.isNotBlank() == true }
 
+room3 {
+    schemaDirectory("$projectDir/schemas")
+}
+
+protobuf {
+    protoc {
+        artifact = libs.protobuf.protoc.get().toString()
+    }
+
+    generateProtoTasks {
+        all().forEach { task ->
+            task.builtins {
+                create("java")
+                create("kotlin")
+            }
+        }
+    }
+}
+
+kotlin {
+    compilerOptions {
+        optIn.addAll(
+            "androidx.compose.material3.ExperimentalMaterial3ExpressiveApi",
+            "kotlin.uuid.ExperimentalUuidApi",
+            "kotlinx.coroutines.FlowPreview",
+            "kotlinx.serialization.ExperimentalSerializationApi",
+            "kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi"
+        )
+    }
+}
+
 android {
     signingConfigs {
         if (releaseSigningAvailable) {
@@ -41,7 +77,7 @@ android {
     defaultConfig {
         applicationId = "me.kavishdevar.librepods"
         targetSdk = 37
-        versionCode = 55
+        versionCode = 85
         versionName = appVersionName
     }
     buildTypes {
@@ -118,6 +154,7 @@ dependencies {
     implementation(platform(libs.androidx.compose.bom))
     implementation(libs.accompanist.permissions)
     implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.foundation.layout)
     implementation(libs.androidx.lifecycle.process)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
@@ -131,12 +168,11 @@ dependencies {
     implementation(libs.haze)
     implementation(libs.haze.materials)
     implementation(libs.androidx.dynamicanimation)
-    implementation(libs.androidx.compose.ui)
     implementation(libs.androidx.compose.material.icons.core)
     implementation(libs.billing)
     debugImplementation(libs.androidx.compose.ui.tooling)
     implementation(libs.androidx.compose.foundation.layout)
-    implementation(libs.aboutlibraries)
+    implementation(libs.aboutlibraries.compose)
     implementation(libs.aboutlibraries.compose.m3)
     implementation(libs.backdrop)
 //    implementation(libs.hilt)
@@ -145,6 +181,16 @@ dependencies {
     implementation(libs.libxposed.service)
     implementation(libs.play.review)
     implementation(libs.play.review.ktx)
+    implementation(libs.androidx.navigation3.ui)
+    implementation(libs.androidx.navigation3.runtime)
+    implementation(libs.androidx.lifecycle.viewmodel.navigation3)
+    implementation(libs.androidx.navigationevent)
+    implementation(libs.androidx.room3.runtime)
+    ksp(libs.androidx.room3.compiler)
+    implementation(libs.kotlinx.serialization.cbor)
+    implementation(libs.protobuf.kotlin)
+//    compileOnly(files("../../../framework-classes.jar"))
+    implementation(libs.androidx.healthconnect.client)
 }
 
 aboutLibraries {
@@ -165,6 +211,7 @@ fun registerRootModuleZipTask(
     flavor: String,
     buildType: String
 ) = tasks.register<Zip>(name) {
+    description = "Zips the root module for the $flavor-$buildType variant."
 
     val variantTask = "assemble${cap(flavor)}${cap(buildType)}"
     dependsOn(variantTask)
@@ -200,6 +247,7 @@ val zipDebug = registerRootModuleZipTask(
 
 val collect = tasks.register<Copy>("collectReleaseArtifacts") {
 
+    description = "Collects release artifacts (APK, AAB, and root module ZIP) into a single directory for easier distribution."
     dependsOn(
         zipRelease,
         zipDebug,
@@ -228,5 +276,6 @@ val collect = tasks.register<Copy>("collectReleaseArtifacts") {
 }
 
 tasks.register("packageReleaseArtifacts") {
+    description = "Packages release artifacts (APK, AAB, and root module ZIP) into a single directory for easier distribution."
     dependsOn(collect)
 }

android/app/schemas/me.kavishdevar.librepods.database.LibrePodsDatabase/1.json

@@ -0,0 +1,221 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 1,
+    "identityHash": "c547604d916583c3b94c7bf1ac787fdf",
+    "entities": [
+      {
+        "tableName": "AppleEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`macAddress` TEXT NOT NULL, `settings` BLOB NOT NULL, `metadata` BLOB NOT NULL, `cache` BLOB NOT NULL, PRIMARY KEY(`macAddress`))",
+        "fields": [
+          {
+            "fieldPath": "macAddress",
+            "columnName": "macAddress",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "settings",
+            "columnName": "settings",
+            "affinity": "BLOB",
+            "notNull": true
+          },
+          {
+            "fieldPath": "metadata",
+            "columnName": "metadata",
+            "affinity": "BLOB",
+            "notNull": true
+          },
+          {
+            "fieldPath": "cache",
+            "columnName": "cache",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "macAddress"
+          ]
+        }
+      },
+      {
+        "tableName": "AppSettingsEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `nightMode` TEXT NOT NULL, `designSystem` TEXT NOT NULL, `useHighestRefreshRate` INTEGER NOT NULL, `debugMode` INTEGER NOT NULL, `bleScanMode` INTEGER NOT NULL, `bleReportDelay` INTEGER NOT NULL, `swipeAnywhereForBack` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "nightMode",
+            "columnName": "nightMode",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "designSystem",
+            "columnName": "designSystem",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "useHighestRefreshRate",
+            "columnName": "useHighestRefreshRate",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "debugMode",
+            "columnName": "debugMode",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bleScanMode",
+            "columnName": "bleScanMode",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bleReportDelay",
+            "columnName": "bleReportDelay",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "swipeAnywhereForBack",
+            "columnName": "swipeAnywhereForBack",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "AppStateEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `isPremium` INTEGER NOT NULL, `hasCompletedOnboarding` INTEGER NOT NULL, `lastVersionShown` TEXT, `hasConnectedToAACP` INTEGER NOT NULL, `firstSuccessfulConnectionTime` INTEGER, `reviewPrompted` INTEGER NOT NULL, `timeUntilFOSSPremiumExpiry` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isPremium",
+            "columnName": "isPremium",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasCompletedOnboarding",
+            "columnName": "hasCompletedOnboarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastVersionShown",
+            "columnName": "lastVersionShown",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "hasConnectedToAACP",
+            "columnName": "hasConnectedToAACP",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "firstSuccessfulConnectionTime",
+            "columnName": "firstSuccessfulConnectionTime",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "reviewPrompted",
+            "columnName": "reviewPrompted",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timeUntilFOSSPremiumExpiry",
+            "columnName": "timeUntilFOSSPremiumExpiry",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "WidgetConfigEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appWidgetId` INTEGER NOT NULL, `macAddress` TEXT NOT NULL, PRIMARY KEY(`appWidgetId`))",
+        "fields": [
+          {
+            "fieldPath": "appWidgetId",
+            "columnName": "appWidgetId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "macAddress",
+            "columnName": "macAddress",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "appWidgetId"
+          ]
+        }
+      },
+      {
+        "tableName": "HeartRateSampleEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `timestamp` INTEGER NOT NULL, `bpm` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timestamp",
+            "columnName": "timestamp",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bpm",
+            "columnName": "bpm",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'c547604d916583c3b94c7bf1ac787fdf')"
+    ]
+  }
+}

android/app/schemas/me.kavishdevar.librepods.database.LibrePodsDatabase/2.json

@@ -0,0 +1,221 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 2,
+    "identityHash": "721149fa5e2a13e82b73a83de312968a",
+    "entities": [
+      {
+        "tableName": "AppleEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`macAddress` TEXT NOT NULL, `settings` BLOB NOT NULL, `metadata` BLOB NOT NULL, `cache` BLOB NOT NULL, PRIMARY KEY(`macAddress`))",
+        "fields": [
+          {
+            "fieldPath": "macAddress",
+            "columnName": "macAddress",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "settings",
+            "columnName": "settings",
+            "affinity": "BLOB",
+            "notNull": true
+          },
+          {
+            "fieldPath": "metadata",
+            "columnName": "metadata",
+            "affinity": "BLOB",
+            "notNull": true
+          },
+          {
+            "fieldPath": "cache",
+            "columnName": "cache",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "macAddress"
+          ]
+        }
+      },
+      {
+        "tableName": "AppSettingsEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `nightMode` TEXT NOT NULL, `designSystem` TEXT NOT NULL, `useHighestRefreshRate` INTEGER NOT NULL, `debugMode` INTEGER NOT NULL, `bleScanMode` INTEGER NOT NULL, `bleReportDelay` INTEGER NOT NULL, `swipeAnywhereForBack` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "nightMode",
+            "columnName": "nightMode",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "designSystem",
+            "columnName": "designSystem",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "useHighestRefreshRate",
+            "columnName": "useHighestRefreshRate",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "debugMode",
+            "columnName": "debugMode",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bleScanMode",
+            "columnName": "bleScanMode",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bleReportDelay",
+            "columnName": "bleReportDelay",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "swipeAnywhereForBack",
+            "columnName": "swipeAnywhereForBack",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "AppStateEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `isPremium` INTEGER NOT NULL, `hasCompletedOnboarding` INTEGER NOT NULL, `lastVersionShown` TEXT, `hasConnectedToAACP` INTEGER NOT NULL, `firstSuccessfulConnectionTime` INTEGER, `reviewPrompted` INTEGER NOT NULL, `timeUntilFOSSPremiumExpiry` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isPremium",
+            "columnName": "isPremium",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasCompletedOnboarding",
+            "columnName": "hasCompletedOnboarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastVersionShown",
+            "columnName": "lastVersionShown",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "hasConnectedToAACP",
+            "columnName": "hasConnectedToAACP",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "firstSuccessfulConnectionTime",
+            "columnName": "firstSuccessfulConnectionTime",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "reviewPrompted",
+            "columnName": "reviewPrompted",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timeUntilFOSSPremiumExpiry",
+            "columnName": "timeUntilFOSSPremiumExpiry",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "WidgetConfigEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appWidgetId` INTEGER NOT NULL, `macAddress` TEXT NOT NULL, PRIMARY KEY(`appWidgetId`))",
+        "fields": [
+          {
+            "fieldPath": "appWidgetId",
+            "columnName": "appWidgetId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "macAddress",
+            "columnName": "macAddress",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "appWidgetId"
+          ]
+        }
+      },
+      {
+        "tableName": "HeartRateSampleEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `timestamp` INTEGER NOT NULL, `bpm` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timestamp",
+            "columnName": "timestamp",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bpm",
+            "columnName": "bpm",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '721149fa5e2a13e82b73a83de312968a')"
+    ]
+  }
+}

android/app/schemas/me.kavishdevar.librepods.database.LibrePodsDatabase/3.json

@@ -0,0 +1,226 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 3,
+    "identityHash": "721149fa5e2a13e82b73a83de312968a",
+    "entities": [
+      {
+        "tableName": "AppleEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`macAddress` TEXT NOT NULL, `settings` BLOB NOT NULL, `metadata` BLOB NOT NULL, `cache` BLOB NOT NULL, PRIMARY KEY(`macAddress`))",
+        "fields": [
+          {
+            "fieldPath": "macAddress",
+            "columnName": "macAddress",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "settings",
+            "columnName": "settings",
+            "affinity": "BLOB",
+            "notNull": true
+          },
+          {
+            "fieldPath": "metadata",
+            "columnName": "metadata",
+            "affinity": "BLOB",
+            "notNull": true
+          },
+          {
+            "fieldPath": "cache",
+            "columnName": "cache",
+            "affinity": "BLOB",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "macAddress"
+          ]
+        }
+      },
+      {
+        "tableName": "AppSettingsEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `nightMode` TEXT NOT NULL, `designSystem` TEXT NOT NULL, `overrideMaterialColor` INTEGER, `useHighestRefreshRate` INTEGER NOT NULL, `debugMode` INTEGER NOT NULL, `bleScanMode` INTEGER NOT NULL, `bleReportDelay` INTEGER NOT NULL, `swipeAnywhereForBack` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "nightMode",
+            "columnName": "nightMode",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "designSystem",
+            "columnName": "designSystem",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "overrideMaterialColor",
+            "columnName": "overrideMaterialColor",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "useHighestRefreshRate",
+            "columnName": "useHighestRefreshRate",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "debugMode",
+            "columnName": "debugMode",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bleScanMode",
+            "columnName": "bleScanMode",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bleReportDelay",
+            "columnName": "bleReportDelay",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "swipeAnywhereForBack",
+            "columnName": "swipeAnywhereForBack",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "AppStateEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER NOT NULL, `isPremium` INTEGER NOT NULL, `hasCompletedOnboarding` INTEGER NOT NULL, `lastVersionShown` TEXT, `hasConnectedToAACP` INTEGER NOT NULL, `firstSuccessfulConnectionTime` INTEGER, `reviewPrompted` INTEGER NOT NULL, `timeUntilFOSSPremiumExpiry` INTEGER NOT NULL, PRIMARY KEY(`id`))",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isPremium",
+            "columnName": "isPremium",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "hasCompletedOnboarding",
+            "columnName": "hasCompletedOnboarding",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastVersionShown",
+            "columnName": "lastVersionShown",
+            "affinity": "TEXT"
+          },
+          {
+            "fieldPath": "hasConnectedToAACP",
+            "columnName": "hasConnectedToAACP",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "firstSuccessfulConnectionTime",
+            "columnName": "firstSuccessfulConnectionTime",
+            "affinity": "INTEGER"
+          },
+          {
+            "fieldPath": "reviewPrompted",
+            "columnName": "reviewPrompted",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timeUntilFOSSPremiumExpiry",
+            "columnName": "timeUntilFOSSPremiumExpiry",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "id"
+          ]
+        }
+      },
+      {
+        "tableName": "WidgetConfigEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`appWidgetId` INTEGER NOT NULL, `macAddress` TEXT NOT NULL, PRIMARY KEY(`appWidgetId`))",
+        "fields": [
+          {
+            "fieldPath": "appWidgetId",
+            "columnName": "appWidgetId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "macAddress",
+            "columnName": "macAddress",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": false,
+          "columnNames": [
+            "appWidgetId"
+          ]
+        }
+      },
+      {
+        "tableName": "HeartRateSampleEntity",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `timestamp` INTEGER NOT NULL, `bpm` INTEGER NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "timestamp",
+            "columnName": "timestamp",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "bpm",
+            "columnName": "bpm",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        }
+      }
+    ],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '721149fa5e2a13e82b73a83de312968a')"
+    ]
+  }
+}

android/app/src/main/AndroidManifest.xml

@@ -26,15 +26,22 @@
     <uses-permission
         android:name="android.permission.INTERACT_ACROSS_USERS"
         tools:ignore="ProtectedPermissions" />
+    <uses-permission
+        android:name="android.permission.MODIFY_AUDIO_ROUTING"
+        tools:ignore="ProtectedPermissions" />
+
     <uses-permission android:name="android.permission.BLUETOOTH" />
+
     <uses-permission
         android:name="android.permission.BLUETOOTH_SCAN"
         android:usesPermissionFlags="neverForLocation"
         tools:ignore="UnusedAttribute" />
+
     <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
     <uses-permission android:name="android.permission.ANSWER_PHONE_CALLS" />
     <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+
 <!--    <uses-permission android:name="android.permission.INTERNET" />-->
 <!--    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"-->
 <!--        android:maxSdkVersion="30" />-->
@@ -42,6 +49,8 @@
 <!--        android:maxSdkVersion="30" />-->
     <uses-permission android:name="com.android.vending.BILLING" />
 
+    <uses-permission android:name="android.permission.health.WRITE_HEART_RATE"/>
+
     <application
         android:name=".LibrePodsApplication"
         android:allowBackup="true"
@@ -80,7 +89,7 @@
         </receiver>
 
         <activity
-            android:name=".MainActivity"
+            android:name=".presentation.activities.MainActivity"
             android:exported="true"
             android:theme="@style/Theme.LibrePods">
             <intent-filter>
@@ -98,16 +107,11 @@
         </activity>
 
         <activity
-            android:name=".QuickSettingsDialogActivity"
-            android:exported="false"
-            android:theme="@style/Theme.TransparentDialog"
-            android:launchMode="singleTask"
-            android:excludeFromRecents="true"
-            android:taskAffinity=""
-             />
+            android:name=".presentation.activities.NoiseControlWidgetConfigurationActivity"
+            android:exported="false" />
 
         <service
-            android:name=".services.AirPodsService"
+            android:name=".services.LibrePodsService"
             android:enabled="true"
             android:exported="true"
             android:foregroundServiceType="connectedDevice"
@@ -115,7 +119,7 @@
         <service
             android:name=".services.AirPodsQSService"
             android:exported="true"
-            android:icon="@drawable/airpods"
+            android:icon="@drawable/ic_airpods"
             android:label="ANC Mode"
             android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
             <intent-filter>
@@ -153,6 +157,28 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/file_paths" />
         </provider>
-    </application>
 
+        <activity
+            android:name=".presentation.activities.PrivacyPolicyActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="androidx.health.ACTION_SHOW_PERMISSIONS_RATIONALE" />
+            </intent-filter>
+        </activity>
+
+        <activity-alias
+            android:name="ViewPermissionUsageActivity"
+            android:exported="true"
+            android:targetActivity=".presentation.activities.PrivacyPolicyActivity"
+            android:permission="android.permission.START_VIEW_PERMISSION_USAGE">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW_PERMISSION_USAGE" />
+                <category android:name="android.intent.category.HEALTH_PERMISSIONS" />
+            </intent-filter>
+        </activity-alias>
+
+    </application>
+    <queries>
+        <package android:name="com.google.android.apps.healthdata" />
+    </queries>
 </manifest>

android/app/src/main/cpp/CMakeLists.txt

@@ -3,21 +3,21 @@ cmake_minimum_required(VERSION 3.22.1)
 project("l2c_fcr_hook")
 set(CMAKE_CXX_STANDARD 23)
 
-add_library(bluetooth_socket SHARED
-        bluetooth_socket.cpp
+add_library(hiddenapi SHARED
+        hiddenapi.cpp
 )
 
-target_compile_options(bluetooth_socket PRIVATE
+target_compile_options(hiddenapi PRIVATE
         -O2
         -fvisibility=hidden
 )
 
-target_link_options(bluetooth_socket PRIVATE
+target_link_options(hiddenapi PRIVATE
         -Wl,--strip-all
         -Wl,--gc-sections
 )
 
-target_link_libraries(bluetooth_socket
+target_link_libraries(hiddenapi
         android
         log
 )
@@ -25,8 +25,8 @@ target_link_libraries(bluetooth_socket
 
 set(XPOSED_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../xposed/cpp)
 
-add_library(l2c_fcr_hook SHARED
-        l2c_fcr_hook.cpp
+add_library(fluoride_hooks SHARED
+        fluoride_hooks.cpp
 
         xz/xz_crc32.c
         xz/xz_crc64.c
@@ -36,11 +36,11 @@ add_library(l2c_fcr_hook SHARED
         xz/xz_dec_bcj.c
 )
 
-target_include_directories(l2c_fcr_hook PRIVATE
+target_include_directories(fluoride_hooks PRIVATE
         xz
 )
 
-target_compile_definitions(l2c_fcr_hook PRIVATE
+target_compile_definitions(fluoride_hooks PRIVATE
         XZ_DEC_X86
         XZ_DEC_ARM
         XZ_DEC_ARMTHUMB
@@ -51,7 +51,7 @@ target_compile_definitions(l2c_fcr_hook PRIVATE
         XZ_DEC_CONCATENATED
 )
 
-target_link_libraries(l2c_fcr_hook
+target_link_libraries(fluoride_hooks
         android
         log
 )

android/app/src/main/cpp/fluoride_hooks.cpp

@@ -0,0 +1,203 @@
+/*
+    LibrePods - AirPods liberated from Apple’s ecosystem
+    Copyright (C) 2025 LibrePods contributors
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <android/log.h>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <elf.h>
+#include <atomic>
+#include <jni.h>
+#include "helpers.h"
+
+#include "fluoride_hooks.h"
+
+static std::atomic<bool> enableSdpHook(false);
+
+static HookFunType hook_func = nullptr;
+
+static uint8_t (*original_l2c_fcr_chk_chan_modes)(void *) = nullptr;
+
+uint8_t fake_l2c_fcr_chk_chan_modes(void *p_ccb) {
+    LOGI("fake_l2c_fcr_chk_chan_modes called");
+    uint8_t orig = 0;
+    if (original_l2c_fcr_chk_chan_modes)
+        orig = original_l2c_fcr_chk_chan_modes(p_ccb);
+
+    LOGI("fake_l2c_fcr_chk_chan_modes: orig = %d, returning 1", orig);
+    return 1;
+}
+
+static tBTA_STATUS (*original_BTA_DmSetLocalDiRecord)(tSDP_DI_RECORD *, uint32_t *) = nullptr;
+
+tBTA_STATUS fake_BTA_DmSetLocalDiRecord(tSDP_DI_RECORD *p_device_info, uint32_t *p_handle) {
+
+    LOGI("fake_BTA_DmSetLocalDiRecord called");
+
+    if (original_BTA_DmSetLocalDiRecord &&
+        enableSdpHook.load(std::memory_order_relaxed))
+        original_BTA_DmSetLocalDiRecord(p_device_info, p_handle);
+
+    LOGI("fake_BTA_DmSetLocalDiRecord: modifying vendor to 0x004C, vendor_id_source to 0x0001");
+
+    if (p_device_info) {
+        p_device_info->vendor = 0x004C;
+        p_device_info->vendor_id_source = 0x0001;
+    }
+
+    LOGI("fake_BTA_DmSetLocalDiRecord: returning status %d",
+         original_BTA_DmSetLocalDiRecord ? original_BTA_DmSetLocalDiRecord(p_device_info, p_handle)
+                                         : BTA_FAILURE);
+    return original_BTA_DmSetLocalDiRecord ? original_BTA_DmSetLocalDiRecord(p_device_info,
+                                                                             p_handle)
+                                           : BTA_FAILURE;
+}
+
+
+static bool hookLibrary(const char *libname) {
+    LOGI("hookLibrary called with libname: %s", libname);
+
+    if (!hook_func) {
+        LOGE("hook_func not initialized");
+        return false;
+    }
+
+    std::string path;
+    if (!getLibraryPath(libname, path)) {
+        LOGE("Failed to locate %s", libname);
+        return false;
+    }
+    LOGI("hookLibrary: located path: %s", path.c_str());
+
+    int fd = open(path.c_str(), O_RDONLY);
+    if (fd < 0) {
+        LOGE("hookLibrary: open failed");
+        return false;
+    }
+
+    struct stat st{};
+    if (fstat(fd, &st) != 0) {
+        LOGE("hookLibrary: fstat failed");
+        close(fd);
+        return false;
+    }
+    LOGI("hookLibrary: opened file, size: %lld", (long long) st.st_size);
+
+    std::vector<uint8_t> file(st.st_size);
+    read(fd, file.data(), st.st_size);
+    close(fd);
+
+    auto *eh = reinterpret_cast<Elf64_Ehdr *>(file.data());
+    auto *shdr = reinterpret_cast<Elf64_Shdr *>(
+            file.data() + eh->e_shoff);
+
+    const char *shstr = reinterpret_cast<const char *>(
+            file.data() + shdr[eh->e_shstrndx].sh_offset);
+
+    uint64_t chk_offset = 0;
+    uint64_t sdp_offset = 0;
+
+    for (int i = 0; i < eh->e_shnum; ++i) {
+        if (!strcmp(shstr + shdr[i].sh_name, ".gnu_debugdata")) {
+            LOGI("hookLibrary: found .gnu_debugdata section");
+
+            std::vector<uint8_t> compressed(file.begin() + shdr[i].sh_offset,
+                                            file.begin() + shdr[i].sh_offset + shdr[i].sh_size);
+
+            std::vector<uint8_t> decompressed;
+
+            if (decompressXZ(compressed.data(), compressed.size(), decompressed)) {
+                chk_offset = findSymbolOffset(decompressed, "l2c_fcr_chk_chan_modes");
+                sdp_offset = findSymbolOffset(decompressed, "BTA_DmSetLocalDiRecord");
+            } else {
+                LOGE("debugdata decompress failed");
+            }
+
+            break;
+        }
+    }
+
+    if (!chk_offset) {
+        LOGI("fallback dynsym chk");
+        chk_offset = findSymbolOffsetDynsym(file, "l2c_fcr_chk_chan_modes");
+    }
+
+    if (!sdp_offset) {
+        LOGI("fallback dynsym sdp");
+        sdp_offset = findSymbolOffsetDynsym(file, "BTA_DmSetLocalDiRecord");
+    }
+
+    uintptr_t base = getModuleBase(libname);
+
+    if (!base) {
+        LOGE("hookLibrary: getModuleBase failed");
+        return false;
+    }
+
+    if (chk_offset) {
+        void *target = reinterpret_cast<void *>(base + chk_offset);
+        hook_func(target, (void *) fake_l2c_fcr_chk_chan_modes,
+                  (void **) &original_l2c_fcr_chk_chan_modes);
+        LOGI("hooked chk");
+    }
+
+    if (sdp_offset) {
+        void *target = reinterpret_cast<void *>(base + sdp_offset);
+        hook_func(target, (void *) fake_BTA_DmSetLocalDiRecord,
+                  (void **) &original_BTA_DmSetLocalDiRecord);
+        LOGI("hooked sdp");
+    }
+
+    return chk_offset || sdp_offset;
+}
+
+static void on_library_loaded(const char *name, void *) {
+    LOGI("on_library_loaded called with name: %s", name);
+
+    if (strstr(name, "libbluetooth_jni.so")) {
+        LOGI("Bluetooth JNI loaded");
+        hookLibrary("libbluetooth_jni.so");
+    }
+
+    if (strstr(name, "libbluetooth_qti.so")) {
+        LOGI("Bluetooth QTI loaded");
+        hookLibrary("libbluetooth_qti.so");
+    }
+}
+
+extern "C" [[gnu::visibility("default")]]
+[[gnu::used]]
+NativeOnModuleLoaded native_init(const NativeAPIEntries *entries) {
+    LOGI("native_init called with entries: %p", entries);
+    hook_func = (HookFunType) entries->hook_func;
+    LOGI("LibrePodsNativeHook initialized, sdp hook enabled: %d",
+         enableSdpHook.load(std::memory_order_relaxed));
+    return on_library_loaded;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_me_kavishdevar_librepods_utils_NativeBridge_setSdpHook(JNIEnv *, jobject thiz,
+                                                            jboolean enable) {
+    LOGI("setSdpHook called with enable: %d", enable);
+    enableSdpHook.store(enable, std::memory_order_relaxed);
+
+    LOGI("sdp hook enabled: %d", enable);
+}

android/app/src/main/cpp/helpers.h

@@ -1,21 +1,3 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
 #include <android/log.h>
 #include <cstring>
 #include <string>
@@ -24,60 +6,17 @@
 #include <unistd.h>
 #include <sys/stat.h>
 #include <elf.h>
-#include <atomic>
 #include <jni.h>
 
-#include "l2c_fcr_hook.h"
 
 extern "C" {
-#include "xz.h"
+    #include "xz.h"
 }
 
 #define LOG_TAG "LibrePodsHook"
 #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
 #define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
 
-static HookFunType hook_func = nullptr;
-
-static uint8_t (*original_l2c_fcr_chk_chan_modes)(void *) = nullptr;
-
-static tBTA_STATUS (*original_BTA_DmSetLocalDiRecord)(tSDP_DI_RECORD *, uint32_t *) = nullptr;
-
-static std::atomic<bool> enableSdpHook(false);
-
-uint8_t fake_l2c_fcr_chk_chan_modes(void *p_ccb) {
-    LOGI("fake_l2c_fcr_chk_chan_modes called");
-    uint8_t orig = 0;
-    if (original_l2c_fcr_chk_chan_modes)
-        orig = original_l2c_fcr_chk_chan_modes(p_ccb);
-
-    LOGI("fake_l2c_fcr_chk_chan_modes: orig = %d, returning 1", orig);
-    return 1;
-}
-
-tBTA_STATUS fake_BTA_DmSetLocalDiRecord(tSDP_DI_RECORD *p_device_info, uint32_t *p_handle) {
-
-    LOGI("fake_BTA_DmSetLocalDiRecord called");
-
-    if (original_BTA_DmSetLocalDiRecord &&
-        enableSdpHook.load(std::memory_order_relaxed))
-        original_BTA_DmSetLocalDiRecord(p_device_info, p_handle);
-
-    LOGI("fake_BTA_DmSetLocalDiRecord: modifying vendor to 0x004C, vendor_id_source to 0x0001");
-
-    if (p_device_info) {
-        p_device_info->vendor = 0x004C;
-        p_device_info->vendor_id_source = 0x0001;
-    }
-
-    LOGI("fake_BTA_DmSetLocalDiRecord: returning status %d",
-         original_BTA_DmSetLocalDiRecord ? original_BTA_DmSetLocalDiRecord(p_device_info, p_handle)
-                                         : BTA_FAILURE);
-    return original_BTA_DmSetLocalDiRecord ? original_BTA_DmSetLocalDiRecord(p_device_info,
-                                                                             p_handle)
-                                           : BTA_FAILURE;
-}
-
 static bool decompressXZ(const uint8_t *input, size_t input_size, std::vector<uint8_t> &output) {
 
     LOGI("decompressXZ called with input_size: %zu", input_size);
@@ -184,7 +123,7 @@ static uintptr_t getModuleBase(const char *name) {
     while (fgets(line, sizeof(line), fp)) {
         if (strstr(line, name)) {
             base = strtoull(line, nullptr, 16);
-            LOGI("getModuleBase: found base at 0x%lx", base);
+            LOGI("getModuleBase: found base at 0x%x", base);
             break;
         }
     }
@@ -302,134 +241,3 @@ static uint64_t findSymbolOffset(const std::vector<uint8_t> &elf, const char *sy
     LOGI("findSymbolOffset: no match found for %s", symbol_substring);
     return 0;
 }
-
-static bool hookLibrary(const char *libname) {
-    LOGI("hookLibrary called with libname: %s", libname);
-
-    if (!hook_func) {
-        LOGE("hook_func not initialized");
-        return false;
-    }
-
-    std::string path;
-    if (!getLibraryPath(libname, path)) {
-        LOGE("Failed to locate %s", libname);
-        return false;
-    }
-    LOGI("hookLibrary: located path: %s", path.c_str());
-
-    int fd = open(path.c_str(), O_RDONLY);
-    if (fd < 0) {
-        LOGE("hookLibrary: open failed");
-        return false;
-    }
-
-    struct stat st{};
-    if (fstat(fd, &st) != 0) {
-        LOGE("hookLibrary: fstat failed");
-        close(fd);
-        return false;
-    }
-    LOGI("hookLibrary: opened file, size: %lld", (long long) st.st_size);
-
-    std::vector<uint8_t> file(st.st_size);
-    read(fd, file.data(), st.st_size);
-    close(fd);
-
-    auto *eh = reinterpret_cast<Elf64_Ehdr *>(file.data());
-    auto *shdr = reinterpret_cast<Elf64_Shdr *>(
-            file.data() + eh->e_shoff);
-
-    const char *shstr = reinterpret_cast<const char *>(
-            file.data() + shdr[eh->e_shstrndx].sh_offset);
-
-    uint64_t chk_offset = 0;
-    uint64_t sdp_offset = 0;
-
-    for (int i = 0; i < eh->e_shnum; ++i) {
-        if (!strcmp(shstr + shdr[i].sh_name, ".gnu_debugdata")) {
-            LOGI("hookLibrary: found .gnu_debugdata section");
-
-            std::vector<uint8_t> compressed(file.begin() + shdr[i].sh_offset,
-                                            file.begin() + shdr[i].sh_offset + shdr[i].sh_size);
-
-            std::vector<uint8_t> decompressed;
-
-            if (decompressXZ(compressed.data(), compressed.size(), decompressed)) {
-
-                chk_offset = findSymbolOffset(decompressed, "l2c_fcr_chk_chan_modes");
-
-                sdp_offset = findSymbolOffset(decompressed, "BTA_DmSetLocalDiRecord");
-            } else {
-                LOGE("debugdata decompress failed");
-            }
-
-            break;
-        }
-    }
-
-    if (!chk_offset) {
-        LOGI("fallback dynsym chk");
-        chk_offset = findSymbolOffsetDynsym(file, "l2c_fcr_chk_chan_modes");
-    }
-
-    if (!sdp_offset) {
-        LOGI("fallback dynsym sdp");
-        sdp_offset = findSymbolOffsetDynsym(file, "BTA_DmSetLocalDiRecord");
-    }
-
-    uintptr_t base = getModuleBase(libname);
-    if (!base) {
-        LOGE("hookLibrary: getModuleBase failed");
-        return false;
-    }
-
-    if (chk_offset) {
-        void *target = reinterpret_cast<void *>(base + chk_offset);
-        hook_func(target, (void *) fake_l2c_fcr_chk_chan_modes,
-                  (void **) &original_l2c_fcr_chk_chan_modes);
-        LOGI("hooked chk");
-    }
-
-    if (sdp_offset) {
-        void *target = reinterpret_cast<void *>(base + sdp_offset);
-        hook_func(target, (void *) fake_BTA_DmSetLocalDiRecord,
-                  (void **) &original_BTA_DmSetLocalDiRecord);
-        LOGI("hooked sdp");
-    }
-
-    return chk_offset || sdp_offset;
-}
-
-static void on_library_loaded(const char *name, void *) {
-    LOGI("on_library_loaded called with name: %s", name);
-
-    if (strstr(name, "libbluetooth_jni.so")) {
-        LOGI("Bluetooth JNI loaded");
-        hookLibrary("libbluetooth_jni.so");
-    }
-
-    if (strstr(name, "libbluetooth_qti.so")) {
-        LOGI("Bluetooth QTI loaded");
-        hookLibrary("libbluetooth_qti.so");
-    }
-}
-
-extern "C" [[gnu::visibility("default")]]
-[[gnu::used]]
-NativeOnModuleLoaded native_init(const NativeAPIEntries *entries) {
-    LOGI("native_init called with entries: %p", entries);
-    hook_func = (HookFunType) entries->hook_func;
-    LOGI("LibrePodsNativeHook initialized, sdp hook enabled: %d",
-         enableSdpHook.load(std::memory_order_relaxed));
-    return on_library_loaded;
-}
-
-extern "C" JNIEXPORT void JNICALL
-Java_me_kavishdevar_librepods_utils_NativeBridge_setSdpHook(JNIEnv *, jobject thiz,
-                                                            jboolean enable) {
-    LOGI("setSdpHook called with enable: %d", enable);
-    enableSdpHook.store(enable, std::memory_order_relaxed);
-
-    LOGI("sdp hook enabled: %d", enable);
-}

android/app/src/main/cpp/hiddenapi.cpp

@@ -41,7 +41,7 @@ JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
         constexpr auto c5 = ENC("([Ljava/lang/String;)V");
         constexpr auto c6 = ENC("java/lang/String");
         constexpr auto c7 = ENC("Landroid/bluetooth/BluetoothSocket;");
-        constexpr auto c8 = ENC("Landroid/bluetooth/BluetoothDevice;");
+        constexpr auto c8 = ENC("L");
 
         JNIEnv* env;
         getVm()->AttachCurrentThread(&env, nullptr);

android/app/src/main/java/me/kavishdevar/librepods/MainActivity.kt

@@ -1,879 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods
-
-// import me.kavishdevar.librepods.screens.Onboarding
-// import me.kavishdevar.librepods.utils.RadareOffsetFinder
-//import dagger.hilt.android.AndroidEntryPoint
-import android.annotation.SuppressLint
-import android.app.Activity
-import android.content.BroadcastReceiver
-import android.content.ComponentName
-import android.content.Context
-import android.content.Context.MODE_PRIVATE
-import android.content.Intent
-import android.content.ServiceConnection
-import android.os.Build
-import android.os.Bundle
-import android.os.IBinder
-import android.provider.Settings
-import android.util.Log
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.RepeatMode
-import androidx.compose.animation.core.animateFloat
-import androidx.compose.animation.core.infiniteRepeatable
-import androidx.compose.animation.core.rememberInfiniteTransition
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
-import androidx.compose.animation.slideInHorizontally
-import androidx.compose.animation.slideOutHorizontally
-import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Notifications
-import androidx.compose.material.icons.filled.Phone
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.scale
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.drawscope.rotate
-import androidx.compose.ui.graphics.vector.ImageVector
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalWindowInfo
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.res.vectorResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.core.content.edit
-import androidx.core.net.toUri
-import androidx.lifecycle.viewmodel.compose.viewModel
-import androidx.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.rememberNavController
-import com.google.accompanist.permissions.ExperimentalPermissionsApi
-import com.google.accompanist.permissions.MultiplePermissionsState
-import com.google.accompanist.permissions.isGranted
-import com.google.accompanist.permissions.rememberMultiplePermissionsState
-import com.google.android.play.core.review.ReviewManagerFactory
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.hazeSource
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import dev.chrisbanes.haze.rememberHazeState
-import me.kavishdevar.librepods.data.AirPodsNotifications
-import me.kavishdevar.librepods.data.ControlCommandRepository
-import me.kavishdevar.librepods.presentation.components.AppInfoCard
-import me.kavishdevar.librepods.presentation.components.DeviceInfoCard
-import me.kavishdevar.librepods.presentation.components.StyledIconButton
-import me.kavishdevar.librepods.presentation.screens.AccessibilitySettingsScreen
-import me.kavishdevar.librepods.presentation.screens.AdaptiveStrengthScreen
-import me.kavishdevar.librepods.presentation.screens.AirPodsSettingsScreen
-import me.kavishdevar.librepods.presentation.screens.AppSettingsScreen
-import me.kavishdevar.librepods.presentation.screens.CameraControlScreen
-import me.kavishdevar.librepods.presentation.screens.DebugScreen
-import me.kavishdevar.librepods.presentation.screens.HeadTrackingScreen
-import me.kavishdevar.librepods.presentation.screens.HearingAidAdjustmentsScreen
-import me.kavishdevar.librepods.presentation.screens.HearingAidScreen
-import me.kavishdevar.librepods.presentation.screens.HearingProtectionScreen
-import me.kavishdevar.librepods.presentation.screens.LongPress
-import me.kavishdevar.librepods.presentation.screens.OpenSourceLicensesScreen
-import me.kavishdevar.librepods.presentation.screens.PurchaseScreen
-import me.kavishdevar.librepods.presentation.screens.RenameScreen
-import me.kavishdevar.librepods.presentation.screens.TransparencySettingsScreen
-import me.kavishdevar.librepods.presentation.screens.TroubleshootingScreen
-import me.kavishdevar.librepods.presentation.screens.UpdateHearingTestScreen
-import me.kavishdevar.librepods.presentation.screens.VersionScreen
-import me.kavishdevar.librepods.presentation.theme.LibrePodsTheme
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-import me.kavishdevar.librepods.presentation.viewmodel.AppSettingsViewModel
-import me.kavishdevar.librepods.presentation.viewmodel.PurchaseViewModel
-import me.kavishdevar.librepods.services.AirPodsService
-import me.kavishdevar.librepods.utils.XposedState
-import me.kavishdevar.librepods.utils.isSupported
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-lateinit var serviceConnection: ServiceConnection
-lateinit var connectionStatusReceiver: BroadcastReceiver
-lateinit var testReviewReceiver: BroadcastReceiver
-
-//@AndroidEntryPoint
-@ExperimentalMaterial3Api
-class MainActivity : ComponentActivity() {
-    companion object {
-        init {
-            if (XposedState.isAvailable && XposedState.bluetoothScopeEnabled) {
-                System.loadLibrary("l2c_fcr_hook")
-            }
-        }
-    }
-
-    @ExperimentalHazeMaterialsApi
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        enableEdgeToEdge()
-
-        setContent {
-            LibrePodsTheme {
-                Main()
-            }
-        }
-    }
-
-    override fun onDestroy() {
-        try {
-            unbindService(serviceConnection)
-            Log.d("MainActivity", "Unbound service")
-        } catch (e: Exception) {
-            Log.e("MainActivity", "Error while unbinding service: $e")
-        }
-        try {
-            unregisterReceiver(connectionStatusReceiver)
-            Log.d("MainActivity", "Unregistered receiver")
-        } catch (e: Exception) {
-            Log.e("MainActivity", "Error while unregistering receiver: $e")
-        }
-        sendBroadcast(Intent(AirPodsNotifications.DISCONNECT_RECEIVERS))
-        super.onDestroy()
-    }
-
-    override fun onStop() {
-        try {
-            unbindService(serviceConnection)
-            Log.d("MainActivity", "Unbound service")
-        } catch (e: Exception) {
-            Log.e("MainActivity", "Error while unbinding service: $e")
-        }
-        try {
-            unregisterReceiver(connectionStatusReceiver)
-            Log.d("MainActivity", "Unregistered receiver")
-        } catch (e: Exception) {
-            Log.e("MainActivity", "Error while unregistering receiver: $e")
-        }
-        super.onStop()
-    }
-}
-
-@ExperimentalHazeMaterialsApi
-@SuppressLint("MissingPermission", "InlinedApi", "UnspecifiedRegisterReceiverFlag")
-@OptIn(ExperimentalPermissionsApi::class, ExperimentalMaterial3Api::class)
-@Composable
-fun Main() {
-    val context = LocalContext.current
-    val sharedPreferences = context.getSharedPreferences("settings", MODE_PRIVATE)
-    if (!isSupported(sharedPreferences) && !XposedState.bluetoothScopeEnabled) {
-        val hazeState = rememberHazeState()
-        val backdrop = rememberLayerBackdrop()
-        val isDarkTheme = isSystemInDarkTheme()
-        val textColor = if (isDarkTheme) Color.White else Color.Black
-        val backgroundColor = if (isSystemInDarkTheme()) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-
-        val scrollState = rememberScrollState()
-
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .hazeSource(hazeState)
-                .layerBackdrop(backdrop)
-                .background(if (isDarkTheme) Color.Black else Color(0xFFF2F2F7)),
-            contentAlignment = Alignment.Center
-        ) {
-            Column(
-                modifier = Modifier
-                    .padding(horizontal = 16.dp)
-                    .verticalScroll(scrollState),
-                verticalArrangement = Arrangement
-                    .spacedBy(16.dp)
-            ) {
-                Spacer(modifier = Modifier.height(48.dp))
-                Column(
-                    modifier = Modifier,
-                    verticalArrangement = Arrangement
-                        .spacedBy(16.dp)
-                ) {
-                    Spacer(modifier = Modifier.height(16.dp))
-                    Text(
-                        text = stringResource(R.string.not_supported),
-                        style = TextStyle(
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            fontWeight = FontWeight.SemiBold,
-                            color = textColor,
-                            fontSize = 28.sp,
-                            textAlign = TextAlign.Center
-                        ),
-                        modifier = Modifier.fillMaxWidth()
-                    )
-
-                    Box(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .background(backgroundColor, RoundedCornerShape(28.dp))
-                            .clip(RoundedCornerShape(28.dp))
-                    ) {
-                        Text(
-                            text = stringResource(R.string.check_the_repository_for_more_info),
-                            style = TextStyle(
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                fontWeight = FontWeight.Medium,
-                                color = if (isDarkTheme) Color.White else Color.Black,
-                                fontSize = 16.sp
-                            ),
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(horizontal = 12.dp, vertical = 16.dp)
-                        )
-                    }
-                    Spacer(modifier = Modifier.height(4.dp))
-                    Text(
-                        text = stringResource(R.string.enable_app_in_xposed_or_update_device),
-                        style = TextStyle(
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            fontWeight = FontWeight.Light,
-                            color = if (isDarkTheme) Color.White else Color.Black,
-                            fontSize = 14.sp
-                        ),
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 16.dp, vertical = 16.dp)
-                    )
-                    DeviceInfoCard()
-                    AppInfoCard()
-                }
-                Spacer(modifier = Modifier.height(48.dp))
-            }
-        }
-        return
-    }
-
-    val isConnected = remember { mutableStateOf(false) }
-
-    var canDrawOverlays by remember { mutableStateOf(Settings.canDrawOverlays(context)) }
-    val overlaySkipped = remember {
-        mutableStateOf(
-            context.getSharedPreferences("settings", MODE_PRIVATE)
-                .getBoolean("overlay_permission_skipped", false)
-        )
-    }
-
-    val bluetoothPermissions = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-        listOf(
-            "android.permission.BLUETOOTH_CONNECT",
-            "android.permission.BLUETOOTH_SCAN",
-            "android.permission.BLUETOOTH",
-            "android.permission.BLUETOOTH_ADMIN",
-            "android.permission.BLUETOOTH_ADVERTISE"
-        )
-    } else {
-        listOf(
-            "android.permission.BLUETOOTH",
-            "android.permission.BLUETOOTH_ADMIN",
-            "android.permission.ACCESS_FINE_LOCATION"
-        )
-    }
-    val otherPermissions = listOf(
-        "android.permission.POST_NOTIFICATIONS",
-        "android.permission.READ_PHONE_STATE",
-        "android.permission.ANSWER_PHONE_CALLS"
-    )
-    val allPermissions = bluetoothPermissions + otherPermissions
-
-    val permissionState = rememberMultiplePermissionsState(
-        permissions = allPermissions
-    )
-
-    val airPodsService = remember { mutableStateOf<AirPodsService?>(null) }
-
-    val airPodsViewModel = remember(airPodsService.value) {
-        airPodsService.value?.let { service ->
-            AirPodsViewModel(
-                service = service,
-                sharedPreferences = context.getSharedPreferences("settings", MODE_PRIVATE),
-                controlRepo = ControlCommandRepository(service.aacpManager),
-                appContext = context.applicationContext
-            )
-        }
-    }
-
-    LaunchedEffect(Unit) {
-        canDrawOverlays = Settings.canDrawOverlays(context)
-    }
-
-    if (permissionState.allPermissionsGranted && (canDrawOverlays || overlaySkipped.value)) {
-
-        val navController = rememberNavController()
-
-        LaunchedEffect(Unit) {
-            if (BuildConfig.PLAY_BUILD) {
-                val now = System.currentTimeMillis()
-                val firstConn =
-                    sharedPreferences.getLong("first_connection_successful_time", 0L)
-
-                val alreadyPrompted =
-                    sharedPreferences.getBoolean("review_prompted", false)
-
-                val oneDay = 24 * 60 * 60 * 1000L
-
-                if (
-                    firstConn != 0L &&
-                    !alreadyPrompted &&
-                    (now - firstConn) > oneDay
-                ) {
-                    triggerReviewFlow(context as? Activity ?: return@LaunchedEffect)
-
-                    sharedPreferences.edit {
-                        putBoolean("review_prompted", true)
-                    }
-                }
-            }
-        }
-
-        Box(
-            modifier = Modifier.fillMaxSize()
-        ) {
-            val backButtonBackdrop = rememberLayerBackdrop()
-            Box(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .background(if (isSystemInDarkTheme()) Color.Black else Color(0xFFF2F2F7))
-                    .layerBackdrop(backButtonBackdrop)
-            ) {
-                NavHost(
-                    navController = navController,
-                    startDestination = "settings",
-                    enterTransition = {
-                        slideInHorizontally(
-                            initialOffsetX = { it }, animationSpec = tween(durationMillis = 300)
-                        )
-                    },
-                    exitTransition = {
-                        slideOutHorizontally(
-                            targetOffsetX = { -it / 4 }, animationSpec = tween(durationMillis = 300)
-                        )
-                    },
-                    popEnterTransition = {
-                        slideInHorizontally(
-                            initialOffsetX = { -it / 4 },
-                            animationSpec = tween(durationMillis = 300)
-                        )
-                    },
-                    popExitTransition = {
-                        slideOutHorizontally(
-                            targetOffsetX = { it }, animationSpec = tween(durationMillis = 300)
-                        )
-                    }) {
-                    composable("settings") {
-                        if (airPodsViewModel != null) AirPodsSettingsScreen(airPodsViewModel, navController)
-                    }
-                    composable("debug") {
-                        DebugScreen(navController = navController)
-                    }
-                    composable("long_press/{bud}") { navBackStackEntry ->
-                        if (airPodsViewModel != null) LongPress(
-                            viewModel = airPodsViewModel,
-                            name = navBackStackEntry.arguments?.getString("bud")!!,
-                            navController = navController
-                        )
-                    }
-                    composable("rename") {
-                        if (airPodsViewModel != null) RenameScreen(airPodsViewModel)
-                    }
-                    composable("app_settings") {
-                        val appSettingsViewModel: AppSettingsViewModel = viewModel()
-                        AppSettingsScreen(navController, appSettingsViewModel)
-                    }
-                    composable("troubleshooting") {
-                        TroubleshootingScreen(navController)
-                    }
-                    composable("head_tracking") {
-                        if (airPodsViewModel != null) HeadTrackingScreen(airPodsViewModel, navController)
-                    }
-                    composable("accessibility") {
-                        if (airPodsViewModel != null) AccessibilitySettingsScreen(airPodsViewModel, navController)
-                    }
-                    composable("transparency_customization") {
-                        if (airPodsViewModel != null) TransparencySettingsScreen(airPodsViewModel)
-                    }
-                    composable("hearing_aid") {
-                        if (airPodsViewModel != null) HearingAidScreen(airPodsViewModel, navController)
-                    }
-                    composable("hearing_aid_adjustments") {
-                        if (airPodsViewModel != null) HearingAidAdjustmentsScreen(airPodsViewModel)
-                    }
-                    composable("adaptive_strength") {
-                        if (airPodsViewModel != null) AdaptiveStrengthScreen(airPodsViewModel, navController)
-                    }
-                    composable("camera_control") {
-                        if (airPodsViewModel != null) CameraControlScreen(airPodsViewModel)
-                    }
-                    composable("open_source_licenses") {
-                        OpenSourceLicensesScreen(navController)
-                    }
-                    composable("update_hearing_test") {
-                        if (airPodsViewModel != null) UpdateHearingTestScreen(airPodsViewModel)
-                    }
-                    composable("version_info") {
-                        if (airPodsViewModel != null) VersionScreen(airPodsViewModel)
-                    }
-                    composable("hearing_protection") {
-                        if (airPodsViewModel != null) HearingProtectionScreen(airPodsViewModel, navController)
-                    }
-                    composable("purchase_screen") {
-                        val purchaseViewModel: PurchaseViewModel = viewModel()
-                        PurchaseScreen(purchaseViewModel, navController)
-                    }
-                }
-            }
-
-            val showBackButton = remember { mutableStateOf(false) }
-
-            LaunchedEffect(navController) {
-                navController.addOnDestinationChangedListener { _, destination, _ ->
-                    showBackButton.value =
-                        destination.route != "settings" // && destination.route != "onboarding"
-                }
-            }
-
-            AnimatedVisibility(
-                visible = showBackButton.value,
-                enter = fadeIn(animationSpec = tween()) + scaleIn(
-                    initialScale = 0f,
-                    animationSpec = tween()
-                ),
-                exit = fadeOut(animationSpec = tween()) + scaleOut(
-                    targetScale = 0.5f,
-                    animationSpec = tween(100)
-                ),
-                modifier = Modifier
-                    .align(Alignment.TopStart)
-                    .padding(
-                        start = 8.dp, top = (LocalWindowInfo.current.containerSize.width * 0.05f).dp
-                    )
-            ) {
-                StyledIconButton(
-                    onClick = { navController.popBackStack() },
-                    icon = "􀯶",
-                    backdrop = backButtonBackdrop
-                )
-            }
-        }
-
-        context.startForegroundService(Intent(context, AirPodsService::class.java))
-
-        serviceConnection = remember {
-            object : ServiceConnection {
-                override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
-                    val binder = service as AirPodsService.LocalBinder
-                    airPodsService.value = binder.getService()
-
-                    if (!sharedPreferences.contains("first_connection_successful_time")) {
-                        sharedPreferences.edit {
-                            putLong("first_connection_successful_time", System.currentTimeMillis())
-                        }
-                    }
-                }
-
-                override fun onServiceDisconnected(name: ComponentName?) {
-                    airPodsService.value = null
-                }
-            }
-        }
-
-        context.bindService(
-            Intent(context, AirPodsService::class.java),
-            serviceConnection,
-            Context.BIND_AUTO_CREATE
-        )
-
-        if (airPodsService.value?.isConnected() == true) {
-            isConnected.value = true
-        }
-    } else {
-        PermissionsScreen(
-            permissionState = permissionState,
-            canDrawOverlays = canDrawOverlays,
-            onOverlaySettingsReturn = { canDrawOverlays = Settings.canDrawOverlays(context) })
-    }
-}
-
-private fun triggerReviewFlow(activity: Activity) {
-    val manager = ReviewManagerFactory.create(activity)
-    val request = manager.requestReviewFlow()
-    request.addOnCompleteListener { task ->
-        if (task.isSuccessful) {
-            val reviewInfo = task.result
-            manager.launchReviewFlow(activity, reviewInfo)
-        }
-    }
-}
-
-@OptIn(ExperimentalPermissionsApi::class, ExperimentalMaterial3Api::class)
-@Composable
-fun PermissionsScreen(
-    permissionState: MultiplePermissionsState,
-    canDrawOverlays: Boolean,
-    onOverlaySettingsReturn: () -> Unit
-) {
-    val context = LocalContext.current
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color.White
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val accentColor = if (isDarkTheme) Color(0xFF007AFF) else Color(0xFF3C6DF5)
-
-    val scrollState = rememberScrollState()
-
-    val basicPermissionsGranted = permissionState.permissions.all { it.status.isGranted }
-
-    val infiniteTransition = rememberInfiniteTransition(label = "pulse")
-    val pulseScale by infiniteTransition.animateFloat(
-        initialValue = 1f, targetValue = 1.05f, animationSpec = infiniteRepeatable(
-            animation = tween(1000), repeatMode = RepeatMode.Reverse
-        ), label = "pulse scale"
-    )
-
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(if (isDarkTheme) Color.Black else Color(0xFFF2F2F7))
-            .padding(16.dp)
-            .verticalScroll(scrollState), horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(180.dp), contentAlignment = Alignment.Center
-        ) {
-            Text(
-                text = "\uDBC2\uDEB7", style = TextStyle(
-                    fontSize = 48.sp,
-                    fontWeight = FontWeight.Bold,
-                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    color = textColor,
-                    textAlign = TextAlign.Center
-                )
-            )
-            Canvas(
-                modifier = Modifier
-                    .size(120.dp)
-                    .scale(pulseScale)
-            ) {
-                val radius = size.minDimension / 2.2f
-                val centerX = size.width / 2
-                val centerY = size.height / 2
-
-                rotate(degrees = 45f) {
-                    drawCircle(
-                        color = accentColor.copy(alpha = 0.1f),
-                        radius = radius * 1.3f,
-                        center = Offset(centerX, centerY)
-                    )
-
-                    drawCircle(
-                        color = accentColor.copy(alpha = 0.2f),
-                        radius = radius * 1.1f,
-                        center = Offset(centerX, centerY)
-                    )
-                }
-            }
-        }
-
-        Spacer(modifier = Modifier.height(16.dp))
-
-        Text(
-            text = "Permission Required", style = TextStyle(
-                fontSize = 24.sp,
-                fontWeight = FontWeight.Bold,
-                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                color = textColor,
-                textAlign = TextAlign.Center
-            ), modifier = Modifier.fillMaxWidth()
-        )
-
-        Spacer(modifier = Modifier.height(8.dp))
-
-        Text(
-            text = stringResource(R.string.permissions_required), style = TextStyle(
-                fontSize = 16.sp,
-                fontWeight = FontWeight.Normal,
-                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                color = textColor.copy(alpha = 0.7f),
-                textAlign = TextAlign.Center
-            ), modifier = Modifier.fillMaxWidth()
-        )
-
-        Spacer(modifier = Modifier.height(32.dp))
-
-        PermissionCard(
-            title = "Bluetooth Permissions",
-            description = "Required to communicate with your AirPods",
-            icon = ImageVector.vectorResource(id = R.drawable.ic_bluetooth),
-            isGranted = permissionState.permissions.filter {
-                it.permission.contains("BLUETOOTH")
-            }.all { it.status.isGranted },
-            backgroundColor = backgroundColor,
-            textColor = textColor,
-            accentColor = accentColor
-        )
-
-        PermissionCard(
-            title = "Notification Permission",
-            description = "To show battery status",
-            icon = Icons.Default.Notifications,
-            isGranted = permissionState.permissions.find {
-                it.permission == "android.permission.POST_NOTIFICATIONS"
-            }?.status?.isGranted == true,
-            backgroundColor = backgroundColor,
-            textColor = textColor,
-            accentColor = accentColor
-        )
-
-        PermissionCard(
-            title = "Phone Permissions",
-            description = "For answering calls with Head Gestures",
-            icon = Icons.Default.Phone,
-            isGranted = permissionState.permissions.filter {
-                it.permission.contains("PHONE") || it.permission.contains("CALLS")
-            }.all { it.status.isGranted },
-            backgroundColor = backgroundColor,
-            textColor = textColor,
-            accentColor = accentColor
-        )
-
-        PermissionCard(
-            title = "Display Over Other Apps",
-            description = "For popup animations when AirPods connect",
-            icon = ImageVector.vectorResource(id = R.drawable.ic_layers),
-            isGranted = canDrawOverlays,
-            backgroundColor = backgroundColor,
-            textColor = textColor,
-            accentColor = accentColor
-        )
-
-        Spacer(modifier = Modifier.height(24.dp))
-
-        Button(
-            onClick = { permissionState.launchMultiplePermissionRequest() },
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(55.dp),
-            colors = ButtonDefaults.buttonColors(
-                containerColor = accentColor
-            ),
-            shape = RoundedCornerShape(8.dp)
-        ) {
-            Text(
-                "Ask for regular permissions",
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    fontWeight = FontWeight.Medium,
-                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    color = Color.White
-                ),
-            )
-        }
-
-        Spacer(modifier = Modifier.height(12.dp))
-
-        Button(
-            onClick = {
-                val intent = Intent(
-                    Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
-                    "package:${context.packageName}".toUri()
-                )
-                context.startActivity(intent)
-                onOverlaySettingsReturn()
-            },
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(55.dp),
-            colors = ButtonDefaults.buttonColors(
-                containerColor = if (canDrawOverlays) Color.Gray else accentColor
-            ),
-            enabled = !canDrawOverlays,
-            shape = RoundedCornerShape(8.dp)
-        ) {
-            Text(
-                if (canDrawOverlays) "Overlay Permission Granted" else "Grant Overlay Permission",
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    fontWeight = FontWeight.Medium,
-                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    color = Color.White
-                ),
-            )
-        }
-
-        if (!canDrawOverlays && basicPermissionsGranted) {
-            Spacer(modifier = Modifier.height(12.dp))
-
-            Button(
-                onClick = {
-                    context.getSharedPreferences("settings", MODE_PRIVATE).edit {
-                        putBoolean("overlay_permission_skipped", true)
-                    }
-
-                    val intent = Intent(context, MainActivity::class.java)
-                    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                    context.startActivity(intent)
-                },
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .height(55.dp),
-                colors = ButtonDefaults.buttonColors(
-                    containerColor = Color(0xFF757575)
-                ),
-                shape = RoundedCornerShape(8.dp)
-            ) {
-                Text(
-                    "Continue without overlay",
-                    style = TextStyle(
-                        fontSize = 16.sp,
-                        fontWeight = FontWeight.Medium,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = Color.White
-                    ),
-                )
-            }
-        }
-    }
-}
-
-@Composable
-fun PermissionCard(
-    title: String,
-    description: String,
-    icon: ImageVector,
-    isGranted: Boolean,
-    backgroundColor: Color,
-    textColor: Color,
-    accentColor: Color
-) {
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 6.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = backgroundColor
-        ),
-        shape = RoundedCornerShape(12.dp)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Box(
-                modifier = Modifier
-                    .size(40.dp)
-                    .clip(RoundedCornerShape(8.dp))
-                    .background(
-                        if (isGranted) accentColor.copy(alpha = 0.15f) else Color.Gray.copy(
-                            alpha = 0.15f
-                        )
-                    ), contentAlignment = Alignment.Center
-            ) {
-                Icon(
-                    imageVector = icon,
-                    contentDescription = title,
-                    tint = if (isGranted) accentColor else Color.Gray,
-                    modifier = Modifier.size(24.dp)
-                )
-            }
-
-            Column(
-                modifier = Modifier
-                    .weight(1f)
-                    .padding(start = 16.dp)
-            ) {
-                Text(
-                    text = title, style = TextStyle(
-                        fontSize = 16.sp,
-                        fontWeight = FontWeight.Medium,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = textColor
-                    )
-                )
-
-                Text(
-                    text = description, style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Normal,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = textColor.copy(alpha = 0.6f)
-                    )
-                )
-            }
-
-            Box(
-                modifier = Modifier
-                    .size(24.dp)
-                    .clip(RoundedCornerShape(12.dp))
-                    .background(if (isGranted) Color(0xFF4CAF50) else Color.Gray),
-                contentAlignment = Alignment.Center
-            ) {
-                Text(
-                    text = if (isGranted) "✓" else "!", style = TextStyle(
-                        fontSize = 14.sp, fontWeight = FontWeight.Bold, color = Color.White
-                    )
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/QuickSettingsDialogActivity.kt

@@ -1,639 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods
-
-import android.annotation.SuppressLint
-import android.content.BroadcastReceiver
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.ServiceConnection
-import android.media.AudioManager
-import android.os.Build
-import android.os.Bundle
-import android.os.IBinder
-import android.util.Log
-import android.view.Gravity
-import android.view.WindowManager
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import androidx.compose.animation.Crossfade
-import androidx.compose.animation.animateContentSize
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.FastOutSlowInEasing
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.spring
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.detectVerticalDragGestures
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.presentation.components.AdaptiveRainbowBrush
-import me.kavishdevar.librepods.presentation.components.ControlCenterNoiseControlSegmentedButton
-import me.kavishdevar.librepods.presentation.components.IconAreaSize
-import me.kavishdevar.librepods.presentation.components.VerticalVolumeSlider
-import me.kavishdevar.librepods.data.AirPodsNotifications
-import me.kavishdevar.librepods.data.NoiseControlMode
-import me.kavishdevar.librepods.services.AirPodsService
-import me.kavishdevar.librepods.presentation.theme.LibrePodsTheme
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import kotlin.io.encoding.ExperimentalEncodingApi
-import kotlin.math.abs
-
-class QuickSettingsDialogActivity : ComponentActivity() {
-
-    private var airPodsService: AirPodsService? = null
-    private var isBound = false
-
-    private var isNoiseControlExpandedState by mutableStateOf(false)
-
-    private val connection = object : ServiceConnection {
-        override fun onServiceConnected(className: ComponentName, service: IBinder) {
-            val binder = service as AirPodsService.LocalBinder
-            airPodsService = binder.getService()
-            isBound = true
-            Log.d("QSActivity", "Service bound")
-            setContent {
-                LibrePodsTheme {
-                    DraggableDismissBox(
-                        onDismiss = { finish() },
-                        onlyCollapseWhenClicked = {
-                            if (isNoiseControlExpandedState) {
-                                isNoiseControlExpandedState = false
-                                true
-                            } else {
-                                false
-                            }
-                        }
-                    ) {
-                        if (isBound && airPodsService != null) {
-                            NewControlCenterDialogContent(
-                                service = airPodsService,
-                                isNoiseControlExpanded = isNoiseControlExpandedState,
-                                onNoiseControlExpandedChange = { isNoiseControlExpandedState = it }
-                            )
-                        }
-                    }
-                }
-            }
-        }
-
-        override fun onServiceDisconnected(arg0: ComponentName) {
-            isBound = false
-            airPodsService = null
-            Log.d("QSActivity", "Service unbound")
-            finish()
-        }
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        window.addFlags(WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL)
-        window.addFlags(WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH)
-        window.addFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND)
-        window.setGravity(Gravity.BOTTOM)
-
-        Intent(this, AirPodsService::class.java).also { intent ->
-            bindService(intent, connection, BIND_AUTO_CREATE)
-        }
-
-        setContent {
-            LibrePodsTheme {
-                DraggableDismissBox(
-                    onDismiss = { finish() },
-                    onlyCollapseWhenClicked = {
-                        if (isNoiseControlExpandedState) {
-                            isNoiseControlExpandedState = false
-                            true
-                        } else {
-                            false
-                        }
-                    }
-                ) {
-                    if (isBound && airPodsService != null) {
-                        NewControlCenterDialogContent(
-                            service = airPodsService,
-                            isNoiseControlExpanded = isNoiseControlExpandedState,
-                            onNoiseControlExpandedChange = { isNoiseControlExpandedState = it }
-                        )
-                    }
-                }
-            }
-        }
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        if (isBound) {
-            unbindService(connection)
-            isBound = false
-        }
-    }
-}
-
-@Composable
-fun DraggableDismissBox(
-    onDismiss: () -> Unit,
-    onlyCollapseWhenClicked: () -> Boolean,
-    content: @Composable () -> Unit
-) {
-    val coroutineScope = rememberCoroutineScope()
-
-    var dragOffset by remember { mutableFloatStateOf(0f) }
-    var isDragging by remember { mutableStateOf(false) }
-    val dismissThreshold = 400f
-
-    val animatedOffset = remember { Animatable(0f) }
-    val animatedScale = remember { Animatable(1f) }
-    val animatedAlpha = remember { Animatable(1f) }
-
-    val backgroundAlpha by animateFloatAsState(
-        targetValue = if (isDragging) {
-            val dragProgress = (abs(dragOffset) / 800f).coerceIn(0f, 0.8f)
-            1f - dragProgress
-        } else 1f,
-        label = "BackgroundFade"
-    )
-
-    LaunchedEffect(isDragging) {
-        if (!isDragging) {
-            if (abs(dragOffset) < dismissThreshold) {
-                val springSpec = spring(
-                    dampingRatio = Spring.DampingRatioLowBouncy,
-                    stiffness = Spring.StiffnessHigh,
-                    visibilityThreshold = 0.1f
-                )
-                launch { animatedOffset.animateTo(0f, springSpec) }
-                launch { animatedScale.animateTo(1f, springSpec) }
-                launch { animatedAlpha.animateTo(1f, tween(100)) }
-                dragOffset = 0f
-            }
-        }
-    }
-
-    LaunchedEffect(dragOffset, isDragging) {
-        if (isDragging) {
-            val dragProgress = (abs(dragOffset) / 1000f).coerceIn(0f, 0.5f)
-
-            animatedOffset.snapTo(dragOffset)
-            animatedScale.snapTo(1f - dragProgress * 0.3f)
-            animatedAlpha.snapTo(1f - dragProgress * 0.7f)
-        }
-    }
-
-    Box(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(Color.Black.copy(alpha = 0.5f * backgroundAlpha))
-            .pointerInput(Unit) {
-                detectVerticalDragGestures(
-                    onDragStart = { isDragging = true },
-                    onDragEnd = {
-                        isDragging = false
-                        if (abs(dragOffset) > dismissThreshold) {
-                            coroutineScope.launch {
-                                val direction = if (dragOffset > 0) 1f else -1f
-
-                                launch {
-                                    animatedOffset.animateTo(
-                                        direction * 1500f,
-                                        tween(350, easing = FastOutSlowInEasing)
-                                    )
-                                }
-                                launch { animatedScale.animateTo(0.7f, tween(350)) }
-                                launch { animatedAlpha.animateTo(0f, tween(250)) }
-
-                                kotlinx.coroutines.delay(350)
-                                onDismiss()
-                            }
-                        }
-                    },
-                    onDragCancel = { isDragging = false },
-                    onVerticalDrag = { change, dragAmount ->
-                        change.consume()
-                        dragOffset += dragAmount
-                    }
-                )
-            }
-            .clickable(
-                interactionSource = remember { MutableInteractionSource() },
-                indication = null
-            ) {
-                onlyCollapseWhenClicked()
-            },
-        contentAlignment = Alignment.BottomCenter
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .graphicsLayer(
-                    translationY = animatedOffset.value,
-                    scaleX = animatedScale.value,
-                    scaleY = animatedScale.value,
-                    alpha = animatedAlpha.value
-                ),
-            contentAlignment = Alignment.BottomCenter
-        ) {
-            content()
-        }
-    }
-}
-
-@SuppressLint("UnspecifiedRegisterReceiverFlag")
-@Composable
-fun NewControlCenterDialogContent(
-    service: AirPodsService?,
-    isNoiseControlExpanded: Boolean,
-    onNoiseControlExpandedChange: (Boolean) -> Unit
-) {
-    val context = LocalContext.current
-    val sharedPreferences = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
-    val textColor = Color.White
-
-    var currentAncMode by remember { mutableStateOf(NoiseControlMode.TRANSPARENCY) }
-    var isConvAwarenessEnabled by remember { mutableStateOf(false) }
-
-    val isOffModeEnabled = remember { sharedPreferences.getBoolean("off_listening_mode", true) }
-    val availableModes = remember(isOffModeEnabled) {
-        mutableListOf(
-            NoiseControlMode.TRANSPARENCY,
-            NoiseControlMode.ADAPTIVE,
-            NoiseControlMode.NOISE_CANCELLATION
-        ).apply {
-            if (isOffModeEnabled) {
-                add(0, NoiseControlMode.OFF)
-            }
-        }
-    }
-
-    val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
-    val maxVolume = remember { audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) }
-    var currentVolumeInt by remember { mutableIntStateOf(audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)) }
-    val animatedVolumeFraction by animateFloatAsState(
-        targetValue = currentVolumeInt.toFloat() / maxVolume.toFloat(),
-        animationSpec = spring(
-            dampingRatio = Spring.DampingRatioLowBouncy,
-            stiffness = Spring.StiffnessMediumLow
-        ),
-        label = "VolumeAnimation"
-    )
-    var liveDragFraction by remember { mutableFloatStateOf(animatedVolumeFraction) }
-    var isDraggingVolume by remember { mutableStateOf(false) }
-    LaunchedEffect(animatedVolumeFraction, isDraggingVolume) {
-        if (!isDraggingVolume) {
-            liveDragFraction = animatedVolumeFraction
-        }
-    }
-
-    DisposableEffect(service, availableModes) {
-        val ancReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                if (intent.action == AirPodsNotifications.ANC_DATA && service != null) {
-                    val newModeOrdinal = intent.getIntExtra("data", NoiseControlMode.TRANSPARENCY.ordinal + 1) - 1
-                    val newMode = NoiseControlMode.entries.getOrElse(newModeOrdinal) { NoiseControlMode.TRANSPARENCY }
-                    if (availableModes.contains(newMode)) {
-                         currentAncMode = newMode
-                    } else if (newMode == NoiseControlMode.OFF && !isOffModeEnabled) {
-                        currentAncMode = NoiseControlMode.TRANSPARENCY
-                    }
-                    Log.d("QSActivity", "ANC Receiver updated mode to: $currentAncMode (available: ${availableModes.joinToString()})")
-                }
-            }
-        }
-        val filter = IntentFilter(AirPodsNotifications.ANC_DATA)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            context.registerReceiver(ancReceiver, filter, Context.RECEIVER_EXPORTED)
-        } else {
-            context.registerReceiver(ancReceiver, filter)
-        }
-
-        service?.let {
-            val initialModeOrdinal = it.getANC().minus(1)
-            var initialMode = NoiseControlMode.entries.getOrElse(initialModeOrdinal) { NoiseControlMode.TRANSPARENCY }
-            if (!availableModes.contains(initialMode)) {
-                initialMode = NoiseControlMode.TRANSPARENCY
-            }
-            currentAncMode = initialMode
-            isConvAwarenessEnabled = sharedPreferences.getBoolean("conversational_awareness", true)
-            Log.d("QSActivity", "Initial ANC: $currentAncMode, ConvAware: $isConvAwarenessEnabled")
-        }
-
-        onDispose {
-            context.unregisterReceiver(ancReceiver)
-        }
-    }
-
-    DisposableEffect(Unit) {
-        val volumeReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                if (intent.action == "android.media.VOLUME_CHANGED_ACTION") {
-                    val newVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
-                    if (newVolume != currentVolumeInt) {
-                        currentVolumeInt = newVolume
-                        Log.d("QSActivity", "Volume Receiver updated volume to: $currentVolumeInt")
-                    }
-                }
-            }
-        }
-        val filter = IntentFilter("android.media.VOLUME_CHANGED_ACTION")
-        context.registerReceiver(volumeReceiver, filter)
-        onDispose {
-            context.unregisterReceiver(volumeReceiver)
-        }
-    }
-
-    val deviceName = remember { sharedPreferences.getString("name", "AirPods") ?: "AirPods" }
-
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .background(Color.Transparent)
-            .padding(horizontal = 24.dp)
-            .pointerInput(Unit) {
-                awaitPointerEventScope {
-                    while (true) {
-                        awaitPointerEvent()
-                    }
-                }
-            },
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.SpaceBetween
-    ) {
-        if (service != null) {
-            Spacer(modifier = Modifier.weight(1f))
-
-            Column(
-                modifier = Modifier
-                    .weight(2f)
-                    .fillMaxWidth(),
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center
-            ) {
-                Icon(
-                    painter = painterResource(id = R.drawable.airpods),
-                    contentDescription = "Device Icon",
-                    tint = textColor.copy(alpha = 0.8f),
-                    modifier = Modifier.size(48.dp)
-                )
-
-                Spacer(modifier = Modifier.height(4.dp))
-
-                Text(
-                    text = deviceName,
-                    color = textColor,
-                    fontSize = 16.sp,
-                    fontWeight = FontWeight.Medium
-                )
-
-                Spacer(modifier = Modifier.height(32.dp))
-
-                VerticalVolumeSlider(
-                    displayFraction = animatedVolumeFraction,
-                    maxVolume = maxVolume,
-                    onVolumeChange = { newVolume ->
-                        currentVolumeInt = newVolume
-                        try {
-                            audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, newVolume, 0)
-                        } catch (e: Exception) { Log.e("QSActivity", "Failed to set volume", e) }
-                    },
-                    initialFraction = animatedVolumeFraction,
-                    onDragStateChange = { dragging -> isDraggingVolume = dragging },
-                    baseSliderHeight = 400.dp,
-                    baseSliderWidth = 145.dp,
-                    baseCornerRadius = 48.dp,
-                    maxStretchFactor = 1.15f,
-                    minCompressionFactor = 0.875f,
-                    stretchSensitivity = 0.3f,
-                    compressionSensitivity = 0.3f,
-                    cornerRadiusChangeFactor = -0.5f,
-                    directionalStretchRatio = 0.75f,
-                    modifier = Modifier
-                        .width(145.dp)
-                        .padding(vertical = 8.dp)
-                )
-            }
-
-            Spacer(modifier = Modifier.weight(1f))
-
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(bottom = 72.dp)
-                    .animateContentSize(
-                        animationSpec = spring(
-                            dampingRatio = Spring.DampingRatioMediumBouncy,
-                            stiffness = Spring.StiffnessMedium
-                        )
-                    ),
-                contentAlignment = Alignment.Center
-            ) {
-                Crossfade(
-                    targetState = isNoiseControlExpanded,
-                    animationSpec = tween(durationMillis = 300),
-                    label = "NoiseControlCrossfade"
-                ) { expanded ->
-                    if (expanded) {
-                        ControlCenterNoiseControlSegmentedButton(
-                            availableModes = availableModes,
-                            selectedMode = currentAncMode,
-                            onModeSelected = { newMode ->
-                                service.aacpManager.sendControlCommand(
-                                    identifier = AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE.value,
-                                    value = newMode.ordinal + 1
-                                )
-                                currentAncMode = newMode
-                            },
-                            modifier = Modifier.fillMaxWidth(0.8f)
-                        )
-                    } else {
-                        Row(
-                            modifier = Modifier.fillMaxWidth(0.85f),
-                            horizontalArrangement = Arrangement.SpaceBetween,
-                            verticalAlignment = Alignment.Top
-                        ) {
-                            val noiseControlButtonBrush = if (currentAncMode == NoiseControlMode.ADAPTIVE) {
-                                AdaptiveRainbowBrush
-                            } else {
-                                null
-                            }
-
-                            Column(
-                                horizontalAlignment = Alignment.CenterHorizontally,
-                                verticalArrangement = Arrangement.Center,
-                                modifier = Modifier.weight(1f)
-                            ) {
-                                Box(
-                                    modifier = Modifier
-                                        .size(IconAreaSize)
-                                        .clip(CircleShape)
-                                        .background(
-                                            brush = noiseControlButtonBrush ?:
-                                                Brush.linearGradient(colors = listOf(Color(0xFF0A84FF), Color(0xFF0A84FF)))
-                                        )
-                                        .clickable(
-                                            onClick = { onNoiseControlExpandedChange(true) },
-                                            indication = null,
-                                            interactionSource = remember { MutableInteractionSource() }
-                                        ),
-                                    contentAlignment = Alignment.Center
-                                ) {
-                                    Icon(
-                                        painter = painterResource(id = getModeIconRes(currentAncMode)),
-                                        contentDescription = getModeLabel(currentAncMode),
-                                        tint = Color.White,
-                                        modifier = Modifier.size(32.dp)
-                                    )
-                                }
-
-                                Spacer(modifier = Modifier.height(8.dp))
-
-                                Text(
-                                    text = getModeLabel(currentAncMode),
-                                    color = Color.White,
-                                    fontSize = 12.sp,
-                                    fontWeight = FontWeight.Medium,
-                                    textAlign = androidx.compose.ui.text.style.TextAlign.Center
-                                )
-                            }
-
-                            Spacer(modifier = Modifier.width(24.dp))
-
-                            Column(
-                                horizontalAlignment = Alignment.CenterHorizontally,
-                                verticalArrangement = Arrangement.Center,
-                                modifier = Modifier.weight(1f)
-                            ) {
-                                Box(
-                                    modifier = Modifier
-                                        .size(IconAreaSize)
-                                        .clip(CircleShape)
-                                        .background(
-                                            Brush.linearGradient(
-                                                colors = listOf(
-                                                    if (isConvAwarenessEnabled) Color(0xFF0A84FF) else Color(0x593C3C3E),
-                                                    if (isConvAwarenessEnabled) Color(0xFF0A84FF) else Color(0x593C3C3E)
-                                                )
-                                            )
-                                        )
-                                        .clickable(
-                                            onClick = {
-                                                val newState = !isConvAwarenessEnabled
-                                                service.aacpManager.sendControlCommand(
-                                                    identifier = AACPManager.Companion.ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG.value,
-                                                    value = newState
-                                                )
-                                                isConvAwarenessEnabled = newState
-                                            },
-                                            indication = null,
-                                            interactionSource = remember { MutableInteractionSource() }
-                                        ),
-                                    contentAlignment = Alignment.Center
-                                ) {
-                                    Icon(
-                                        painter = painterResource(id = R.drawable.airpods),
-                                        contentDescription = "Conversational Awareness",
-                                        tint = Color.White,
-                                        modifier = Modifier.size(32.dp)
-                                    )
-                                }
-
-                                Spacer(modifier = Modifier.height(8.dp))
-
-                                Text(
-                                    text = "Conversational\nAwareness",
-                                    color = Color.White,
-                                    fontSize = 12.sp,
-                                    fontWeight = FontWeight.Medium,
-                                    textAlign = androidx.compose.ui.text.style.TextAlign.Center,
-                                    lineHeight = 14.sp
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-
-        } else {
-            Spacer(modifier = Modifier.weight(1f))
-            Box(modifier = Modifier.fillMaxWidth(), contentAlignment = Alignment.Center) {
-                Text("Loading...", color = textColor)
-            }
-            Spacer(modifier = Modifier.weight(1f))
-        }
-    }
-}
-
-private fun getModeIconRes(mode: NoiseControlMode): Int {
-    return when (mode) {
-        NoiseControlMode.OFF -> R.drawable.noise_cancellation
-        NoiseControlMode.TRANSPARENCY -> R.drawable.transparency
-        NoiseControlMode.ADAPTIVE -> R.drawable.adaptive
-        NoiseControlMode.NOISE_CANCELLATION -> R.drawable.noise_cancellation
-    }
-}
-
-private fun getModeLabel(mode: NoiseControlMode): String {
-    return when (mode) {
-        NoiseControlMode.OFF -> "Off"
-        NoiseControlMode.TRANSPARENCY -> "Transparency"
-        NoiseControlMode.ADAPTIVE -> "Adaptive"
-        NoiseControlMode.NOISE_CANCELLATION -> "Noise Cancel"
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/bluetooth/ATTManager.kt

@@ -1,211 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.bluetooth
-
-import android.util.Log
-import java.util.concurrent.ConcurrentHashMap
-import java.util.concurrent.LinkedBlockingQueue
-import java.util.concurrent.TimeUnit
-import java.util.concurrent.atomic.AtomicBoolean
-
-private const val TAG = "ATTManager"
-
-enum class ATTHandles(val value: Int) {
-    TRANSPARENCY(0x18),
-    LOUD_SOUND_REDUCTION(0x1B),
-    HEARING_AID(0x2A)
-}
-
-enum class ATTCCCDHandles(val value: Int) {
-    TRANSPARENCY(ATTHandles.TRANSPARENCY.value + 1),
-//    LOUD_SOUND_REDUCTION(ATTHandles.LOUD_SOUND_REDUCTION.value + 1), // doesn't work
-    HEARING_AID(ATTHandles.HEARING_AID.value + 1)
-}
-
-class ATTManagerv2 {
-    val characteristicList = mutableMapOf<ATTHandles, ByteArray>()
-
-    private val responseQueues = ConcurrentHashMap<Byte, LinkedBlockingQueue<ByteArray>>()
-
-    private val readerRunning = AtomicBoolean(false)
-    private var readerThread: Thread? = null
-
-    private var onNotificationReceived: ((handle: Byte, value: ByteArray) -> Unit)? = null
-
-    fun startReader() {
-        if (readerRunning.getAndSet(true)) return
-
-        readerThread = Thread {
-            try {
-                runReaderLoop()
-            } catch (t: Throwable) {
-                Log.e(TAG, "reader thread crashed: ${t.message}", t)
-            } finally {
-                readerRunning.set(false)
-                Log.d(TAG, "reader thread stopped")
-            }
-        }.also { it.name = "ATT-Reader"; it.isDaemon = true; it.start() }
-        Log.d(TAG, "reader started")
-    }
-
-    fun stopReader() {
-        readerRunning.set(false)
-        readerThread?.interrupt()
-        readerThread = null
-    }
-
-    fun setOnNotificationReceived(listener: ((handle: Byte, value: ByteArray) -> Unit)?) {
-        onNotificationReceived = listener
-    }
-
-    fun enableNotification(handle: ATTCCCDHandles) {
-        writeCharacteristic(handle.value.toByte(), byteArrayOf(0x01))
-    }
-
-    fun getCharacteristic(handle: ATTHandles): ByteArray? {
-        val storedValue = characteristicList[handle]
-        return if (storedValue?.isNotEmpty() != true) {
-            readCharacteristic(handle)
-        } else storedValue
-    }
-
-    fun readCharacteristic(handle: ATTHandles, timeoutMillis: Long = 2000): ByteArray? {
-        val socket = BluetoothConnectionManager.getATTSocket() ?: return null
-        try {
-            val output = socket.outputStream
-            val pdu = byteArrayOf(0x0A, handle.value.toByte(), 0x00)
-            synchronized(output) {
-                output.write(pdu)
-                output.flush()
-            }
-            Log.d(TAG, "sending read request: ${pdu.joinToString(" ") { String.format("%02X", it) }}")
-
-            val resp = waitForResponse(0x0B, timeoutMillis) ?: run {
-                Log.e(TAG, "Timeout waiting for Read Response (0x0B) for handle ${handle.value}")
-                return null
-            }
-
-            Log.d(TAG, "read response: ${resp.joinToString(" ") { String.format("%02X", it) }}")
-            val value = resp.copyOfRange(1, resp.size)
-            characteristicList[handle] = value
-            return value
-        } catch (e: Exception) {
-            Log.e(TAG, "error reading characteristic: ${e.message}")
-            return null
-        }
-    }
-
-    fun writeCharacteristic(handle: ATTHandles, data: ByteArray, timeoutMillis: Long = 2000) {
-        characteristicList[handle] = data
-        writeCharacteristic(handle.value.toByte(), data, timeoutMillis)
-    }
-
-    fun writeCharacteristic(handle: Byte, data: ByteArray, timeoutMillis: Long = 2000) {
-        val socket = BluetoothConnectionManager.getATTSocket() ?: return
-        try {
-            val output = socket.outputStream
-            val pdu = byteArrayOf(0x12, handle, 0x00) + data // 0x00 for LE
-            synchronized(output) {
-                output.write(pdu)
-                output.flush()
-            }
-            Log.d(TAG, "sending write request: ${pdu.joinToString(" ") { String.format("%02X", it) }}")
-
-            val resp = waitForResponse(0x13, timeoutMillis) ?: run {
-                Log.e(TAG, "timeout waiting for response (0x13) for handle ${String.format("%02X", handle)}")
-                return
-            }
-
-            Log.d(TAG, "write respose: ${resp.joinToString(" ") { String.format("%02X", it) }}")
-        } catch (e: Exception) {
-            Log.e(TAG, "error writing characteristic: ${e.message}")
-        }
-    }
-
-    fun disconnected() {
-        characteristicList.clear()
-        stopReader()
-        val socket = BluetoothConnectionManager.getATTSocket() ?: return
-        try {
-            socket.close()
-        } catch (e: Exception) {
-            Log.w(TAG, "error closing socket: ${e.message}")
-        }
-        Log.d(TAG, "ATT disconnected")
-    }
-
-    private fun runReaderLoop() {
-        val socket = BluetoothConnectionManager.getATTSocket() ?: run {
-            Log.w(TAG, "ATT socket not available. stopping reader")
-            readerRunning.set(false)
-            return
-        }
-
-        val input = socket.inputStream
-        val buffer = ByteArray(512)
-
-        while (readerRunning.get()) {
-            try {
-                val len = input.read(buffer)
-                if (len == -1) {
-                    Log.w(TAG, "ATT input stream ended")
-                    break
-                }
-                val data = buffer.copyOfRange(0, len)
-                if (data.isEmpty()) continue
-
-                val opcode = data[0]
-                Log.d(TAG, "pdu received ${data.joinToString(" ") { String.format("%02X", it) }}")
-
-                val queue = responseQueues.computeIfAbsent(opcode) { LinkedBlockingQueue() }
-                queue.offer(data)
-
-                if (opcode == 0x1B.toByte()) {
-                    if (data.size >= 3) {
-                        val handle = data[1]
-                        val value = if (data.size > 3) data.copyOfRange(3, data.size) else ByteArray(0)
-                        Log.d(TAG, "notification/indication handle=0x${String.format("%02X", handle)} value=${value.toHexString()}")
-                        try {
-                            onNotificationReceived?.invoke(handle, value)
-                        } catch (t: Throwable) {
-                            Log.e(TAG, "onNotificationReceived threw: ${t.message}", t)
-                        }
-                    } else {
-                        Log.w(TAG, "notification PDU too short: ${data.joinToString(" ") { String.format("%02X", it) }}")
-                    }
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "error in reader loop: ${e.message}", e)
-                break
-            }
-        }
-
-        readerRunning.set(false)
-    }
-
-    private fun waitForResponse(opcode: Byte, timeoutMillis: Long): ByteArray? {
-        val queue = responseQueues.computeIfAbsent(opcode) { LinkedBlockingQueue() }
-        return try {
-            queue.poll(timeoutMillis, TimeUnit.MILLISECONDS)
-        } catch (e: Exception) {
-            e.printStackTrace()
-            null
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/bluetooth/BluetoothConnectionManager.kt

@@ -1,39 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.bluetooth
-
-import android.bluetooth.BluetoothSocket
-
-object BluetoothConnectionManager {
-    private var aacpSocket: BluetoothSocket? = null
-    private var attSocket: BluetoothSocket? = null
-
-    fun setCurrentConnection(aacpSocket: BluetoothSocket?, attSocket: BluetoothSocket?) {
-        BluetoothConnectionManager.aacpSocket = aacpSocket
-        BluetoothConnectionManager.attSocket = attSocket
-    }
-
-    fun getAACPSocket(): BluetoothSocket? {
-        return aacpSocket
-    }
-
-    fun getATTSocket(): BluetoothSocket? {
-        return attSocket
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/data/AirPods.kt

@@ -1,277 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.data
-
-import me.kavishdevar.librepods.R
-
-open class AirPodsBase(
-    val modelNumber: List<String>,
-    val name: String,
-    val displayName: String = "AirPods",
-    val manufacturer: String = "Apple Inc.",
-    val budCaseRes: Int,
-    val budsRes: Int,
-    val leftBudsRes: Int,
-    val rightBudsRes: Int,
-    val caseRes: Int,
-    val capabilities: Set<Capability>
-)
-enum class Capability {
-    LISTENING_MODE,
-    CONVERSATION_AWARENESS,
-    STEM_CONFIG,
-    HEAD_GESTURES,
-    LOUD_SOUND_REDUCTION,
-    PPE,
-    SLEEP_DETECTION,
-    HEARING_AID,
-    ADAPTIVE_AUDIO,
-    ADAPTIVE_VOLUME,
-    SWIPE_FOR_VOLUME,
-    HRM
-}
-
-class AirPods: AirPodsBase(
-    modelNumber = listOf("A1523", "A1722"),
-    name = "AirPods 1",
-    // budCaseRes = R.drawable.airpods_1
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_1_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_1_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_1_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_1_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = emptySet()
-)
-
-class AirPods2: AirPodsBase(
-    modelNumber = listOf("A2032", "A2031"),
-    name = "AirPods 2",
-    // budCaseRes = R.drawable.airpods_2
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_2_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_2_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_2_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_2_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = emptySet()
-)
-
-class AirPods3: AirPodsBase(
-    modelNumber = listOf("A2565", "A2564"),
-    name = "AirPods 3",
-    // budCaseRes = R.drawable.airpods_3
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_3_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_3_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_3_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_3_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.HEAD_GESTURES
-    )
-)
-
-class AirPods4: AirPodsBase(
-    modelNumber = listOf("A3053", "A3050", "A3054"),
-    name = "AirPods 4",
-    // budCaseRes = R.drawable.airpods_4
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_4_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_4_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_4_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_4_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.HEAD_GESTURES,
-        Capability.SLEEP_DETECTION,
-        Capability.ADAPTIVE_VOLUME
-    )
-)
-
-class AirPods4ANC: AirPodsBase(
-    modelNumber = listOf("A3056", "A3055", "A3057"),
-    name = "AirPods 4 (ANC)",
-    // budCaseRes = R.drawable.airpods_4
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_4_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_4_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_4_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_4_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.LISTENING_MODE,
-        Capability.CONVERSATION_AWARENESS,
-        Capability.HEAD_GESTURES,
-        Capability.ADAPTIVE_AUDIO,
-        Capability.SLEEP_DETECTION,
-        Capability.ADAPTIVE_VOLUME,
-        Capability.STEM_CONFIG
-    )
-)
-
-class AirPodsPro1: AirPodsBase(
-    modelNumber = listOf("A2084", "A2083"),
-    name = "AirPods Pro 1",
-    displayName = "AirPods Pro",
-    // budCaseRes = R.drawable.airpods_pro_1
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_pro_1_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_pro_1_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_pro_1_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_pro_1_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.LISTENING_MODE
-    )
-)
-
-class AirPodsPro2Lightning: AirPodsBase(
-    modelNumber = listOf("A2931", "A2699", "A2698"),
-    name = "AirPods Pro 2 with Magsafe Charging Case (Lightning)",
-    displayName = "AirPods Pro",
-    // budCaseRes = R.drawable.airpods_pro_2
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_pro_2_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_pro_2_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_pro_2_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_pro_2_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.LISTENING_MODE,
-        Capability.CONVERSATION_AWARENESS,
-        Capability.STEM_CONFIG,
-        Capability.LOUD_SOUND_REDUCTION,
-        Capability.SLEEP_DETECTION,
-        Capability.HEARING_AID,
-        Capability.ADAPTIVE_AUDIO,
-        Capability.ADAPTIVE_VOLUME,
-        Capability.SWIPE_FOR_VOLUME,
-        Capability.HEAD_GESTURES
-    )
-)
-
-class AirPodsPro2USBC: AirPodsBase(
-    modelNumber = listOf("A3047", "A3048", "A3049"),
-    name = "AirPods Pro 2 with Magsafe Charging Case (USB-C)",
-    displayName = "AirPods Pro",
-    // budCaseRes = R.drawable.airpods_pro_2
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_pro_2_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_pro_2_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_pro_2_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_pro_2_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.LISTENING_MODE,
-        Capability.CONVERSATION_AWARENESS,
-        Capability.STEM_CONFIG,
-        Capability.LOUD_SOUND_REDUCTION,
-        Capability.SLEEP_DETECTION,
-        Capability.HEARING_AID,
-        Capability.ADAPTIVE_AUDIO,
-        Capability.ADAPTIVE_VOLUME,
-        Capability.SWIPE_FOR_VOLUME,
-        Capability.HEAD_GESTURES
-    )
-)
-
-class AirPodsPro3: AirPodsBase(
-    modelNumber = listOf("A3063", "A3064", "A3065"),
-    name = "AirPods Pro 3",
-    displayName = "AirPods Pro",
-    // budCaseRes = R.drawable.airpods_pro_3
-    budCaseRes = R.drawable.airpods_pro_2,
-    // budsRes = R.drawable.airpods_pro_3_buds
-    budsRes = R.drawable.airpods_pro_2_buds,
-    // leftBudsRes = R.drawable.airpods_pro_3_left
-    leftBudsRes = R.drawable.airpods_pro_2_left,
-    // rightBudsRes = R.drawable.airpods_pro_3_right
-    rightBudsRes = R.drawable.airpods_pro_2_right,
-    // caseRes = R.drawable.airpods_pro_3_case
-    caseRes = R.drawable.airpods_pro_2_case,
-    capabilities = setOf(
-        Capability.LISTENING_MODE,
-        Capability.CONVERSATION_AWARENESS,
-        Capability.HEAD_GESTURES,
-        Capability.STEM_CONFIG,
-        Capability.LOUD_SOUND_REDUCTION,
-        Capability.PPE,
-        Capability.SLEEP_DETECTION,
-        Capability.HEARING_AID,
-        Capability.ADAPTIVE_AUDIO,
-        Capability.ADAPTIVE_VOLUME,
-        Capability.SWIPE_FOR_VOLUME,
-        Capability.HRM
-    )
-)
-
-data class AirPodsInstance(
-    val name: String,
-    val model: AirPodsBase,
-    val actualModelNumber: String,
-    val serialNumber: String?,
-    val leftSerialNumber: String?,
-    val rightSerialNumber: String?,
-    val version1: String?,
-    val version2: String?,
-    val version3: String?,
-)
-
-object AirPodsModels {
-    val models: List<AirPodsBase> = listOf(
-        AirPods(),
-        AirPods2(),
-        AirPods3(),
-        AirPods4(),
-        AirPods4ANC(),
-        AirPodsPro1(),
-        AirPodsPro2Lightning(),
-        AirPodsPro2USBC(),
-        AirPodsPro3()
-    )
-
-    fun getModelByModelNumber(modelNumber: String): AirPodsBase? {
-        return models.find { modelNumber in it.modelNumber }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/data/ControlCommandRepository.kt

@@ -1,70 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.data
-
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.bluetooth.AACPManager.Companion.ControlCommandIdentifiers
-
-class ControlCommandRepository(
-    private val aacpManager: AACPManager
-) {
-    fun getValue(
-        identifier: ControlCommandIdentifiers
-    ): ByteArray? {
-        return aacpManager.controlCommandStatusList
-            .find { it.identifier == identifier }
-            ?.value
-    }
-
-    fun setValue(
-        id: ControlCommandIdentifiers,
-        value: ByteArray
-    ) {
-        aacpManager.sendControlCommand(id.value, value)
-    }
-
-
-    fun observe(
-        identifier: ControlCommandIdentifiers,
-        onChange: (ByteArray) -> Unit
-    ): AACPManager.ControlCommandListener {
-
-        val listener = object : AACPManager.ControlCommandListener {
-            override fun onControlCommandReceived(controlCommand: AACPManager.ControlCommand) {
-                onChange(controlCommand.value)
-            }
-        }
-
-        aacpManager.registerControlCommandListener(identifier, listener)
-        return listener
-    }
-
-    fun remove(
-        identifier: ControlCommandIdentifiers,
-        listener: AACPManager.ControlCommandListener
-    ) {
-        aacpManager.unregisterControlCommandListener(identifier, listener)
-    }
-
-    fun getMap(): Map<ControlCommandIdentifiers, ByteArray> {
-        return aacpManager.controlCommandStatusList.associate {
-            it.identifier to it.value
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/data/Packets.kt

@@ -1,270 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.data
-
-import android.os.Parcelable
-import android.util.Log
-import kotlinx.parcelize.Parcelize
-
-enum class Enums(val value: ByteArray) {
-    NOISE_CANCELLATION(Capabilities.NOISE_CANCELLATION),
-    PREFIX(byteArrayOf(0x04, 0x00, 0x04, 0x00)),
-    SETTINGS(byteArrayOf(0x09, 0x00)),
-    NOISE_CANCELLATION_PREFIX(PREFIX.value + SETTINGS.value + NOISE_CANCELLATION.value),
-    CONVERSATION_AWARENESS_RECEIVE_PREFIX(PREFIX.value + byteArrayOf(0x4b, 0x00, 0x02, 0x00)),
-}
-
-object BatteryComponent {
-    const val LEFT = 4
-    const val RIGHT = 2
-    const val CASE = 8
-}
-
-object BatteryStatus {
-    const val CHARGING = 1
-    const val NOT_CHARGING = 2
-    const val DISCONNECTED = 4
-    const val OPTIMIZED_CHARGING = 5
-}
-
-@Parcelize
-data class Battery(val component: Int, val level: Int, val status: Int) : Parcelable {
-    fun getComponentName(): String? {
-        return when (component) {
-            BatteryComponent.LEFT -> "LEFT"
-            BatteryComponent.RIGHT -> "RIGHT"
-            BatteryComponent.CASE -> "CASE"
-            else -> null
-        }
-    }
-
-    fun getStatusName(): String? {
-        return when (status) {
-            BatteryStatus.CHARGING -> "CHARGING"
-            BatteryStatus.NOT_CHARGING -> "NOT_CHARGING"
-            BatteryStatus.DISCONNECTED -> "DISCONNECTED"
-            BatteryStatus.OPTIMIZED_CHARGING -> "OPTIMIZED_CHARGING"
-            else -> null
-        }
-    }
-}
-
-enum class NoiseControlMode {
-    OFF,  NOISE_CANCELLATION, TRANSPARENCY, ADAPTIVE
-}
-
-class AirPodsNotifications {
-    companion object {
-        const val AIRPODS_CONNECTED = "me.kavishdevar.librepods.AIRPODS_CONNECTED"
-        const val AIRPODS_L2CAP_CONNECTED = "me.kavishdevar.librepods.AIRPODS_CONNECTED"
-        const val AIRPODS_DATA = "me.kavishdevar.librepods.AIRPODS_DATA"
-        const val EAR_DETECTION_DATA = "me.kavishdevar.librepods.EAR_DETECTION_DATA"
-        const val ANC_DATA = "me.kavishdevar.librepods.ANC_DATA"
-        const val BATTERY_DATA = "me.kavishdevar.librepods.BATTERY_DATA"
-        const val CA_DATA = "me.kavishdevar.librepods.CA_DATA"
-        const val AIRPODS_DISCONNECTED = "me.kavishdevar.librepods.AIRPODS_DISCONNECTED"
-        const val AIRPODS_CONNECTION_DETECTED = "me.kavishdevar.librepods.AIRPODS_CONNECTION_DETECTED"
-        const val DISCONNECT_RECEIVERS = "me.kavishdevar.librepods.DISCONNECT_RECEIVERS"
-        const val EQ_DATA = "me.kavishdevar.librepods.EQ_DATA"
-        const val AIRPODS_INFORMATION_UPDATED = "me.kavishdevar.librepods.AIRPODS_INFORMATION_UPDATED"
-    }
-
-    class EarDetection {
-        private val notificationBit = Capabilities.EAR_DETECTION
-        private val notificationPrefix = Enums.PREFIX.value + notificationBit
-
-        var status: List<Byte> = listOf(0x01, 0x01)
-
-        fun setStatus(data: ByteArray) {
-            status = listOf(data[6], data[7])
-        }
-
-        fun isEarDetectionData(data: ByteArray): Boolean {
-            if (data.size != 8) {
-                return false
-            }
-            val prefixHex = notificationPrefix.joinToString("") { "%02x".format(it) }
-            val dataHex = data.joinToString("") { "%02x".format(it) }
-            return dataHex.startsWith(prefixHex)
-        }
-    }
-
-    class ANC {
-        private val notificationPrefix = Enums.NOISE_CANCELLATION_PREFIX.value
-
-        var status: Int = 1
-            private set
-
-        fun isANCData(data: ByteArray): Boolean {
-            if (data.size != 11) {
-                return false
-            }
-            val prefixHex = notificationPrefix.joinToString("") { "%02x".format(it) }
-            val dataHex = data.joinToString("") { "%02x".format(it) }
-            return dataHex.startsWith(prefixHex)
-        }
-
-        fun setStatus(data: ByteArray) {
-            when (data.size) {
-                // if the whole packet is given
-                11 -> {
-                    status = data[7].toInt()
-                }
-                // if only the data is given
-                1 -> {
-                    status = data[0].toInt()
-                }
-                // if the value of control command is given
-                4 -> {
-                    status = data[0].toInt()
-                }
-                else -> {
-                    Log.d("ANC", "Invalid ANC data size: ${data.size}")
-                }
-            }
-        }
-
-        val name: String =
-            when (status) {
-                1 -> "OFF"
-                2 -> "ON"
-                3 -> "TRANSPARENCY"
-                4 -> "ADAPTIVE"
-                else -> "UNKNOWN"
-            }
-
-    }
-
-    class BatteryNotification {
-        private var first: Battery = Battery(BatteryComponent.LEFT, 0, BatteryStatus.DISCONNECTED)
-        private var second: Battery = Battery(BatteryComponent.RIGHT, 0, BatteryStatus.DISCONNECTED)
-        private var case: Battery = Battery(BatteryComponent.CASE, 0, BatteryStatus.DISCONNECTED)
-
-        fun isBatteryData(data: ByteArray): Boolean {
-            if (data.joinToString("") { "%02x".format(it) }.startsWith("040004000400")) {
-                Log.d("BatteryNotification", "Battery data starts with 040004000400. Most likely is a battery packet.")
-            } else {
-                return false
-            }
-            if (data.size != 22) {
-                Log.d("BatteryNotification", "Battery data size is not 22, probably being used with Airpods with fewer or more battery count.")
-                return false
-            }
-            Log.d("BatteryNotification", data.joinToString("") { "%02x".format(it) }.startsWith("040004000400").toString())
-            return data.joinToString("") { "%02x".format(it) }.startsWith("040004000400")
-        }
-
-        fun setBatteryDirect(
-            leftLevel: Int,
-            leftCharging: Boolean,
-            rightLevel: Int,
-            rightCharging: Boolean,
-            caseLevel: Int,
-            caseCharging: Boolean
-        ) {
-            first = Battery(BatteryComponent.LEFT, leftLevel, if (leftCharging) BatteryStatus.CHARGING else BatteryStatus.NOT_CHARGING)
-            second = Battery(BatteryComponent.RIGHT, rightLevel, if (rightCharging) BatteryStatus.CHARGING else BatteryStatus.NOT_CHARGING)
-            case = Battery(BatteryComponent.CASE, caseLevel, if (caseCharging) BatteryStatus.CHARGING else BatteryStatus.NOT_CHARGING)
-        }
-
-        fun setBattery(data: ByteArray) {
-            if (data.size != 22) {
-                return
-            }
-//            first = if (data[10].toInt() == BatteryStatus.DISCONNECTED) {
-//                Battery(first.component, first.level, data[10].toInt())
-//            } else {
-//                Battery(data[7].toInt(), data[9].toInt(), data[10].toInt())
-//            }
-//            second = if (data[15].toInt() == BatteryStatus.DISCONNECTED) {
-//                Battery(second.component, second.level, data[15].toInt())
-//            } else {
-//                Battery(data[12].toInt(), data[14].toInt(), data[15].toInt())
-//            }
-//            case = if (data[20].toInt() == BatteryStatus.DISCONNECTED && case.status != BatteryStatus.DISCONNECTED) {
-//                Battery(case.component, case.level, data[20].toInt())
-//            } else {
-//                Battery(data[17].toInt(), data[19].toInt(), data[20].toInt())
-//            }
-//            sometimes it shows battery as -1%, just skip all that and set it normally
-            first = Battery(
-                data[7].toInt(), data[9].toInt(), data[10].toInt()
-            )
-            second = Battery(
-                data[12].toInt(), data[14].toInt(), data[15].toInt()
-            )
-            case = Battery(
-                data[17].toInt(), data[19].toInt(), data[20].toInt()
-            )
-        }
-
-        fun getBattery(): List<Battery> {
-            val left = if (first.component == BatteryComponent.LEFT) first else second
-            val right = if (first.component == BatteryComponent.LEFT) second else first
-            return listOf(left, right, case)
-        }
-    }
-
-    class ConversationalAwarenessNotification {
-        @Suppress("PrivatePropertyName")
-        private val NOTIFICATION_PREFIX = Enums.CONVERSATION_AWARENESS_RECEIVE_PREFIX.value
-
-        var status: Byte = 0
-            private set
-
-        fun isConversationalAwarenessData(data: ByteArray): Boolean {
-            if (data.size != 10) {
-                return false
-            }
-            val prefixHex = NOTIFICATION_PREFIX.joinToString("") { "%02x".format(it) }
-            val dataHex = data.joinToString("") { "%02x".format(it) }
-            return dataHex.startsWith(prefixHex)
-        }
-
-        fun setData(data: ByteArray) {
-            status = data[9]
-        }
-    }
-}
-
-class Capabilities {
-    companion object {
-        val NOISE_CANCELLATION = byteArrayOf(0x0d)
-        val EAR_DETECTION = byteArrayOf(0x06)
-    }
-}
-
-fun isHeadTrackingData(data: ByteArray): Boolean {
-    if (data.size <= 60) return false
-
-    val prefixPattern = byteArrayOf(
-        0x04, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00,
-        0x10, 0x00
-    )
-
-    for (i in prefixPattern.indices) {
-        if (data[i] != prefixPattern[i]) return false
-    }
-
-    if (data[10] != 0x44.toByte() && data[10] != 0x45.toByte()) return false
-
-    if (data[11] != 0x00.toByte()) return false
-
-    return true
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/AboutCard.kt

@@ -1,206 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Composable
-fun AboutCard(
-    navController: NavController,
-    modelName: String,
-    actualModel: String,
-    serialNumbers: List<String>,
-    version: String?
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-
-    Box(
-        modifier = Modifier
-            .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-            .padding(horizontal = 16.dp, vertical = 4.dp)
-    ){
-        Text(
-            text = stringResource(R.string.about),
-            style = TextStyle(
-                fontSize = 14.sp,
-                fontWeight = FontWeight.Bold,
-                color = textColor.copy(alpha = 0.6f),
-                fontFamily = FontFamily(Font(R.font.sf_pro))
-            )
-        )
-    }
-
-    val rowHeight = remember { mutableStateOf(0.dp) }
-    val density = LocalDensity.current
-
-    Column(
-        modifier = Modifier
-            .clip(RoundedCornerShape(28.dp))
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(28.dp))
-            .padding(top = 2.dp)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp)
-                .onGloballyPositioned { coordinates ->
-                    rowHeight.value = with(density) { coordinates.size.height.toDp() }
-                },
-            horizontalArrangement = Arrangement.SpaceBetween,
-        ) {
-            Text(
-                text = stringResource(R.string.model_name),
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = textColor,
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-            Text(
-                text = modelName,
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.8f),
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-        }
-        HorizontalDivider(
-            thickness = 1.dp,
-            color = Color(0x40888888),
-            modifier = Modifier
-                .padding(horizontal = 12.dp)
-        )
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-        ) {
-            Text(
-                text = stringResource(R.string.model_name),
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = textColor,
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-            Text(
-                text = actualModel,
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.8f),
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-        }
-        HorizontalDivider(
-            thickness = 1.dp,
-            color = Color(0x40888888),
-            modifier = Modifier
-                .padding(horizontal = 12.dp)
-        )
-        val serialNumbers = listOf(
-            serialNumbers[0],
-            "􀀛 ${serialNumbers[1]}",
-            "􀀧 ${serialNumbers[2]}"
-        )
-        val serialNumber = remember { mutableIntStateOf(0) }
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(16.dp),
-            horizontalArrangement = Arrangement.SpaceBetween,
-        ) {
-            Text(
-                text = stringResource(R.string.serial_number),
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = textColor,
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                ),
-            )
-            Text(
-                text = serialNumbers[serialNumber.intValue],
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.8f),
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                ),
-                modifier = Modifier
-                    .clickable(
-                        interactionSource = remember { MutableInteractionSource() },
-                        indication = null
-                    ) {
-                        serialNumber.intValue = (serialNumber.intValue + 1) % serialNumbers.size
-                    }
-            )
-        }
-        HorizontalDivider(
-            thickness = 1.dp,
-            color = Color(0x40888888),
-            modifier = Modifier
-                .padding(horizontal = 12.dp)
-        )
-        NavigationButton(
-            to = "version_info",
-            navController = navController,
-            name = stringResource(R.string.version),
-            currentState = version,
-            independent = false,
-            height = rowHeight.value + 32.dp
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/AppInfoCard.kt

@@ -1,193 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import me.kavishdevar.librepods.BuildConfig
-import me.kavishdevar.librepods.R
-
-@Composable
-fun AppInfoCard() {
-    val rowHeight = remember { mutableStateOf(0.dp) }
-    val density = LocalDensity.current
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    Column {
-        Box(
-            modifier = Modifier
-                .background(if (isDarkTheme) Color.Black else Color(0xFFF2F2F7))
-                .padding(start = 16.dp, bottom = 8.dp, end = 4.dp)
-        ) {
-            Text(
-                text = stringResource(R.string.about), style = TextStyle(
-                    fontSize = 14.sp,
-                    fontWeight = FontWeight.Bold,
-                    color = textColor.copy(alpha = 0.6f),
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-        }
-
-        Column(
-            modifier = Modifier
-                .clip(RoundedCornerShape(28.dp))
-                .fillMaxWidth()
-                .background(backgroundColor, RoundedCornerShape(28.dp))
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp)
-                    .onGloballyPositioned { coordinates ->
-                        rowHeight.value = with(density) { coordinates.size.height.toDp() }
-                    },
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.version), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = BuildConfig.VERSION_NAME, style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.version_code), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = BuildConfig.VERSION_CODE.toString(), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.flavor), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = BuildConfig.FLAVOR, style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.build_type), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = BuildConfig.BUILD_TYPE,
-                    style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/AudioSettings.kt

@@ -1,182 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import androidx.navigation.compose.rememberNavController
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Composable
-fun AudioSettings(
-    navController: NavController,
-    adaptiveVolumeCapability: Boolean,
-    conversationalAwarenessCapability: Boolean,
-    loudSoundReductionCapability: Boolean,
-    adaptiveAudioCapability: Boolean,
-
-    adaptiveVolumeChecked: Boolean,
-    onAdaptiveVolumeCheckedChange: (Boolean) -> Unit,
-
-    conversationalAwarenessChecked: Boolean,
-    onConversationalAwarenessCheckedChange: (Boolean) -> Unit,
-
-    loudSoundReductionChecked: Boolean,
-    onLoudSoundReductionCheckedChange: (Boolean) -> Unit,
-
-    vendorIdHook: Boolean,
-    isPremium: Boolean
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    if (!adaptiveVolumeCapability && !conversationalAwarenessCapability && !loudSoundReductionCapability && !adaptiveAudioCapability) {
-        return
-    }
-    Box(
-        modifier = Modifier
-            .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-            .padding(horizontal = 16.dp, vertical = 4.dp)
-    ){
-        Text(
-            text = stringResource(R.string.audio),
-            style = TextStyle(
-                fontSize = 14.sp,
-                fontWeight = FontWeight.Bold,
-                color = textColor.copy(alpha = 0.6f),
-                fontFamily = FontFamily(Font(R.font.sf_pro))
-            )
-        )
-    }
-
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-
-    Column(
-        modifier = Modifier
-            .clip(RoundedCornerShape(28.dp))
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(28.dp))
-            .padding(top = 2.dp)
-    ) {
-
-        if (adaptiveVolumeCapability) {
-            StyledToggle(
-                label = stringResource(R.string.personalized_volume),
-                description = stringResource(R.string.personalized_volume_description),
-                independent = false,
-                checked = adaptiveVolumeChecked,
-                onCheckedChange = onAdaptiveVolumeCheckedChange,
-                enabled = isPremium
-            )
-
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier
-                    .padding(horizontal = 12.dp)
-            )
-        }
-
-        if (conversationalAwarenessCapability) {
-            StyledToggle(
-                label = stringResource(R.string.conversational_awareness),
-                description = stringResource(R.string.conversational_awareness_description),
-                independent = false,
-                checked = conversationalAwarenessChecked,
-                onCheckedChange = onConversationalAwarenessCheckedChange,
-                enabled = isPremium
-            )
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier
-                    .padding(horizontal = 12.dp)
-            )
-        }
-
-        if (loudSoundReductionCapability && vendorIdHook){
-            StyledToggle(
-                label = stringResource(R.string.loud_sound_reduction),
-                description = stringResource(R.string.loud_sound_reduction_description),
-                independent = false,
-                checked = loudSoundReductionChecked,
-                onCheckedChange = onLoudSoundReductionCheckedChange,
-                enabled = isPremium
-            )
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier
-                    .padding(horizontal = 12.dp)
-            )
-        }
-
-        if (adaptiveAudioCapability) {
-            NavigationButton(
-                to = "adaptive_strength",
-                name = stringResource(R.string.adaptive_audio),
-                navController = navController,
-                independent = false
-            )
-        }
-    }
-}
-
-@Preview
-@Composable
-fun AudioSettingsPreview() {
-    AudioSettings(
-        navController = rememberNavController(),
-        adaptiveVolumeCapability = true,
-        conversationalAwarenessCapability = true,
-        loudSoundReductionCapability = true,
-        adaptiveAudioCapability = true,
-        adaptiveVolumeChecked = true,
-        onAdaptiveVolumeCheckedChange = { },
-        conversationalAwarenessChecked = true,
-        onConversationalAwarenessCheckedChange = { },
-        loudSoundReductionChecked = true,
-        onLoudSoundReductionCheckedChange = { },
-        vendorIdHook = true,
-        isPremium = true
-    )
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/BatteryView.kt

@@ -1,177 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.content.res.Configuration
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.layout.widthIn
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.res.imageResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.data.Battery
-import me.kavishdevar.librepods.data.BatteryComponent
-import me.kavishdevar.librepods.data.BatteryStatus
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Composable
-fun BatteryView(
-    batteryList: List<Battery>,
-    budsRes: Int,
-    caseRes: Int
-) {
-    val left = batteryList.find { it.component == BatteryComponent.LEFT }
-    val right = batteryList.find { it.component == BatteryComponent.RIGHT }
-    val case = batteryList.find { it.component == BatteryComponent.CASE }
-
-    val leftLevel = left?.level ?: 0
-    val rightLevel = right?.level ?: 0
-    val caseLevel = case?.level ?: 0
-
-    val caseCharging = case?.status == BatteryStatus.CHARGING ||
-        case?.status == BatteryStatus.OPTIMIZED_CHARGING
-
-    val singleDisplayed = remember { mutableStateOf(false) }
-
-    Box(
-        modifier = Modifier.fillMaxWidth(),
-        contentAlignment = Alignment.Center
-    ) {
-        Row(
-            modifier = Modifier.widthIn(max = 500.dp),
-            horizontalArrangement = Arrangement.Center
-        ) {
-            Column(
-                modifier = Modifier.weight(1f),
-                horizontalAlignment = Alignment.CenterHorizontally
-            ) {
-                Image(
-                    bitmap = ImageBitmap.imageResource(budsRes),
-                    contentDescription = stringResource(R.string.buds),
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(8.dp)
-                )
-
-                if (
-                    left?.status == right?.status &&
-                    (leftLevel - rightLevel) in -3..3
-                ) {
-                    BatteryIndicator(
-                        leftLevel.coerceAtMost(rightLevel),
-                        left?.status ?: BatteryStatus.NOT_CHARGING
-                    )
-                    singleDisplayed.value = true
-                } else {
-                    singleDisplayed.value = false
-
-                    Row(
-                        modifier = Modifier.fillMaxWidth(),
-                        horizontalArrangement = Arrangement.Center
-                    ) {
-                        if (leftLevel > 0 || left?.status != BatteryStatus.DISCONNECTED) {
-                            BatteryIndicator(
-                                leftLevel,
-                                left?.status ?: BatteryStatus.NOT_CHARGING,
-                                "\uDBC6\uDCE5"
-                            )
-                        }
-
-                        if (leftLevel > 0 && rightLevel > 0) {
-                            Spacer(modifier = Modifier.width(16.dp))
-                        }
-
-                        if (rightLevel > 0 || right?.status != BatteryStatus.DISCONNECTED) {
-                            BatteryIndicator(
-                                rightLevel,
-                                right?.status ?: BatteryStatus.NOT_CHARGING,
-                                "\uDBC6\uDCE8"
-                            )
-                        }
-                    }
-                }
-            }
-
-            Column(
-                modifier = Modifier.weight(1f),
-                horizontalAlignment = Alignment.CenterHorizontally
-            ) {
-                Image(
-                    bitmap = ImageBitmap.imageResource(caseRes),
-                    contentDescription = stringResource(R.string.case_alt),
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(8.dp)
-                )
-
-                if (caseLevel > 0 || case?.status != BatteryStatus.DISCONNECTED) {
-                    BatteryIndicator(
-                        caseLevel,
-                        case?.status ?: BatteryStatus.NOT_CHARGING,
-                        prefix = if (!singleDisplayed.value) "\uDBC3\uDE6C" else ""
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Preview(uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-fun BatteryViewPreview() {
-    val fakeBattery = listOf(
-        Battery(BatteryComponent.LEFT, 85, BatteryStatus.CHARGING),
-        Battery(BatteryComponent.RIGHT, 40, BatteryStatus.OPTIMIZED_CHARGING),
-        Battery(BatteryComponent.CASE, 60, BatteryStatus.NOT_CHARGING)
-    )
-
-    val bg = if (isSystemInDarkTheme()) Color.Black else Color(0xFFF2F2F7)
-
-    Box(
-        modifier = Modifier
-            .background(bg)
-            .padding(16.dp)
-    ) {
-        BatteryView(
-            batteryList = fakeBattery,
-            budsRes = R.drawable.airpods_pro_2_buds,
-            caseRes = R.drawable.airpods_pro_2_case
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/CallControlSettings.kt

@@ -1,432 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.util.Log
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.layout.positionInParent
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@ExperimentalHazeMaterialsApi
-@Composable
-fun CallControlSettings(
-    hazeState: HazeState,
-    flipped: Boolean,
-    onCallControlValueChanged: (Boolean) -> Unit
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    Box(
-        modifier = Modifier
-            .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-            .padding(horizontal = 16.dp, vertical = 4.dp)
-    ){
-        Text(
-            text = stringResource(R.string.call_controls),
-            style = TextStyle(
-                fontSize = 14.sp,
-                fontWeight = FontWeight.Bold,
-                color = textColor.copy(alpha = 0.6f),
-                fontFamily = FontFamily(Font(R.font.sf_pro))
-            )
-        )
-    }
-
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(28.dp))
-            .padding(top = 2.dp)
-    ) {
-
-        val scope = rememberCoroutineScope()
-        val haptics = LocalHapticFeedback.current
-
-        val pressOnceText = stringResource(R.string.press_once)
-        val pressTwiceText = stringResource(R.string.press_twice)
-
-        var singlePressAction by remember { mutableStateOf(if (flipped) pressTwiceText else pressOnceText) }
-        var doublePressAction by remember { mutableStateOf(if (flipped) pressOnceText else pressTwiceText) }
-
-        var showSinglePressDropdown by remember { mutableStateOf(false) }
-        var touchOffsetSingle by remember { mutableStateOf<Offset?>(null) }
-        var boxPositionSingle by remember { mutableStateOf(Offset.Zero) }
-        var lastDismissTimeSingle by remember { mutableLongStateOf(0L) }
-        var parentHoveredIndexSingle by remember { mutableStateOf<Int?>(null) }
-        var parentDragActiveSingle by remember { mutableStateOf(false) }
-        var previousIdxSingle by remember { mutableStateOf<Int?>(null) }
-
-        var showDoublePressDropdown by remember { mutableStateOf(false) }
-        var touchOffsetDouble by remember { mutableStateOf<Offset?>(null) }
-        var boxPositionDouble by remember { mutableStateOf(Offset.Zero) }
-        var lastDismissTimeDouble by remember { mutableLongStateOf(0L) }
-        var parentHoveredIndexDouble by remember { mutableStateOf<Int?>(null) }
-        var parentDragActiveDouble by remember { mutableStateOf(false) }
-        var previousIdxDouble by remember { mutableStateOf<Int?>(null) }
-
-        LaunchedEffect(flipped) {
-            Log.d("CallControlSettings", "Call control flipped: $flipped")
-        }
-
-        val density = LocalDensity.current
-        val itemHeightPx = with(density) { 48.dp.toPx() }
-
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 16.dp)
-                    .height(58.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Text(
-                    text = stringResource(R.string.answer_call),
-                    fontSize = 16.sp,
-                    color = textColor,
-                    modifier = Modifier.padding(bottom = 4.dp)
-                )
-                Text(
-                    text = stringResource(R.string.press_once),
-                    fontSize = 16.sp,
-                    color = textColor.copy(alpha = 0.6f)
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier
-                    .padding(horizontal = 12.dp)
-            )
-
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 16.dp)
-                    .height(58.dp)
-                    .pointerInput(Unit) {
-                        detectTapGestures { offset ->
-                            val now = System.currentTimeMillis()
-                            if (showSinglePressDropdown) {
-                                showSinglePressDropdown = false
-                                lastDismissTimeSingle = now
-                            } else {
-                                if (now - lastDismissTimeSingle > 250L) {
-                                    touchOffsetSingle = offset
-                                    showSinglePressDropdown = true
-                                }
-                            }
-                        }
-                    }
-                    .pointerInput(Unit) {
-                        detectDragGesturesAfterLongPress(
-                            onDragStart = { offset ->
-                                val now = System.currentTimeMillis()
-                                touchOffsetSingle = offset
-                                if (!showSinglePressDropdown && now - lastDismissTimeSingle > 250L) {
-                                    showSinglePressDropdown = true
-                                }
-                                lastDismissTimeSingle = now
-                                parentDragActiveSingle = true
-                                parentHoveredIndexSingle = 0
-                            },
-                            onDrag = { change, _ ->
-                                val current = change.position
-                                val touch = touchOffsetSingle ?: current
-                                val posInPopupY = current.y - touch.y
-                                val idx = (posInPopupY / itemHeightPx).toInt()
-                                if (idx != previousIdxSingle) {
-                                    scope.launch { haptics.performHapticFeedback(HapticFeedbackType.SegmentTick) }
-                                }
-                                parentHoveredIndexSingle = idx
-                                previousIdxSingle = idx
-                            },
-                            onDragEnd = {
-                                parentDragActiveSingle = false
-                                parentHoveredIndexSingle?.let { idx ->
-                                    val options = listOf(pressOnceText, pressTwiceText)
-                                    if (idx in options.indices) {
-                                        val option = options[idx]
-                                        singlePressAction = option
-                                        doublePressAction =
-                                            if (option == pressOnceText) pressTwiceText else pressOnceText
-                                        showSinglePressDropdown = false
-                                        lastDismissTimeSingle = System.currentTimeMillis()
-                                        onCallControlValueChanged(option != pressOnceText)
-
-                                    }
-                                }
-                                if (parentHoveredIndexSingle != null && parentHoveredIndexSingle in 0..1) {
-                                    scope.launch { haptics.performHapticFeedback(HapticFeedbackType.GestureEnd) }
-                                }
-                                parentHoveredIndexSingle = null
-                            },
-                            onDragCancel = {
-                                parentDragActiveSingle = false
-                                parentHoveredIndexSingle = null
-                            }
-                        )
-                    },
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Text(
-                    text = stringResource(R.string.mute_unmute),
-                    fontSize = 16.sp,
-                    color = textColor,
-                    modifier = Modifier.padding(bottom = 4.dp)
-                )
-                Box(
-                    modifier = Modifier.onGloballyPositioned { coordinates ->
-                        boxPositionSingle = coordinates.positionInParent()
-                    }
-                ) {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Text(
-                            text = singlePressAction,
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = 0.8f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            )
-                        )
-                        Text(
-                            text = "􀆏",
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = 0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            modifier = Modifier
-                                .padding(start = 6.dp)
-                        )
-                    }
-
-                    StyledDropdown(
-                        expanded = showSinglePressDropdown,
-                        onDismissRequest = {
-                            showSinglePressDropdown = false
-                            lastDismissTimeSingle = System.currentTimeMillis()
-                        },
-                        options = listOf(pressOnceText, pressTwiceText),
-                        selectedOption = singlePressAction,
-                        touchOffset = touchOffsetSingle,
-                        boxPosition = boxPositionSingle,
-                        externalHoveredIndex = parentHoveredIndexSingle,
-                        externalDragActive = parentDragActiveSingle,
-                        onOptionSelected = { option ->
-                            singlePressAction = option
-                            doublePressAction =
-                                if (option == pressOnceText) pressTwiceText else pressOnceText
-                            showSinglePressDropdown = false
-                            val flipped = option != pressOnceText
-                            onCallControlValueChanged(flipped)
-                        },
-                        hazeState = hazeState
-                    )
-                }
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier
-                    .padding(horizontal = 12.dp)
-            )
-
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 16.dp)
-                    .height(58.dp)
-                    .pointerInput(Unit) {
-                        detectTapGestures { offset ->
-                            val now = System.currentTimeMillis()
-                            if (showDoublePressDropdown) {
-                                showDoublePressDropdown = false
-                                lastDismissTimeDouble = now
-                            } else {
-                                if (now - lastDismissTimeDouble > 250L) {
-                                    touchOffsetDouble = offset
-                                    showDoublePressDropdown = true
-                                }
-                            }
-                        }
-                    }
-                    .pointerInput(Unit) {
-                        detectDragGesturesAfterLongPress(
-                            onDragStart = { offset ->
-                                val now = System.currentTimeMillis()
-                                touchOffsetDouble = offset
-                                if (!showDoublePressDropdown && now - lastDismissTimeDouble > 250L) {
-                                    showDoublePressDropdown = true
-                                }
-                                lastDismissTimeDouble = now
-                                parentDragActiveDouble = true
-                                parentHoveredIndexDouble = 0
-                            },
-                            onDrag = { change, _ ->
-                                val current = change.position
-                                val touch = touchOffsetDouble ?: current
-                                val posInPopupY = current.y - touch.y
-                                val idx = (posInPopupY / itemHeightPx).toInt()
-                                if (idx != previousIdxDouble) {
-                                    scope.launch { haptics.performHapticFeedback(HapticFeedbackType.SegmentTick) }
-                                }
-                                parentHoveredIndexDouble = idx
-                                previousIdxDouble = idx
-                            },
-                            onDragEnd = {
-                                parentDragActiveDouble = false
-                                parentHoveredIndexDouble?.let { idx ->
-                                    val options = listOf(pressOnceText, pressTwiceText)
-                                    if (idx in options.indices) {
-                                        val option = options[idx]
-                                        doublePressAction = option
-                                        singlePressAction =
-                                            if (option == pressOnceText) pressTwiceText else pressOnceText
-                                        showDoublePressDropdown = false
-                                        lastDismissTimeDouble = System.currentTimeMillis()
-                                        val flipped = option == pressOnceText
-                                        onCallControlValueChanged(flipped)
-                                    }
-                                }
-                                if (parentHoveredIndexDouble != null && parentHoveredIndexDouble in 0..1) {
-                                    scope.launch { haptics.performHapticFeedback(HapticFeedbackType.GestureEnd) }
-                                }
-                                parentHoveredIndexDouble = null
-                            },
-                            onDragCancel = {
-                                parentDragActiveDouble = false
-                                parentHoveredIndexDouble = null
-                            }
-                        )
-                    },
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Text(
-                    text = stringResource(R.string.hang_up),
-                    fontSize = 16.sp,
-                    color = textColor,
-                    modifier = Modifier.padding(bottom = 4.dp)
-                )
-                Box(
-                    modifier = Modifier.onGloballyPositioned { coordinates ->
-                        boxPositionDouble = coordinates.positionInParent()
-                    }
-                ) {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Text(
-                            text = doublePressAction,
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = 0.8f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            )
-                        )
-                        Text(
-                            text = "􀆏",
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = 0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            modifier = Modifier
-                                .padding(start = 6.dp)
-                        )
-                    }
-
-                    StyledDropdown(
-                        expanded = showDoublePressDropdown,
-                        onDismissRequest = {
-                            showDoublePressDropdown = false
-                            lastDismissTimeDouble = System.currentTimeMillis()
-                        },
-                        options = listOf(pressOnceText, pressTwiceText),
-                        selectedOption = doublePressAction,
-                        touchOffset = touchOffsetDouble,
-                        boxPosition = boxPositionDouble,
-                        externalHoveredIndex = parentHoveredIndexDouble,
-                        externalDragActive = parentDragActiveDouble,
-                        onOptionSelected = { option ->
-                            doublePressAction = option
-                            singlePressAction =
-                                if (option == pressOnceText) pressTwiceText else pressOnceText
-                            showDoublePressDropdown = false
-                            val flipped = option == pressOnceText
-                            onCallControlValueChanged(flipped)
-                        },
-                        hazeState = hazeState
-                    )
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/ConfirmationDialog.kt

@@ -1,179 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.scaleIn
-import androidx.compose.animation.scaleOut
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.requiredWidthIn
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.MutableState
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.kyant.backdrop.backdrops.LayerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import com.kyant.backdrop.drawBackdrop
-import com.kyant.backdrop.effects.blur
-import com.kyant.backdrop.effects.lens
-import com.kyant.backdrop.effects.vibrancy
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import me.kavishdevar.librepods.R
-
-@ExperimentalHazeMaterialsApi
-@Composable
-fun ConfirmationDialog(
-    showDialog: MutableState<Boolean>,
-    title: String,
-    message: String,
-    confirmText: String = "Enable",
-    dismissText: String = "Cancel",
-    onConfirm: () -> Unit,
-    onDismiss: () -> Unit = { showDialog.value = false },
-    backdrop: LayerBackdrop,
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val accentColor = if (isDarkTheme) Color(0xFF0091FF) else Color(0xFF0088FF)
-
-    AnimatedVisibility(
-        visible = showDialog.value,
-        enter = scaleIn(initialScale = 1.05f) + fadeIn(),
-        exit = scaleOut(targetScale = 1.05f) + fadeOut()
-    ) {
-        Box(
-            modifier = Modifier.fillMaxSize(),
-            contentAlignment = Alignment.Center
-        ) {
-            val innerBackdrop = rememberLayerBackdrop()
-            Box(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .background(Color.Black.copy(alpha = 0.4f))
-                    .clickable(enabled = false, onClick = {}),
-                contentAlignment = Alignment.Center
-            ) {
-                Box(
-                    modifier = Modifier
-                        .requiredWidthIn(min = 200.dp, max = 360.dp)
-                        .clip(RoundedCornerShape(48.dp))
-                        .drawBackdrop(
-                            backdrop = backdrop,
-                            exportedBackdrop = innerBackdrop,
-                            shape = { RoundedCornerShape(48.dp) },
-                            effects = {
-                                vibrancy()
-                                blur(4f.dp.toPx())
-                                lens(12f.dp.toPx(), 48f.dp.toPx(), true)
-                            },
-                            onDrawSurface = {
-                                drawRect(
-                                    if (isDarkTheme) Color(0xFF1F1F1F).copy(alpha = 0.35f) else Color(0xFFE0E0E0).copy(alpha = 0.7f)
-                                )
-                            })) {
-                    Column(horizontalAlignment = Alignment.CenterHorizontally) {
-                        Spacer(modifier = Modifier.height(24.dp))
-                        Text(
-                            title,
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Bold,
-                                color = textColor,
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            textAlign = TextAlign.Center,
-                            modifier = Modifier.padding(horizontal = 16.dp)
-                        )
-                        Spacer(modifier = Modifier.height(12.dp))
-                        Text(
-                            message,
-                            style = TextStyle(
-                                fontSize = 14.sp,
-                                color = textColor.copy(alpha = 0.8f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            textAlign = TextAlign.Center,
-                            modifier = Modifier.padding(horizontal = 16.dp)
-                        )
-                        Spacer(modifier = Modifier.height(16.dp))
-                        Row(
-                            modifier = Modifier.fillMaxWidth(0.9f),
-                            horizontalArrangement = Arrangement.spacedBy(24.dp)
-                        ) {
-                            StyledButton(
-                                onClick = onDismiss,
-                                backdrop = innerBackdrop,
-                                modifier = Modifier.weight(1f),
-                            ) {
-                                Text(
-                                    text = dismissText, style = TextStyle(
-                                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                        fontWeight = FontWeight.Medium,
-                                        fontSize = 14.sp,
-                                        color = textColor
-                                    )
-                                )
-                            }
-                            StyledButton(
-                                onClick = onConfirm,
-                                backdrop = innerBackdrop,
-                                modifier = Modifier.weight(1f),
-                                surfaceColor = accentColor
-                            ) {
-                                Text(
-                                    text = confirmText, style = TextStyle(
-                                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                        fontWeight = FontWeight.Medium,
-                                        fontSize = 14.sp,
-                                        color = Color.White
-                                    )
-                                )
-                            }
-                        }
-                        Spacer(modifier = Modifier.height(24.dp))
-                    }
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/ConnectionSettings.kt

@@ -1,75 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Composable
-fun ConnectionSettings(
-    automaticEarDetectionEnabled: Boolean,
-    onAutomaticEarDetectionChanged: (Boolean) -> Unit,
-    automaticConnectionEnabled: Boolean,
-    onAutomaticConnectionChanged: (Boolean) -> Unit,
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(28.dp))
-            .padding(top = 2.dp)
-    ) {
-        StyledToggle(
-            label = stringResource(R.string.ear_detection),
-            independent = false,
-            checked = automaticEarDetectionEnabled,
-            onCheckedChange = onAutomaticEarDetectionChanged
-        )
-        HorizontalDivider(
-            thickness = 1.dp,
-            color = Color(0x40888888),
-            modifier = Modifier
-                .padding(horizontal = 12.dp)
-        )
-
-        StyledToggle(
-            label = stringResource(R.string.automatically_connect),
-            description = stringResource(R.string.automatically_connect_description),
-            independent = false,
-            checked = automaticConnectionEnabled,
-            onCheckedChange = onAutomaticConnectionChanged
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/ControlCenterButton.kt

@@ -1,106 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:Suppress("unused")
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.animateColorAsState
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.painter.Painter
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-
-private val SelectedColorBlue = Color(0xFF0A84FF)
-private val UnselectedColor = Color(0x593C3C3E)
-private val TextColor = Color.White
-private val IconTint = Color.White
-
-@Composable
-fun ControlCenterButton(
-    label: String,
-    icon: Painter,
-    onClick: () -> Unit,
-    modifier: Modifier = Modifier,
-    iconAreaSize: Dp,
-    isSelected: Boolean,
-    backgroundBrush: Brush? = null
-) {
-    val targetBackgroundColor = if (isSelected) SelectedColorBlue else UnselectedColor
-    val backgroundColor by animateColorAsState(
-        targetValue = targetBackgroundColor,
-        label = "ButtonBackground"
-    )
-
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        Box(
-            modifier = Modifier
-                .size(iconAreaSize)
-                .clip(CircleShape)
-                .background(backgroundBrush ?: Brush.linearGradient(colors=listOf(backgroundColor, backgroundColor)))
-                .clickable(
-                    onClick = onClick,
-                    indication = null,
-                    interactionSource = remember { MutableInteractionSource() }
-                ),
-            contentAlignment = Alignment.Center
-        ) {
-            Icon(
-                painter = icon,
-                contentDescription = null,
-                tint = IconTint,
-                modifier = Modifier.size(32.dp)
-            )
-        }
-        Spacer(modifier = Modifier.height(8.dp))
-        Text(
-            text = label,
-            color = TextColor,
-            fontSize = 12.sp,
-            fontWeight = FontWeight.Medium,
-            textAlign = TextAlign.Center,
-            maxLines = 2
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/ControlCenterNoiseControlSegmentedButton.kt

@@ -1,242 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.animation.core.spring
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Brush
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.layout.onSizeChanged
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.data.NoiseControlMode
-
-private val ContainerColor = Color(0x593C3C3E)
-private val SelectedIndicatorColorGray = Color(0xFF6C6C6E)
-private val SelectedIndicatorColorBlue = Color(0xFF0A84FF)
-private val TextColor = Color.White
-private val IconTintUnselected = Color.White
-private val IconTintSelected = Color.White
-
-internal val AdaptiveRainbowBrush = Brush.sweepGradient(
-    colors = listOf(
-        Color(0xFFB03A2F), Color(0xFFB07A2F), Color(0xFFB0A22F), Color(0xFF6AB02F),
-        Color(0xFF2FAAB0), Color(0xFF2F5EB0), Color(0xFF7D2FB0), Color(0xFFB02F7D),
-        Color(0xFFB03A2F)
-    )
-)
-
-internal val IconAreaSize = 72.dp
-private val IconSize = 42.dp
-private val IconRowHeight = IconAreaSize + 12.dp
-private val TextRowHeight = 24.dp
-private val TextSize = 12.sp
-
-@Composable
-fun ControlCenterNoiseControlSegmentedButton(
-    modifier: Modifier = Modifier,
-    availableModes: List<NoiseControlMode>,
-    selectedMode: NoiseControlMode,
-    onModeSelected: (NoiseControlMode) -> Unit
-) {
-    val selectedIndex = availableModes.indexOf(selectedMode).coerceAtLeast(0)
-    val density = LocalDensity.current
-    var iconRowWidthPx by remember { mutableFloatStateOf(0f) }
-    val itemCount = availableModes.size
-
-    val itemSlotWidthPx = remember(iconRowWidthPx, itemCount) {
-        if (itemCount > 0 && iconRowWidthPx > 0) {
-            iconRowWidthPx / itemCount
-        } else {
-            0f
-        }
-    }
-    val itemSlotWidthDp = remember(itemSlotWidthPx) { with(density) { itemSlotWidthPx.toDp() } }
-    val iconAreaSizePx = remember { with(density) { IconAreaSize.toPx() } }
-
-    val targetIndicatorStartPx = remember(selectedIndex, itemSlotWidthPx, iconAreaSizePx) {
-        if (itemSlotWidthPx > 0) {
-            val slotCenterPx = (selectedIndex + 0.5f) * itemSlotWidthPx
-            slotCenterPx - (iconAreaSizePx / 2f)
-        } else {
-            0f
-        }
-    }
-
-    val indicatorOffset: Dp by animateDpAsState(
-        targetValue = with(density) { targetIndicatorStartPx.toDp() },
-        animationSpec = spring(
-            dampingRatio = Spring.DampingRatioLowBouncy,
-            stiffness = Spring.StiffnessMedium
-        ),
-        label = "IndicatorOffset"
-    )
-
-    val indicatorBackground = remember(selectedMode) {
-        when (selectedMode) {
-            NoiseControlMode.ADAPTIVE -> AdaptiveRainbowBrush
-            NoiseControlMode.OFF -> Brush.linearGradient(colors=listOf(SelectedIndicatorColorGray, SelectedIndicatorColorGray))
-            NoiseControlMode.TRANSPARENCY,
-            NoiseControlMode.NOISE_CANCELLATION -> Brush.linearGradient(colors=listOf(SelectedIndicatorColorBlue, SelectedIndicatorColorBlue))
-        }
-    }
-
-    Column(
-        modifier = modifier,
-        horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(IconRowHeight)
-                .clip(CircleShape)
-                .background(ContainerColor)
-                .onSizeChanged { iconRowWidthPx = it.width.toFloat() },
-            contentAlignment = Alignment.Center
-        ) {
-            Box(
-                Modifier
-                    .align(Alignment.CenterStart)
-                    .offset(x = indicatorOffset)
-                    .size(IconAreaSize)
-                    .clip(CircleShape)
-                    .background(indicatorBackground)
-            )
-
-            Row(
-                modifier = Modifier.fillMaxWidth().align(Alignment.Center),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceAround
-            ) {
-                availableModes.forEach { mode ->
-                    val isSelected = selectedMode == mode
-                    NoiseControlIconItem(
-                        modifier = Modifier.size(IconAreaSize),
-                        mode = mode,
-                        isSelected = isSelected,
-                        onClick = { onModeSelected(mode) }
-                    )
-                }
-            }
-        }
-
-        Spacer(modifier = Modifier.height(4.dp))
-
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(TextRowHeight),
-            horizontalArrangement = Arrangement.SpaceAround,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            availableModes.forEach { mode ->
-                val isSelected = selectedMode == mode
-                Text(
-                    text = getModeLabel(mode),
-                    color = TextColor,
-                    fontSize = TextSize,
-                    fontWeight = if (isSelected) FontWeight.SemiBold else FontWeight.Normal,
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.width(itemSlotWidthDp.coerceAtLeast(1.dp))
-                )
-            }
-        }
-    }
-}
-
-@Composable
-private fun NoiseControlIconItem(
-    modifier: Modifier = Modifier,
-    mode: NoiseControlMode,
-    isSelected: Boolean,
-    onClick: () -> Unit
-) {
-    val iconRes = remember(mode) { getModeIconRes(mode) }
-
-    val tint = IconTintUnselected
-
-    Box(
-        modifier = modifier
-            .clip(CircleShape)
-            .clickable(
-                onClick = onClick,
-                indication = null,
-                interactionSource = remember { MutableInteractionSource() }
-            ),
-        contentAlignment = Alignment.Center
-    ) {
-        Icon(
-            painter = painterResource(id = iconRes),
-            contentDescription = getModeLabel(mode),
-            tint = if (isSelected && mode == NoiseControlMode.ADAPTIVE) IconTintSelected else tint,
-            modifier = Modifier.size(IconSize)
-        )
-    }
-}
-
-
-private fun getModeIconRes(mode: NoiseControlMode): Int {
-    return when (mode) {
-        NoiseControlMode.OFF -> R.drawable.noise_cancellation
-        NoiseControlMode.TRANSPARENCY -> R.drawable.transparency
-        NoiseControlMode.ADAPTIVE -> R.drawable.adaptive
-        NoiseControlMode.NOISE_CANCELLATION -> R.drawable.noise_cancellation
-    }
-}
-
-private fun getModeLabel(mode: NoiseControlMode): String {
-    return when (mode) {
-        NoiseControlMode.OFF -> "Off"
-        NoiseControlMode.TRANSPARENCY -> "Transparency"
-        NoiseControlMode.ADAPTIVE -> "Adaptive"
-        NoiseControlMode.NOISE_CANCELLATION -> "Noise Cancellation"
-    }
-}
-

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/DeviceInfoCard.kt

@@ -1,235 +0,0 @@
-package me.kavishdevar.librepods.presentation.components
-
-import android.os.Build
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.utils.XposedState
-
-@Composable
-fun DeviceInfoCard() {
-    val isDarkTheme = isSystemInDarkTheme()
-
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-
-    val rowHeight = remember { mutableStateOf(0.dp) }
-    val density = LocalDensity.current
-
-    Column (
-        verticalArrangement = Arrangement.spacedBy(8.dp)
-    ) {
-        Box(
-            modifier = Modifier
-                .background(if (isDarkTheme) Color.Black else Color(0xFFF2F2F7))
-                .padding(start = 16.dp, top = 24.dp, end = 4.dp)
-        ) {
-            Text(
-                text = stringResource(R.string.device_info), style = TextStyle(
-                    fontSize = 14.sp,
-                    fontWeight = FontWeight.Bold,
-                    color = textColor.copy(alpha = 0.6f),
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-        }
-        Column(
-            modifier = Modifier
-                .clip(RoundedCornerShape(28.dp))
-                .fillMaxWidth()
-                .background(backgroundColor, RoundedCornerShape(28.dp))
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp)
-                    .onGloballyPositioned { coordinates ->
-                        rowHeight.value = with(density) { coordinates.size.height.toDp() }
-                    },
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.manufacturer), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = Build.MANUFACTURER, style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.model_number), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = Build.MODEL, style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.build_id), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = Build.DISPLAY, style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.version), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = Build.ID + " (${Build.VERSION.SDK_INT_FULL})",
-                    style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.xposed_available), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = if (XposedState.isAvailable) stringResource(R.string.yes) else stringResource(R.string.no), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier.padding(horizontal = 12.dp)
-            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(16.dp),
-                horizontalArrangement = Arrangement.SpaceBetween,
-            ) {
-                Text(
-                    text = stringResource(R.string.app_enabled_in_xposed), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-                Text(
-                    text = if (XposedState.bluetoothScopeEnabled) stringResource(R.string.yes) else stringResource(R.string.no), style = TextStyle(
-                        fontSize = 16.sp,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                            alpha = 0.8f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/HearingHealthSettings.kt

@@ -1,118 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Composable
-fun HearingHealthSettings(
-    navController: NavController,
-    hasPPECapability: Boolean,
-    hasHearingAidCapability: Boolean,
-    vendorIdHook: Boolean
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val shouldShowHearingAid = hasHearingAidCapability && vendorIdHook
-
-    if (hasPPECapability && shouldShowHearingAid) {
-        Box(
-            modifier = Modifier
-                .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-                .padding(horizontal = 16.dp, vertical = 4.dp)
-        ){
-            Text(
-                text = stringResource(R.string.hearing_health),
-                style = TextStyle(
-                    fontSize = 14.sp,
-                    fontWeight = FontWeight.Bold,
-                    color = textColor.copy(alpha = 0.6f),
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                )
-            )
-        }
-        Column(
-            modifier = Modifier
-                .clip(RoundedCornerShape(28.dp))
-                .fillMaxWidth()
-                .background(backgroundColor, RoundedCornerShape(28.dp))
-                .padding(top = 2.dp)
-        ) {
-            NavigationButton(
-                to = "hearing_protection",
-                name = stringResource(R.string.hearing_protection),
-                navController = navController,
-                independent = false
-            )
-
-            HorizontalDivider(
-                thickness = 1.dp,
-                color = Color(0x40888888),
-                modifier = Modifier
-                    .padding(horizontal = 12.dp)
-            )
-
-
-            NavigationButton(
-                to = "hearing_aid",
-                name = stringResource(R.string.hearing_aid),
-                navController = navController,
-                independent = false
-            )
-        }
-    } else if (shouldShowHearingAid) {
-        NavigationButton(
-            to = "hearing_aid",
-            name = stringResource(R.string.hearing_aid),
-            navController = navController
-        )
-    } else if (hasPPECapability) {
-        NavigationButton(
-            to = "hearing_protection",
-            name = stringResource(R.string.hearing_protection),
-            title = stringResource(R.string.hearing_health),
-            navController = navController
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/MicrophoneSettings.kt

@@ -1,263 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.layout.positionInParent
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@ExperimentalHazeMaterialsApi
-@Composable
-fun MicrophoneSettings(
-    hazeState: HazeState,
-    micModeValue: Byte,
-    onMicModeValueChanged: (Byte) -> Unit
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(28.dp))
-            .padding(top = 2.dp)
-    ) {
-        var selectedMode by remember {
-            mutableStateOf(
-                when (micModeValue) {
-                    0x00.toByte() -> "Automatic"
-                    0x01.toByte() -> "Always Right"
-                    0x02.toByte() -> "Always Left"
-                    else -> "Automatic"
-                }
-            )
-        }
-        var showDropdown by remember { mutableStateOf(false) }
-        var touchOffset by remember { mutableStateOf<Offset?>(null) }
-        var boxPosition by remember { mutableStateOf(Offset.Zero) }
-        var lastDismissTime by remember { mutableLongStateOf(0L) }
-        val reopenThresholdMs = 250L
-
-        val density = LocalDensity.current
-        val itemHeightPx = with(density) { 48.dp.toPx() }
-        var parentHoveredIndex by remember { mutableStateOf<Int?>(null) }
-        var parentDragActive by remember { mutableStateOf(false) }
-        var previousIdx by remember { mutableStateOf<Int?>(null) }
-        val haptics = LocalHapticFeedback.current
-        val scope = rememberCoroutineScope()
-        val microphoneAutomaticText = stringResource(R.string.microphone_automatic)
-        val microphoneAlwaysRightText = stringResource(R.string.microphone_always_right)
-        val microphoneAlwaysLeftText = stringResource(R.string.microphone_always_left)
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 16.dp)
-                .height(58.dp)
-                .pointerInput(Unit) {
-                    detectTapGestures { offset ->
-                        val now = System.currentTimeMillis()
-                        if (showDropdown) {
-                            showDropdown = false
-                            lastDismissTime = now
-                        } else {
-                            if (now - lastDismissTime > reopenThresholdMs) {
-                                touchOffset = offset
-                                showDropdown = true
-                            }
-                        }
-                    }
-                }
-                .pointerInput(Unit) {
-                    detectDragGesturesAfterLongPress(
-                        onDragStart = { offset ->
-                            val now = System.currentTimeMillis()
-                            touchOffset = offset
-                            if (!showDropdown && now - lastDismissTime > reopenThresholdMs) {
-                                showDropdown = true
-                            }
-                            lastDismissTime = now
-                            parentDragActive = true
-                            parentHoveredIndex = 0
-                        },
-                        onDrag = { change, _ ->
-                            val current = change.position
-                            val touch = touchOffset ?: current
-                            val posInPopupY = current.y - touch.y
-                            val idx = (posInPopupY / itemHeightPx).toInt()
-                            if (idx != previousIdx) {
-                                scope.launch { haptics.performHapticFeedback(HapticFeedbackType.SegmentTick) }
-                            }
-                            parentHoveredIndex = idx
-                            previousIdx = idx
-                        },
-                        onDragEnd = {
-                            parentDragActive = false
-                            parentHoveredIndex?.let { idx ->
-                                val options = listOf(
-                                    microphoneAutomaticText,
-                                    microphoneAlwaysRightText,
-                                    microphoneAlwaysLeftText
-                                )
-                                if (idx in options.indices) {
-                                    val option = options[idx]
-                                    selectedMode = option
-                                    showDropdown = false
-                                    lastDismissTime = System.currentTimeMillis()
-                                    val byteValue = when (option) {
-                                        options[0] -> 0x00
-                                        options[1] -> 0x01
-                                        options[2] -> 0x02
-                                        else -> 0x00
-                                    }
-//                                    service.aacpManager.sendControlCommand(
-//                                        AACPManager.Companion.ControlCommandIdentifiers.MIC_MODE.value,
-//                                        byteArrayOf(byteValue.toByte())
-//                                    )
-                                    onMicModeValueChanged(byteValue.toByte())
-                                }
-                            }
-                            if (parentHoveredIndex != null && parentHoveredIndex in 0..2) {
-                                scope.launch { haptics.performHapticFeedback(HapticFeedbackType.GestureEnd) }
-                            }
-                            parentHoveredIndex = null
-                        },
-                        onDragCancel = {
-                            parentDragActive = false
-                            parentHoveredIndex = null
-                        }
-                    )
-                },
-            horizontalArrangement = Arrangement.SpaceBetween,
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Text(
-                text = stringResource(R.string.microphone_mode),
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    color = textColor,
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                ),
-                modifier = Modifier.padding(bottom = 4.dp)
-            )
-            Box(
-                modifier = Modifier.onGloballyPositioned { coordinates ->
-                    boxPosition = coordinates.positionInParent()
-                }
-            ) {
-                Row(
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(
-                        text = selectedMode,
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor.copy(alpha = 0.8f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                    Text(
-                        text = "􀆏",
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor.copy(alpha = 0.6f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        ),
-                        modifier = Modifier
-                            .padding(start = 6.dp)
-                    )
-                }
-
-                val microphoneAutomaticText = stringResource(R.string.microphone_automatic)
-                val microphoneAlwaysRightText = stringResource(R.string.microphone_always_right)
-                val microphoneAlwaysLeftText = stringResource(R.string.microphone_always_left)
-
-                StyledDropdown(
-                    expanded = showDropdown,
-                    onDismissRequest = {
-                        showDropdown = false
-                        lastDismissTime = System.currentTimeMillis()
-                    },
-                    options = listOf(
-                        microphoneAutomaticText,
-                        microphoneAlwaysRightText,
-                        microphoneAlwaysLeftText
-                    ),
-                    selectedOption = selectedMode,
-                    touchOffset = touchOffset,
-                    boxPosition = boxPosition,
-                    externalHoveredIndex = parentHoveredIndex,
-                    externalDragActive = parentDragActive,
-                    onOptionSelected = { option ->
-                        selectedMode = option
-                        showDropdown = false
-                        val byteValue = when (option) {
-                            microphoneAutomaticText -> 0x00
-                            microphoneAlwaysRightText -> 0x01
-                            microphoneAlwaysLeftText -> 0x02
-                            else -> 0x00
-                        }
-                        onMicModeValueChanged(byteValue.toByte())
-                    },
-                    hazeState = hazeState
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/NavigationButton.kt

@@ -1,179 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.animateColorAsState
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-
-@Composable
-fun NavigationButton(
-    to: String,
-    name: String,
-    navController: NavController, onClick: (() -> Unit)? = null,
-    independent: Boolean = true,
-    title: String? = null,
-    description: String? = null,
-    currentState: String? = null,
-    height: Dp = 58.dp,
-    enabled: Boolean = true
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    var backgroundColor by remember { mutableStateOf(if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)) }
-    val animatedBackgroundColor by animateColorAsState(targetValue = backgroundColor, animationSpec = tween(durationMillis = 500))
-    val haptics = LocalHapticFeedback.current
-    val scope = rememberCoroutineScope()
-
-    Column {
-        if (title != null) {
-            Box(
-                modifier = Modifier
-                    .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-                    .padding(start = 16.dp, end = 16.dp, top = 8.dp, bottom = 4.dp)
-            ){
-                Text(
-                    text = title,
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-        }
-        Row(
-            modifier = Modifier
-                .background(
-                    animatedBackgroundColor,
-                    RoundedCornerShape(if (independent) 28.dp else 0.dp)
-                )
-                .height(height)
-                .pointerInput(Unit) {
-                    detectTapGestures(
-                        onPress = {
-                            if (enabled) {
-                                backgroundColor =
-                                    if (isDarkTheme) Color(0x40888888) else Color(0x40D9D9D9)
-                                tryAwaitRelease()
-                                backgroundColor =
-                                    if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-                            }
-                        },
-                        onTap = {
-                            if (enabled) {
-                                scope.launch { haptics.performHapticFeedback(HapticFeedbackType.ContextClick) }
-                                if (onClick != null) onClick() else navController.navigate(to)
-                            }
-                        }
-                    )
-                }
-                .padding(horizontal = 16.dp),
-            verticalAlignment = Alignment.CenterVertically,
-        ) {
-            Text(
-                text = name,
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    color = if (isDarkTheme) Color.White else Color.Black,
-                )
-            )
-            Spacer(modifier = Modifier.weight(1f))
-            if (currentState != null) {
-                Text(
-                    text = currentState,
-                    style = TextStyle(
-                        fontSize = 16.sp,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.8f),
-                    )
-                )
-            }
-            Text(
-                text = "􀯻",
-                style = TextStyle(
-                    fontSize = 16.sp,
-                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.6f)
-                ),
-                modifier = Modifier
-                    .padding(start = if (currentState != null) 6.dp else 0.dp)
-            )
-        }
-        if (description != null) {
-            Box(
-                modifier = Modifier
-                    .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7)) // because blur effect doesn't work for some reason
-                    .padding(horizontal = 16.dp, vertical = 4.dp),
-            ) {
-                Text(
-                    text = description,
-                    style = TextStyle(
-                        fontSize = 12.sp,
-                        fontWeight = FontWeight.Light,
-                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    // modifier = Modifier.padding(horizontal = 16.dp)
-                )
-            }
-        }
-    }
-}
-
-@Preview
-@Composable
-fun NavigationButtonPreview() {
-    NavigationButton("to", "Name", NavController(LocalContext.current))
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/NoiseControlSettings.kt

@@ -1,397 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.annotation.SuppressLint
-import androidx.compose.animation.core.AnimationSpec
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.SpringSpec
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.draggable
-import androidx.compose.foundation.gestures.rememberDraggableState
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.BoxWithConstraints
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Text
-import androidx.compose.material3.VerticalDivider
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.alpha
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.res.imageResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.zIndex
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.data.NoiseControlMode
-import kotlin.io.encoding.ExperimentalEncodingApi
-import kotlin.math.roundToInt
-
-@SuppressLint("UnspecifiedRegisterReceiverFlag", "UnusedBoxWithConstraintsScope")
-@Composable
-fun NoiseControlSettings(
-    showOffListeningMode: Boolean,
-    noiseControlModeValue: Int,
-    onNoiseControlModeChanged: (Int) -> Unit
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFE3E3E8)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val textColorSelected = if (isDarkTheme) Color.White else Color.Black
-    val selectedBackground = if (isDarkTheme) Color(0xBF5C5A5F) else Color(0xFFFFFFFF)
-
-
-
-    val noiseControlMode = remember { mutableStateOf(NoiseControlMode.OFF) }
-
-    val d1a = remember { mutableFloatStateOf(0f) }
-    val d2a = remember { mutableFloatStateOf(0f) }
-    val d3a = remember { mutableFloatStateOf(0f) }
-
-    // this function exists solely for the dividers, should get rid of it
-    fun onModeSelected(mode: NoiseControlMode, received: Boolean = false) {
-        val previousMode = noiseControlMode.value
-
-        val targetMode = if (!showOffListeningMode && mode == NoiseControlMode.OFF) {
-             NoiseControlMode.TRANSPARENCY
-        } else {
-            mode
-        }
-
-        noiseControlMode.value = targetMode
-
-        if (!received && targetMode != previousMode) onNoiseControlModeChanged(targetMode.ordinal + 1)
-
-
-        when (noiseControlMode.value) {
-            NoiseControlMode.NOISE_CANCELLATION -> {
-                d1a.floatValue = 1f
-                d2a.floatValue = 1f
-                d3a.floatValue = 0f
-            }
-            NoiseControlMode.OFF -> {
-                d1a.floatValue = 0f
-                d2a.floatValue = 1f
-                d3a.floatValue = 1f
-            }
-            NoiseControlMode.ADAPTIVE -> {
-                d1a.floatValue = 1f
-                d2a.floatValue = 0f
-                d3a.floatValue = 0f
-            }
-            NoiseControlMode.TRANSPARENCY -> {
-                d1a.floatValue = 0f
-                d2a.floatValue = 0f
-                d3a.floatValue = 1f
-            }
-        }
-    }
-
-
-    val index = (noiseControlModeValue - 1).coerceIn(0, NoiseControlMode.entries.size - 1)
-    noiseControlMode.value = NoiseControlMode.entries[index]
-
-    onModeSelected(noiseControlMode.value, received = true)
-
-    Box(
-        modifier = Modifier
-            .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-            .padding(horizontal = 16.dp, vertical = 4.dp)
-    ){
-        Text(
-            text = stringResource(R.string.noise_control),
-            style = TextStyle(
-                fontSize = 14.sp,
-                fontWeight = FontWeight.Bold,
-                color = textColor.copy(alpha = 0.6f),
-                fontFamily = FontFamily(Font(R.font.sf_pro))
-            )
-        )
-    }
-
-    BoxWithConstraints(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 8.dp)
-    ) {
-        val density = LocalDensity.current
-        val buttonCount = if (showOffListeningMode) 4 else 3
-        val buttonWidth = maxWidth / buttonCount
-
-        val isDragging = remember { mutableStateOf(false) }
-        var dragOffset by remember {
-            mutableFloatStateOf(
-                with(density) {
-                    when(noiseControlMode.value) {
-                        NoiseControlMode.OFF -> if (showOffListeningMode) 0f else buttonWidth.toPx()
-                        NoiseControlMode.TRANSPARENCY -> if (showOffListeningMode) buttonWidth.toPx() else 0f
-                        NoiseControlMode.ADAPTIVE -> if (showOffListeningMode) (buttonWidth * 2).toPx() else buttonWidth.toPx()
-                        NoiseControlMode.NOISE_CANCELLATION -> if (showOffListeningMode) (buttonWidth * 3).toPx() else (buttonWidth * 2).toPx()
-                    }
-                }
-            )
-        }
-
-        val animationSpec: AnimationSpec<Float> = SpringSpec(
-            dampingRatio = Spring.DampingRatioLowBouncy,
-            stiffness = Spring.StiffnessMediumLow,
-            visibilityThreshold = 0.01f
-        )
-
-        val targetOffset = buttonWidth * when(noiseControlMode.value) {
-            NoiseControlMode.OFF -> if (showOffListeningMode) 0 else 1
-            NoiseControlMode.TRANSPARENCY -> if (showOffListeningMode) 1 else 0
-            NoiseControlMode.ADAPTIVE -> if (showOffListeningMode) 2 else 1
-            NoiseControlMode.NOISE_CANCELLATION -> if (showOffListeningMode) 3 else 2
-        }
-
-        val animatedOffset by animateFloatAsState(
-            targetValue = with(density) {
-                if (isDragging.value) dragOffset else targetOffset.toPx()
-            },
-            animationSpec = animationSpec,
-            label = "selector"
-        )
-
-        Column(
-            modifier = Modifier.fillMaxWidth()
-        ) {
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .height(60.dp)
-                    .background(backgroundColor, RoundedCornerShape(28.dp))
-            ) {
-                Row(
-                    modifier = Modifier.fillMaxWidth()
-                ) {
-                    if (showOffListeningMode) {
-                        NoiseControlButton(
-                            icon = ImageBitmap.imageResource(R.drawable.noise_cancellation),
-                            onClick = { onModeSelected(NoiseControlMode.OFF) },
-                            textColor = if (noiseControlMode.value == NoiseControlMode.OFF) textColorSelected else textColor,
-                            modifier = Modifier.weight(1f),
-                            usePadding = false
-                        )
-                        VerticalDivider(
-                            thickness = 1.dp,
-                            modifier = Modifier
-                                .padding(vertical = 10.dp)
-                                .alpha(d1a.floatValue),
-                            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f)
-                        )
-                    }
-                    NoiseControlButton(
-                        icon = ImageBitmap.imageResource(R.drawable.transparency),
-                        onClick = { onModeSelected(NoiseControlMode.TRANSPARENCY) },
-                        textColor = if (noiseControlMode.value == NoiseControlMode.TRANSPARENCY) textColorSelected else textColor,
-                        modifier = Modifier.weight(1f),
-                        usePadding = false
-                    )
-                    VerticalDivider(
-                        thickness = 1.dp,
-                        modifier = Modifier
-                            .padding(vertical = 10.dp)
-                            .alpha(d2a.floatValue),
-                        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f)
-                    )
-                    NoiseControlButton(
-                        icon = ImageBitmap.imageResource(R.drawable.adaptive),
-                        onClick = { onModeSelected(NoiseControlMode.ADAPTIVE) },
-                        textColor = if (noiseControlMode.value == NoiseControlMode.ADAPTIVE) textColorSelected else textColor,
-                        modifier = Modifier.weight(1f),
-                        usePadding = false
-                    )
-                    VerticalDivider(
-                        thickness = 1.dp,
-                        modifier = Modifier
-                            .padding(vertical = 10.dp)
-                            .alpha(d3a.floatValue),
-                        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f)
-                    )
-                    NoiseControlButton(
-                        icon = ImageBitmap.imageResource(R.drawable.noise_cancellation),
-                        onClick = { onModeSelected(NoiseControlMode.NOISE_CANCELLATION) },
-                        textColor = if (noiseControlMode.value == NoiseControlMode.NOISE_CANCELLATION) textColorSelected else textColor,
-                        modifier = Modifier.weight(1f),
-                        usePadding = false
-                    )
-                }
-
-                Box(
-                    modifier = Modifier
-                        .width(buttonWidth)
-                        .fillMaxHeight()
-                        .offset { IntOffset(animatedOffset.roundToInt(), 0) }
-                        .zIndex(0f)
-                        .draggable(
-                            orientation = Orientation.Horizontal,
-                            state = rememberDraggableState { delta ->
-                                dragOffset = (dragOffset + delta).coerceIn(
-                                    0f,
-                                    with(density) { (buttonWidth * (buttonCount - 1)).toPx() }
-                                )
-                            },
-                            onDragStarted = { isDragging.value = true },
-                            onDragStopped = {
-                                isDragging.value = false
-                                val position = dragOffset / with(density) { buttonWidth.toPx() }
-                                val newIndex = position.roundToInt()
-                                val newMode = when(newIndex) {
-                                    0 -> if (showOffListeningMode) NoiseControlMode.OFF else NoiseControlMode.TRANSPARENCY
-                                    1 -> if (showOffListeningMode) NoiseControlMode.TRANSPARENCY else NoiseControlMode.ADAPTIVE
-                                    2 -> if (showOffListeningMode) NoiseControlMode.ADAPTIVE else NoiseControlMode.NOISE_CANCELLATION
-                                    3 -> NoiseControlMode.NOISE_CANCELLATION
-                                    else -> noiseControlMode.value // Keep current if index is invalid
-                                }
-                                onModeSelected(newMode)
-                            }
-                        )
-                ) {
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize()
-                            .padding(3.dp)
-                            .background(selectedBackground, RoundedCornerShape(26.dp))
-                    )
-                }
-
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .zIndex(1f)
-                ) {
-                    if (showOffListeningMode) {
-                        NoiseControlButton(
-                            icon = ImageBitmap.imageResource(R.drawable.noise_cancellation),
-                            onClick = { onModeSelected(NoiseControlMode.OFF) },
-                            textColor = if (noiseControlMode.value == NoiseControlMode.OFF) textColorSelected else textColor,
-                            modifier = Modifier.weight(1f),
-                            usePadding = false
-                        )
-                        VerticalDivider(
-                            thickness = 1.dp,
-                            modifier = Modifier
-                                .padding(vertical = 10.dp)
-                                .alpha(d1a.floatValue),
-                            color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f)
-                        )
-                    }
-                    NoiseControlButton(
-                        icon = ImageBitmap.imageResource(R.drawable.transparency),
-                        onClick = { onModeSelected(NoiseControlMode.TRANSPARENCY) },
-                        textColor = if (noiseControlMode.value == NoiseControlMode.TRANSPARENCY) textColorSelected else textColor,
-                        modifier = Modifier.weight(1f),
-                        usePadding = false
-                    )
-                    VerticalDivider(
-                        thickness = 1.dp,
-                        modifier = Modifier
-                            .padding(vertical = 10.dp)
-                            .alpha(d2a.floatValue),
-                        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f)
-                    )
-                    NoiseControlButton(
-                        icon = ImageBitmap.imageResource(R.drawable.adaptive),
-                        onClick = { onModeSelected(NoiseControlMode.ADAPTIVE) },
-                        textColor = if (noiseControlMode.value == NoiseControlMode.ADAPTIVE) textColorSelected else textColor,
-                        modifier = Modifier.weight(1f),
-                        usePadding = false
-                    )
-                    VerticalDivider(
-                        thickness = 1.dp,
-                        modifier = Modifier
-                            .padding(vertical = 10.dp)
-                            .alpha(d3a.floatValue),
-                        color = MaterialTheme.colorScheme.onSurface.copy(alpha = 0.12f)
-                    )
-                    NoiseControlButton(
-                        icon = ImageBitmap.imageResource(R.drawable.noise_cancellation),
-                        onClick = { onModeSelected(NoiseControlMode.NOISE_CANCELLATION) },
-                        textColor = if (noiseControlMode.value == NoiseControlMode.NOISE_CANCELLATION) textColorSelected else textColor,
-                        modifier = Modifier.weight(1f),
-                        usePadding = false
-                    )
-                }
-            }
-
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(top = 4.dp)
-            ) {
-                if (showOffListeningMode) {
-                    Text(
-                        text = stringResource(R.string.off),
-                        style = TextStyle(fontSize = 12.sp, color = textColor),
-                        textAlign = TextAlign.Center,
-                        modifier = Modifier.weight(1f)
-                    )
-                }
-                Text(
-                    text = stringResource(R.string.transparency),
-                    style = TextStyle(fontSize = 12.sp, color = textColor),
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.weight(1f)
-                )
-                Text(
-                    text = stringResource(R.string.adaptive),
-                    style = TextStyle(fontSize = 12.sp, color = textColor),
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.weight(1f)
-                )
-                Text(
-                    text = stringResource(R.string.noise_cancellation),
-                    style = TextStyle(fontSize = 12.sp, color = textColor),
-                    textAlign = TextAlign.Center,
-                    modifier = Modifier.weight(1f)
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/PressAndHoldSettings.kt

@@ -1,108 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.data.StemAction
-
-@Composable
-fun PressAndHoldSettings(
-    navController: NavController,
-    leftAction: StemAction,
-    rightAction: StemAction
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val dividerColor = Color(0x40888888)
-
-    val leftActionText = when (leftAction) {
-        StemAction.CYCLE_NOISE_CONTROL_MODES -> stringResource(R.string.noise_control)
-        StemAction.DIGITAL_ASSISTANT -> "Digital Assistant"
-        else -> "INVALID!!"
-    }
-
-    val rightActionText = when (rightAction) {
-        StemAction.CYCLE_NOISE_CONTROL_MODES -> stringResource(R.string.noise_control)
-        StemAction.DIGITAL_ASSISTANT -> "Digital Assistant"
-        else -> "INVALID!!"
-    }
-    Box(
-        modifier = Modifier
-            .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-            .padding(horizontal = 16.dp, vertical = 4.dp)
-    ){
-        Text(
-            text = stringResource(R.string.press_and_hold_airpods),
-            style = TextStyle(
-                fontSize = 14.sp,
-                fontWeight = FontWeight.Bold,
-                color = textColor.copy(alpha = 0.6f),
-                fontFamily = FontFamily(Font(R.font.sf_pro))
-            )
-        )
-    }
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF), RoundedCornerShape(28.dp))
-            .clip(RoundedCornerShape(28.dp))
-    ) {
-        NavigationButton(
-            to = "long_press/Left",
-            name = stringResource(R.string.left),
-            navController = navController,
-            independent = false,
-            currentState = leftActionText,
-        )
-        HorizontalDivider(
-            thickness = 1.dp,
-            color = dividerColor,
-            modifier = Modifier
-                .padding(horizontal = 16.dp)
-        )
-        NavigationButton(
-            to = "long_press/Right",
-            name = stringResource(R.string.right),
-            navController = navController,
-            independent = false,
-            currentState = rightActionText,
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledButton.kt

@@ -1,329 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.graphics.RuntimeShader
-import android.os.Build
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.VectorConverter
-import androidx.compose.animation.core.VisibilityThreshold
-import androidx.compose.animation.core.spring
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.RowScope
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.BlendMode
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.ShaderBrush
-import androidx.compose.ui.graphics.isSpecified
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.semantics.Role
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.util.fastCoerceAtMost
-import androidx.compose.ui.util.fastCoerceIn
-import androidx.compose.ui.util.lerp
-import com.kyant.backdrop.Backdrop
-import com.kyant.backdrop.drawBackdrop
-import com.kyant.backdrop.effects.blur
-import com.kyant.backdrop.effects.lens
-import com.kyant.backdrop.effects.vibrancy
-import com.kyant.backdrop.highlight.Highlight
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.utils.inspectDragGestures
-import kotlin.math.abs
-import kotlin.math.atan2
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.tanh
-
-@Composable
-fun StyledButton(
-    onClick: () -> Unit,
-    backdrop: Backdrop,
-    modifier: Modifier = Modifier,
-    isInteractive: Boolean = true,
-    tint: Color = Color.Unspecified,
-    surfaceColor: Color = Color.Unspecified,
-    maxScale: Float = 0.1f,
-    enabled: Boolean = true,
-    content: @Composable RowScope.() -> Unit,
-) {
-    val isInteractive = enabled && isInteractive
-    val scope = rememberCoroutineScope()
-    val haptics = LocalHapticFeedback.current
-    val progressAnimation = remember { Animatable(0f) }
-    var pressStartPosition by remember { mutableStateOf(Offset.Zero) }
-    val offsetAnimation = remember { Animatable(Offset.Zero, Offset.VectorConverter) }
-    var isPressed by remember { mutableStateOf(false) }
-
-    val interactiveHighlightShader = remember {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            RuntimeShader(
-                """
-uniform float2 size;
-layout(color) uniform half4 color;
-uniform float radius;
-uniform float2 offset;
-
-half4 main(float2 coord) {
-    float2 center = offset;
-    float dist = distance(coord, center);
-    float intensity = smoothstep(radius, radius * 0.5, dist);
-    return color * intensity;
-}"""
-            )
-        } else {
-            null
-        }
-    }
-
-    Row(
-        modifier
-            .then(
-                if (!isInteractive) {
-                    Modifier.drawBackdrop(
-                        backdrop = backdrop,
-                        shape = { RoundedCornerShape(28f.dp) },
-                        effects = {
-                            blur(16f.dp.toPx())
-                        },
-                        layerBlock = null,
-                        onDrawSurface = {
-                            if (tint.isSpecified) {
-                                drawRect(tint, blendMode = BlendMode.Hue)
-                                drawRect(tint.copy(alpha = 0.75f))
-                            } else {
-                                drawRect(Color.White.copy(0.1f))
-                            }
-                            if (surfaceColor.isSpecified && enabled) {
-                                val color = if (isPressed) {
-                                    Color(
-                                        red = surfaceColor.red * 0.5f,
-                                        green = surfaceColor.green * 0.5f,
-                                        blue = surfaceColor.blue * 0.5f,
-                                        alpha = surfaceColor.alpha
-                                    )
-                                } else {
-                                    surfaceColor
-                                }
-                                drawRect(color)
-                            } else {
-                                if (isPressed) {
-                                    drawRect(Color.Black.copy(alpha = 0.4f))
-                                    drawRect(Color.White.copy(alpha = 0.2f))
-                                }
-                            }
-                        },
-                        onDrawFront = null,
-                        highlight = { Highlight.Ambient.copy(alpha = 0f) }
-                    )
-                } else {
-                    Modifier.drawBackdrop(
-                        backdrop = backdrop,
-                        shape = { RoundedCornerShape(28f.dp) },
-                        effects = {
-                            vibrancy()
-                            blur(2f.dp.toPx())
-                            lens(
-                                refractionHeight = 12f.dp.toPx(),
-                                refractionAmount = 24f.dp.toPx(),
-                                depthEffect = true,
-                                chromaticAberration = true
-                            )
-                        },
-                        layerBlock = {
-                            val width = size.width
-                            val height = size.height
-
-                            val progress = progressAnimation.value
-                            val scale = lerp(1f, 1f + maxScale, progress)
-
-                            val maxOffset = size.minDimension
-                            val initialDerivative = 0.05f
-                            val offset = offsetAnimation.value
-                            translationX =
-                                maxOffset * tanh(initialDerivative * offset.x / maxOffset)
-                            translationY =
-                                maxOffset * tanh(initialDerivative * offset.y / maxOffset)
-
-                            val maxDragScale = 0.1f
-                            val offsetAngle = atan2(offset.y, offset.x)
-                            scaleX =
-                                scale +
-                                    maxDragScale * abs(cos(offsetAngle) * offset.x / size.maxDimension) *
-                                    (width / height).fastCoerceAtMost(1f)
-                            scaleY =
-                                scale +
-                                    maxDragScale * abs(sin(offsetAngle) * offset.y / size.maxDimension) *
-                                    (height / width).fastCoerceAtMost(1f)
-                        },
-                        onDrawSurface = {
-                            if (tint.isSpecified) {
-                                drawRect(tint, blendMode = BlendMode.Hue)
-                                drawRect(tint.copy(alpha = 0.75f))
-                            } else {
-                                drawRect(Color.White.copy(0.1f))
-                            }
-                            if (surfaceColor.isSpecified) {
-                                val color = if (!isInteractive && isPressed) {
-                                    Color(
-                                        red = surfaceColor.red * 0.5f,
-                                        green = surfaceColor.green * 0.5f,
-                                        blue = surfaceColor.blue * 0.5f,
-                                        alpha = surfaceColor.alpha
-                                    )
-                                } else {
-                                    surfaceColor
-                                }
-                                drawRect(color)
-                            }
-                        },
-                        onDrawFront = {
-                            val progress = progressAnimation.value.fastCoerceIn(0f, 1f)
-                            if (progress > 0f) {
-                                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && interactiveHighlightShader != null) {
-                                    drawRect(
-                                        Color.White.copy(0.1f * progress),
-                                        blendMode = BlendMode.Plus
-                                    )
-                                    interactiveHighlightShader.apply {
-                                        val offset = pressStartPosition + offsetAnimation.value
-                                        setFloatUniform("size", size.width, size.height)
-                                        setColorUniform(
-                                            "color",
-                                            Color.White.copy(0.15f * progress).toArgb()
-                                        )
-                                        setFloatUniform("radius", size.maxDimension)
-                                        setFloatUniform(
-                                            "offset",
-                                            offset.x.fastCoerceIn(0f, size.width),
-                                            offset.y.fastCoerceIn(0f, size.height)
-                                        )
-                                    }
-                                    drawRect(
-                                        ShaderBrush(interactiveHighlightShader),
-                                        blendMode = BlendMode.Plus
-                                    )
-                                } else {
-                                    drawRect(
-                                        Color.White.copy(0.25f * progress),
-                                        blendMode = BlendMode.Plus
-                                    )
-                                }
-                            }
-                        }
-                    )
-                }
-            )
-            .clickable(
-                interactionSource = null,
-                indication = null,
-                role = Role.Button,
-                onClick = {
-                    if (enabled) {
-                        haptics.performHapticFeedback(HapticFeedbackType.ContextClick)
-                        onClick()
-                    }
-                }
-            )
-            .then(
-                if (isInteractive) {
-                    Modifier.pointerInput(scope) {
-                        val progressAnimationSpec = spring(0.5f, 300f, 0.001f)
-                        val offsetAnimationSpec = spring(1f, 300f, Offset.VisibilityThreshold)
-                        val onDragStop: () -> Unit = {
-                            scope.launch {
-                                launch { haptics.performHapticFeedback(HapticFeedbackType.Reject) }
-                                launch { progressAnimation.animateTo(0f, progressAnimationSpec) }
-                                launch {
-                                    offsetAnimation.animateTo(
-                                        Offset.Zero,
-                                        offsetAnimationSpec
-                                    )
-                                }
-                            }
-                        }
-                        inspectDragGestures(
-                            onDragStart = { down ->
-                                pressStartPosition = down.position
-                                scope.launch {
-                                    launch { haptics.performHapticFeedback(HapticFeedbackType.SegmentFrequentTick) }
-                                    launch {
-                                        progressAnimation.animateTo(
-                                            1f,
-                                            progressAnimationSpec
-                                        )
-                                    }
-                                    launch { offsetAnimation.snapTo(Offset.Zero) }
-                                }
-                            },
-                            onDragEnd = {
-                                onDragStop()
-                            },
-                            onDragCancel = onDragStop
-                        ) { _, dragAmount ->
-                            scope.launch {
-                                if (dragAmount.getDistanceSquared() > 350) haptics.performHapticFeedback(
-                                    HapticFeedbackType.SegmentFrequentTick
-                                )
-                                offsetAnimation.snapTo(offsetAnimation.value + dragAmount)
-                            }
-                        }
-                    }
-                } else {
-                    Modifier.pointerInput(Unit) {
-                        detectTapGestures(
-                            onPress = {
-                                isPressed = true
-                                tryAwaitRelease()
-                                isPressed = false
-                            },
-                            onTap = {
-                                if (enabled) {
-                                    haptics.performHapticFeedback(HapticFeedbackType.ContextClick)
-                                    onClick()
-                                }
-                            }
-                        )
-                    }
-                }
-            )
-            .height(48f.dp)
-            .padding(horizontal = 16f.dp),
-        horizontalArrangement = Arrangement.spacedBy(8f.dp, Alignment.CenterHorizontally),
-        verticalAlignment = Alignment.CenterVertically,
-        content = content
-    )
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledDropdown.kt

@@ -1,259 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.annotation.SuppressLint
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.detectDragGestures
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.Checkbox
-import androidx.compose.material3.CheckboxDefaults
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.unit.IntOffset
-import androidx.compose.ui.unit.IntSize
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.window.Popup
-import dev.chrisbanes.haze.HazeEffectScope
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.HazeTint
-import dev.chrisbanes.haze.hazeEffect
-import dev.chrisbanes.haze.materials.CupertinoMaterials
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-
-@ExperimentalHazeMaterialsApi
-@Composable
-fun StyledDropdown(
-    expanded: Boolean,
-    onDismissRequest: () -> Unit,
-    options: List<String>,
-    selectedOption: String,
-    touchOffset: Offset?,
-    boxPosition: Offset,
-    onOptionSelected: (String) -> Unit,
-    externalHoveredIndex: Int? = null,
-    externalDragActive: Boolean = false,
-    hazeState: HazeState,
-    @SuppressLint("ModifierParameter") modifier: Modifier = Modifier
-) {
-    if (expanded) {
-        val relativeOffset = touchOffset?.let { it - boxPosition } ?: Offset.Zero
-        Popup(
-            offset = IntOffset(relativeOffset.x.toInt(), relativeOffset.y.toInt()),
-            onDismissRequest = onDismissRequest
-        ) {
-            AnimatedVisibility(
-                visible = true,
-                enter = slideInVertically(initialOffsetY = { -it }) + fadeIn(),
-                exit = slideOutVertically(targetOffsetY = { -it }) + fadeOut()
-            ) {
-                Card(
-                    modifier = modifier
-                        .padding(8.dp)
-                        .width(300.dp)
-                        .background(Color.Transparent)
-                        .clip(RoundedCornerShape(8.dp)),
-                    elevation = CardDefaults.cardElevation(defaultElevation = 4.dp)
-                ) {
-                    var hoveredIndex by remember { mutableStateOf<Int?>(null) }
-                    val itemHeight = 48.dp
-
-                    val scope = rememberCoroutineScope()
-                    val haptics = LocalHapticFeedback.current
-
-                    var popupSize by remember { mutableStateOf(IntSize(0, 0)) }
-                    var lastDragPosition by remember { mutableStateOf<Offset?>(null) }
-
-                    LaunchedEffect(externalHoveredIndex, externalDragActive) {
-                        if (externalDragActive) {
-                            hoveredIndex = externalHoveredIndex
-                        }
-                    }
-
-                    Column(
-                        modifier = Modifier
-                            .onGloballyPositioned { coordinates ->
-                                popupSize = coordinates.size
-                            }
-                            .pointerInput(popupSize) {
-                                detectDragGestures(
-                                    onDragStart = { offset ->
-                                        hoveredIndex = (offset.y / itemHeight.toPx()).toInt()
-                                        lastDragPosition = offset
-                                    },
-                                    onDrag = { change, _ ->
-                                        val y = change.position.y
-                                        val newHoveredIndex = (y / itemHeight.toPx()).toInt()
-                                        if (newHoveredIndex != hoveredIndex) {
-                                            scope.launch { haptics.performHapticFeedback(
-                                                HapticFeedbackType.SegmentTick) }
-                                        }
-                                        hoveredIndex = newHoveredIndex
-                                        lastDragPosition = change.position
-                                    },
-                                    onDragEnd = {
-                                        val pos = lastDragPosition
-                                        val withinBounds = pos != null &&
-                                            pos.x >= 0f && pos.y >= 0f &&
-                                            pos.x <= popupSize.width.toFloat() && pos.y <= popupSize.height.toFloat()
-
-                                        if (withinBounds) {
-                                            hoveredIndex?.let { idx ->
-                                                if (idx in options.indices) {
-                                                    scope.launch { haptics.performHapticFeedback(
-                                                        HapticFeedbackType.GestureEnd) }
-                                                    onOptionSelected(options[idx])
-                                                }
-                                            }
-                                            onDismissRequest()
-                                        } else {
-                                            hoveredIndex = null
-                                        }
-                                    }
-                                )
-                            }
-                    ) {
-                        options.forEachIndexed { index, text ->
-                            val isHovered =
-                                if (externalDragActive && externalHoveredIndex != null) {
-                                    index == externalHoveredIndex
-                                } else {
-                                    index == hoveredIndex
-                                }
-                            val isSystemInDarkTheme = isSystemInDarkTheme()
-                            Box(
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .height(itemHeight)
-                                    .background(
-                                        Color.Transparent
-                                    )
-                                    .clickable(
-                                        interactionSource = remember { MutableInteractionSource() },
-                                        indication = null
-                                    ) {
-                                        scope.launch { haptics.performHapticFeedback(HapticFeedbackType.ContextClick) }
-                                        onOptionSelected(text)
-                                        onDismissRequest()
-                                    }
-                                    .hazeEffect(
-                                        state = hazeState,
-                                        style = CupertinoMaterials.regular(),
-                                        block = fun HazeEffectScope.() {
-                                            alpha = 1f
-                                            backgroundColor = if (isSystemInDarkTheme) {
-                                                Color(0xB02C2C2E)
-                                            } else {
-                                                Color(0xB0FFFFFF)
-                                            }
-                                            tints = if (isHovered) listOf(
-                                                HazeTint(
-                                                    color = if (isSystemInDarkTheme) Color(0x338A8A8A) else Color(0x40D9D9D9)
-                                                )
-                                            ) else listOf()
-                                        })
-                                    .padding(horizontal = 12.dp),
-                                contentAlignment = Alignment.CenterStart
-                            ) {
-                                Row(
-                                    modifier = Modifier.fillMaxWidth(),
-                                    horizontalArrangement = Arrangement.SpaceBetween,
-                                    verticalAlignment = Alignment.CenterVertically
-                                ) {
-                                    Text(
-                                        text,
-                                        style = TextStyle(
-                                            fontSize = 16.sp,
-                                            color = if (isSystemInDarkTheme()) Color.White else Color.Black.copy(alpha = 0.75f),
-                                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                                        )
-                                    )
-                                    Checkbox(
-                                        checked = text == selectedOption,
-                                        onCheckedChange = { onOptionSelected(text) },
-                                        colors = CheckboxDefaults.colors().copy(
-                                            checkedCheckmarkColor = Color(0xFF007AFF),
-                                            uncheckedCheckmarkColor = Color.Transparent,
-                                            checkedBoxColor = Color.Transparent,
-                                            uncheckedBoxColor = Color.Transparent,
-                                            checkedBorderColor = Color.Transparent,
-                                            uncheckedBorderColor = Color.Transparent,
-                                            disabledBorderColor = Color.Transparent,
-                                            disabledCheckedBoxColor = Color.Transparent,
-                                            disabledUncheckedBoxColor = Color.Transparent,
-                                            disabledUncheckedBorderColor = Color.Transparent
-                                        )
-                                    )
-                                }
-                            }
-
-                            if (index != options.lastIndex) {
-                                HorizontalDivider(
-                                    thickness = 1.dp,
-                                    color = Color(0x40888888),
-                                    modifier = Modifier.padding(start = 12.dp, end = 0.dp)
-                                )
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledIconButton.kt

@@ -1,306 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.graphics.RuntimeShader
-import android.os.Build
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.VectorConverter
-import androidx.compose.animation.core.VisibilityThreshold
-import androidx.compose.animation.core.spring
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.BlendMode
-import androidx.compose.ui.graphics.BlurEffect
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.ShaderBrush
-import androidx.compose.ui.graphics.TileMode
-import androidx.compose.ui.graphics.drawOutline
-import androidx.compose.ui.graphics.drawscope.translate
-import androidx.compose.ui.graphics.isSpecified
-import androidx.compose.ui.graphics.layer.CompositingStrategy
-import androidx.compose.ui.graphics.layer.drawLayer
-import androidx.compose.ui.graphics.rememberGraphicsLayer
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.util.fastCoerceAtMost
-import androidx.compose.ui.util.fastCoerceIn
-import androidx.compose.ui.util.lerp
-import com.kyant.backdrop.backdrops.LayerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import com.kyant.backdrop.drawBackdrop
-import com.kyant.backdrop.effects.lens
-import com.kyant.backdrop.highlight.Highlight
-import com.kyant.backdrop.shadow.Shadow
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.utils.inspectDragGestures
-import kotlin.math.abs
-import kotlin.math.atan2
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.math.tanh
-
-@Composable
-fun StyledIconButton(
-    modifier: Modifier = Modifier,
-    icon: String,
-    iconTint: Color = Color.Unspecified,
-    surfaceColor: Color = Color.Unspecified,
-    backdrop: LayerBackdrop = rememberLayerBackdrop(),
-    onClick: () -> Unit,
-    enabled: Boolean = true
-) {
-    val haptics = LocalHapticFeedback.current
-    val darkMode = isSystemInDarkTheme()
-    val scope = rememberCoroutineScope()
-    val progressAnimationSpec = spring(0.5f, 300f, 0.001f)
-    val offsetAnimationSpec = spring(1f, 300f, Offset.VisibilityThreshold)
-    val progressAnimation = remember { Animatable(0f) }
-    val offsetAnimation = remember { Animatable(Offset.Zero, Offset.VectorConverter) }
-    var pressStartPosition by remember { mutableStateOf(Offset.Zero) }
-    val innerShadowLayer = rememberGraphicsLayer().apply {
-        compositingStrategy = CompositingStrategy.Offscreen
-    }
-    val density = LocalDensity.current
-
-    val interactiveHighlightShader = remember {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            RuntimeShader(
-                """
-uniform float2 size;
-layout(color) uniform half4 color;
-uniform float radius;
-uniform float2 offset;
-
-half4 main(float2 coord) {
-    float2 center = offset;
-    float dist = distance(coord, center);
-    float intensity = smoothstep(radius, radius * 0.5, dist);
-    return color * intensity;
-}"""
-            )
-        } else {
-            null
-        }
-    }
-    val isDarkTheme = isSystemInDarkTheme()
-    TextButton(
-        onClick = {
-            if (enabled) {
-                scope.launch { haptics.performHapticFeedback(HapticFeedbackType.ContextClick) }
-                onClick()
-            }
-        },
-        shape = RoundedCornerShape(56.dp),
-        modifier = modifier
-            .padding(horizontal = 12.dp)
-            .drawBackdrop(
-                backdrop = backdrop,
-                shape = { RoundedCornerShape(56.dp) },
-                highlight = { Highlight.Ambient.copy(alpha = if (isDarkTheme) 1f else 0f) },
-                shadow = {
-                    Shadow(
-                        radius = 12f.dp,
-                        color = Color.Black.copy(if (isDarkTheme) 0.08f else 0.2f)
-                    )
-                },
-                layerBlock = {
-                    if (!enabled) return@drawBackdrop
-                    val width = size.width
-                    val height = size.height
-
-                    val progress = progressAnimation.value
-                    val scale = lerp(1f, 1.5f, progress)
-
-                    val maxOffset = size.minDimension
-                    val initialDerivative = 0.05f
-                    val offset = offsetAnimation.value
-                    translationX = maxOffset * tanh(initialDerivative * offset.x / maxOffset)
-                    translationY = maxOffset * tanh(initialDerivative * offset.y / maxOffset)
-
-                    val maxDragScale = 0.1f
-                    val offsetAngle = atan2(offset.y, offset.x)
-                    scaleX =
-                        scale +
-                            maxDragScale * abs(cos(offsetAngle) * offset.x / size.maxDimension) *
-                            (width / height).fastCoerceAtMost(1f)
-                    scaleY =
-                        scale +
-                            maxDragScale * abs(sin(offsetAngle) * offset.y / size.maxDimension) *
-                            (height / width).fastCoerceAtMost(1f)
-                },
-                onDrawSurface = {
-                    if (!enabled) {
-                        drawRect(
-                            (if (isDarkTheme) Color(0xFFAFAFAF) else Color.White).copy(0.5f)
-                        )
-                        return@drawBackdrop
-                    }
-                    val progress = progressAnimation.value.coerceIn(0f, 1f)
-
-                    val shape = RoundedCornerShape(56.dp)
-                    val outline = shape.createOutline(size, layoutDirection, this)
-                    val innerShadowOffset = 4f.dp.toPx()
-                    val innerShadowBlurRadius = 4f.dp.toPx()
-
-                    innerShadowLayer.alpha = progress
-                    innerShadowLayer.renderEffect =
-                        BlurEffect(
-                            innerShadowBlurRadius,
-                            innerShadowBlurRadius,
-                            TileMode.Decal
-                        )
-                    innerShadowLayer.record {
-                        drawOutline(outline, Color.Black.copy(0.2f))
-                        translate(0f, innerShadowOffset) {
-                            drawOutline(
-                                outline,
-                                Color.Transparent,
-                                blendMode = BlendMode.Clear
-                            )
-                        }
-                    }
-                    drawLayer(innerShadowLayer)
-
-                    if (surfaceColor.isSpecified) {
-                        drawRect(surfaceColor)
-                    }
-
-                    drawRect(
-                        (if (isDarkTheme) Color(0xFFAFAFAF) else Color.White).copy(
-                            progress.coerceIn(
-                                0.15f,
-                                0.35f
-                            )
-                        )
-                    )
-                },
-                onDrawFront = {
-                    if (!enabled) return@drawBackdrop
-                    val progress = progressAnimation.value.fastCoerceIn(0f, 1f)
-                    if (progress > 0f) {
-                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && interactiveHighlightShader != null) {
-                            drawRect(
-                                Color.White.copy(0.1f * progress),
-                                blendMode = BlendMode.Plus
-                            )
-                            interactiveHighlightShader.apply {
-                                val offset = pressStartPosition + offsetAnimation.value
-                                setFloatUniform("size", size.width, size.height)
-                                setColorUniform(
-                                    "color",
-                                    Color.White.copy(0.15f * progress).toArgb()
-                                )
-                                setFloatUniform("radius", size.maxDimension)
-                                setFloatUniform(
-                                    "offset",
-                                    offset.x.fastCoerceIn(0f, size.width),
-                                    offset.y.fastCoerceIn(0f, size.height)
-                                )
-                            }
-                            drawRect(
-                                ShaderBrush(interactiveHighlightShader),
-                                blendMode = BlendMode.Plus
-                            )
-                        } else {
-                            drawRect(
-                                Color.White.copy(0.25f * progress),
-                                blendMode = BlendMode.Plus
-                            )
-                        }
-                    }
-                },
-                effects = {
-                    lens(
-                        refractionHeight = 6f.dp.toPx(),
-                        refractionAmount = size.height / 2f,
-                        depthEffect = true,
-                        chromaticAberration = true
-                    )
-                },
-            )
-            .pointerInput(scope) {
-                val onDragStop: () -> Unit = {
-                    if (enabled) {
-                        scope.launch {
-                            launch { haptics.performHapticFeedback(HapticFeedbackType.Reject) }
-                            launch { progressAnimation.animateTo(0f, progressAnimationSpec) }
-                            launch { offsetAnimation.animateTo(Offset.Zero, offsetAnimationSpec) }
-                        }
-                    }
-                }
-                inspectDragGestures(
-                    onDragStart = { down ->
-                        if (enabled) {
-                            pressStartPosition = down.position
-                            scope.launch {
-                                launch { haptics.performHapticFeedback(HapticFeedbackType.SegmentFrequentTick) }
-                                launch { progressAnimation.animateTo(1f, progressAnimationSpec) }
-                                launch { offsetAnimation.snapTo(Offset.Zero) }
-                            }
-                        }
-                    },
-                    onDragEnd = { onDragStop() },
-                    onDragCancel = onDragStop
-                ) { _, dragAmount ->
-                    scope.launch {
-                        if (enabled) {
-                            if (dragAmount.getDistanceSquared() > 350) haptics.performHapticFeedback(
-                                HapticFeedbackType.SegmentFrequentTick
-                            )
-                            offsetAnimation.snapTo(offsetAnimation.value + dragAmount)
-                        }
-                    }
-                }
-            }
-            .size(with(density) { 48.sp.toDp() }),
-    ) {
-        Text(
-            text = icon,
-            style = TextStyle(
-                fontSize = 20.sp,
-                fontWeight = FontWeight.Normal,
-                color = if (iconTint.isSpecified) iconTint else if (darkMode) Color.White else Color.Black,
-                fontFamily = FontFamily(Font(R.font.sf_pro))
-            )
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledInputField.kt

@@ -1,154 +0,0 @@
-package me.kavishdevar.librepods.presentation.components
-
-import android.R.attr.singleLine
-import androidx.compose.animation.core.animateDp
-import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.animation.core.updateTransition
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.text.input.TextFieldLineLimits
-import androidx.compose.foundation.text.input.TextFieldState
-import androidx.compose.foundation.text.input.clearText
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.focus.focusRequester
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.SolidColor
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import me.kavishdevar.librepods.R
-
-
-@Composable
-fun StyledInputField(
-    inputState: TextFieldState,
-    focusRequester: FocusRequester,
-    placeholder: String = "",
-    singleLine: Boolean = true
-){
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val minHeight = if (singleLine) 58.dp else 120.dp
-    val verticalAlignment = if (singleLine) Alignment.CenterVertically else Alignment.Top
-    val hasText = inputState.text.isNotEmpty()
-    val density = LocalDensity.current
-    val spacerHeight by animateDpAsState(
-        targetValue = if (hasText) with(density) { 32.sp.toDp() } else 0.dp,
-        label = "labelSpacer"
-    )
-
-    val transition = updateTransition(hasText, label = "floating")
-    val yOffset by transition.animateDp(label = "y") {
-        if (it) with (density) { (-48).sp.toDp() } else 0.dp
-    }
-
-    Spacer(modifier = Modifier.height(spacerHeight))
-
-    Box(
-        modifier = Modifier.fillMaxWidth()
-    ) {
-        Row(
-            verticalAlignment = verticalAlignment,
-            modifier = Modifier
-                .fillMaxWidth()
-                .heightIn(min = minHeight)
-                .background(
-                    backgroundColor,
-                    RoundedCornerShape(28.dp)
-                )
-                .padding(horizontal = 16.dp, vertical = 8.dp)
-                .pointerInput(Unit) {
-                    detectTapGestures {
-                        focusRequester.requestFocus()
-                    }
-                }
-        ) {
-            BasicTextField(
-                state = inputState,
-                lineLimits = if (singleLine) TextFieldLineLimits.SingleLine else TextFieldLineLimits.Default,
-                textStyle = TextStyle(
-                    fontSize = 16.sp,
-                    color = textColor,
-                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                ),
-                cursorBrush = SolidColor(textColor),
-                decorator = { innerTextField ->
-                    Row(
-                        modifier = Modifier.padding(top = if (singleLine) 0.dp else 16.dp),
-                        verticalAlignment = verticalAlignment,
-                    ) {
-                        Row(
-                            modifier = Modifier
-                                .weight(1f)
-                        ) {
-                            Box(
-                                modifier = Modifier
-                                    .weight(1f),
-                                contentAlignment = if (singleLine) Alignment.CenterStart else Alignment.TopStart
-                            ) {
-                                Text(
-                                    text = placeholder,
-                                    style = TextStyle(
-                                        fontSize = 16.sp,
-                                        fontWeight = FontWeight.Light,
-                                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                        color = textColor.copy(alpha = 0.8f)
-                                    ),
-                                    modifier = Modifier
-                                        .offset(y = yOffset)
-                                )
-
-                                innerTextField()
-                            }
-                        }
-                        if (singleLine && !inputState.text.isEmpty()) {
-                            IconButton(
-                                onClick = {
-                                    inputState.clearText()
-                                }
-                            ) {
-                                Text(
-                                    text = "􀁡",
-                                    style = TextStyle(
-                                        fontSize = 16.sp,
-                                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                        color = if (isDarkTheme) Color.White.copy(alpha = 0.6f) else Color.Black.copy(
-                                            alpha = 0.6f
-                                        )
-                                    ),
-                                )
-                            }
-                        }
-                    }
-                },
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(start = 8.dp)
-                    .focusRequester(focusRequester)
-            )
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledScaffold.kt

@@ -1,163 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.SnackbarHost
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.shadow
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalLayoutDirection
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.zIndex
-import com.kyant.backdrop.backdrops.LayerBackdrop
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.HazeProgressive
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.HazeTint
-import dev.chrisbanes.haze.hazeEffect
-import dev.chrisbanes.haze.rememberHazeState
-import me.kavishdevar.librepods.R
-
-@Composable
-fun StyledScaffold(
-    title: String,
-    actionButtons: List<@Composable (backdrop: LayerBackdrop) -> Unit> = emptyList(),
-    snackbarHostState: SnackbarHostState = remember { SnackbarHostState() },
-    content: @Composable (spacerValue: Dp, hazeState: HazeState, bottomPadding: Dp) -> Unit
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val hazeState = rememberHazeState(blurEnabled = true)
-
-    Scaffold(
-        containerColor = if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7),
-        snackbarHost = { SnackbarHost(snackbarHostState) },
-        modifier = Modifier
-            .then(if (!isDarkTheme) Modifier.shadow(elevation = 36.dp, shape = RoundedCornerShape(52.dp), ambientColor = Color.Black, spotColor = Color.Black) else Modifier)
-            .clip(RoundedCornerShape(52.dp))
-    ) { paddingValues ->
-        val topPadding = paddingValues.calculateTopPadding()
-        val bottomPadding = paddingValues.calculateBottomPadding() + 16.dp
-        val startPadding = paddingValues.calculateLeftPadding(LocalLayoutDirection.current)
-        val endPadding = paddingValues.calculateRightPadding(LocalLayoutDirection.current)
-
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(start = startPadding, end = endPadding)
-        ) {
-            val backdrop = rememberLayerBackdrop()
-            Box(
-                modifier = Modifier
-                    .zIndex(2f)
-                    .height(64.dp + topPadding)
-                    .fillMaxWidth()
-                    .layerBackdrop(backdrop)
-                    .hazeEffect(state = hazeState) {
-                        tints = listOf(HazeTint(color = if (isDarkTheme) Color.Black else Color.White))
-                        progressive = HazeProgressive.verticalGradient(startIntensity = 1f, endIntensity = 0f)
-                    }
-            ) {
-                Column(modifier = Modifier.fillMaxSize()) {
-                    Spacer(modifier = Modifier.height(topPadding + 12.dp))
-                    Text(
-                            text = title,
-                            style = TextStyle(
-                                fontSize = 20.sp,
-                                fontWeight = FontWeight.Medium,
-                                color = if (isDarkTheme) Color.White else Color.Black,
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            modifier = Modifier.fillMaxWidth(),
-                            textAlign = TextAlign.Center
-                        )
-                }
-            }
-            Row(
-                modifier = Modifier
-                    .zIndex(3f)
-                    .padding(top = topPadding, end = 8.dp)
-                    .align(Alignment.TopEnd)
-            ) {
-                actionButtons.forEach { actionButton ->
-                    actionButton(backdrop)
-                }
-            }
-
-            content(topPadding + 64.dp, hazeState, bottomPadding + 12.dp)
-        }
-    }
-}
-
-
-@Composable
-fun StyledScaffold(
-    title: String,
-    actionButtons: List<@Composable (backdrop: LayerBackdrop) -> Unit> = emptyList(),
-    snackbarHostState: SnackbarHostState = remember { SnackbarHostState() },
-    content: @Composable () -> Unit
-) {
-    StyledScaffold(
-        title = title,
-        actionButtons = actionButtons,
-        snackbarHostState = snackbarHostState,
-    ) { _, _, _->
-        content()
-    }
-}
-
-@Composable
-fun StyledScaffold(
-    title: String,
-    actionButtons: List<@Composable (backdrop: LayerBackdrop) -> Unit> = emptyList(),
-    snackbarHostState: SnackbarHostState = remember { SnackbarHostState() },
-    content: @Composable (spacerValue: Dp) -> Unit
-) {
-    StyledScaffold(
-        title = title,
-        actionButtons = actionButtons,
-        snackbarHostState = snackbarHostState,
-    ) { spacerValue, _, _ ->
-        content(spacerValue)
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledSelectList.kt

@@ -1,188 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.animateColorAsState
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.wrapContentWidth
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import me.kavishdevar.librepods.R
-
-data class SelectItem(
-    val name: String,
-    val description: String? = null,
-    val iconRes: Int? = null,
-    val selected: Boolean,
-    val onClick: () -> Unit,
-    val visible: Boolean = true,
-    val enabled: Boolean = true
-)
-
-@Composable
-fun StyledSelectList(
-    items: List<SelectItem>,
-    modifier: Modifier = Modifier
-) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    val haptics = LocalHapticFeedback.current
-
-    Column(
-        modifier = modifier
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(28.dp)),
-        horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        val visibleItems = items.filter { it.visible }
-        visibleItems.forEachIndexed { index, item ->
-            val isFirst = index == 0
-            val isLast = index == visibleItems.size - 1
-            val hasIcon = item.iconRes != null
-
-            val shape = when {
-                isFirst && isLast -> RoundedCornerShape(28.dp)
-                isFirst -> RoundedCornerShape(topStart = 28.dp, topEnd = 28.dp)
-                isLast -> RoundedCornerShape(bottomStart = 28.dp, bottomEnd = 28.dp)
-                else -> RoundedCornerShape(0.dp)
-            }
-            var itemBackgroundColor by remember { mutableStateOf(if (item.enabled) backgroundColor else if (isDarkTheme) Color(0x40050505) else Color(0x40D9D9D9)) }
-            val animatedBackgroundColor by animateColorAsState(targetValue = itemBackgroundColor, animationSpec = tween(durationMillis = 500))
-
-            Row(
-                modifier = Modifier
-                    .heightIn(min = if (hasIcon) 72.dp else 55.dp)
-                    .background(animatedBackgroundColor, shape)
-                    .pointerInput(Unit) {
-                        detectTapGestures(
-                            onPress = {
-                                if (item.enabled) {
-                                    itemBackgroundColor =
-                                        if (isDarkTheme) Color(0x40888888) else Color(0x40D9D9D9)
-                                    tryAwaitRelease()
-                                    itemBackgroundColor = backgroundColor
-                                }
-                            },
-                            onTap = {
-                                if (item.enabled) {
-                                    haptics.performHapticFeedback(HapticFeedbackType.ContextClick)
-                                    item.onClick()
-                                }
-                            }
-                        )
-                    }
-                    .padding(horizontal = 16.dp),
-                verticalAlignment = Alignment.CenterVertically,
-                horizontalArrangement = Arrangement.SpaceBetween
-            ) {
-                if (hasIcon) {
-                    Icon(
-                        painter = painterResource(item.iconRes),
-                        contentDescription = "Icon",
-                        tint = Color(0xFF007AFF),
-                        modifier = Modifier
-                            .height(48.dp)
-                            .wrapContentWidth()
-                    )
-                }
-                Column(
-                    modifier = Modifier
-                        .weight(1f)
-                        .padding(vertical = 2.dp)
-                        .padding(start = if (hasIcon) 8.dp else 4.dp)
-                ) {
-                    Text(
-                        item.name,
-                        fontSize = 16.sp,
-                        color = textColor,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    )
-                    item.description?.let {
-                        Text(
-                            it,
-                            fontSize = 14.sp,
-                            color = textColor.copy(alpha = 0.6f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        )
-                    }
-                }
-                val floatAnimateState by animateFloatAsState(
-                    targetValue = if (item.selected) 1f else 0f,
-                    animationSpec = tween(durationMillis = 300)
-                )
-                Text(
-                    text = "􀆅",
-                    style = TextStyle(
-                        fontSize = 20.sp,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = Color(0xFF007AFF).copy(alpha = floatAnimateState),
-                    ),
-                    modifier = Modifier.padding(end = 4.dp)
-                )
-            }
-            if (!isLast) {
-                if (hasIcon) {
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(start = 72.dp, end = 20.dp)
-                    )
-                } else {
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(start = 20.dp, end = 20.dp)
-                    )
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledSlider.kt

@@ -1,631 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import android.annotation.SuppressLint
-import android.content.res.Configuration
-import android.util.Log
-import androidx.compose.animation.core.Animatable
-import androidx.compose.animation.core.FiniteAnimationSpec
-import androidx.compose.animation.core.spring
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.draggable
-import androidx.compose.foundation.gestures.rememberDraggableState
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.size
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.derivedStateOf
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.graphicsLayer
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.input.pointer.util.VelocityTracker
-import androidx.compose.ui.input.pointer.util.addPointerInputChange
-import androidx.compose.ui.layout.layout
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.layout.onSizeChanged
-import androidx.compose.ui.layout.positionInParent
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.Velocity
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.compose.ui.util.fastCoerceIn
-import androidx.compose.ui.util.fastRoundToInt
-import androidx.compose.ui.util.lerp
-import com.kyant.backdrop.Backdrop
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberCombinedBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import com.kyant.backdrop.drawBackdrop
-import com.kyant.backdrop.effects.blur
-import com.kyant.backdrop.effects.lens
-import com.kyant.backdrop.highlight.Highlight
-import com.kyant.backdrop.shadow.InnerShadow
-import com.kyant.backdrop.shadow.Shadow
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.utils.inspectDragGestures
-import kotlin.math.abs
-import kotlin.math.roundToInt
-
-@Composable
-fun rememberMomentumAnimation(
-    maxScale: Float,
-    progressAnimationSpec: FiniteAnimationSpec<Float> =
-        spring(1f, 1000f, 0.01f),
-    velocityAnimationSpec: FiniteAnimationSpec<Float> =
-        spring(0.5f, 250f, 5f),
-    scaleXAnimationSpec: FiniteAnimationSpec<Float> =
-        spring(0.4f, 400f, 0.01f),
-    scaleYAnimationSpec: FiniteAnimationSpec<Float> =
-        spring(0.6f, 400f, 0.01f)
-): MomentumAnimation {
-    val animationScope = rememberCoroutineScope()
-    return remember(
-        maxScale,
-        animationScope,
-        progressAnimationSpec,
-        velocityAnimationSpec,
-        scaleXAnimationSpec,
-        scaleYAnimationSpec
-    ) {
-        MomentumAnimation(
-            maxScale = maxScale,
-            animationScope = animationScope,
-            progressAnimationSpec = progressAnimationSpec,
-            velocityAnimationSpec = velocityAnimationSpec,
-            scaleXAnimationSpec = scaleXAnimationSpec,
-            scaleYAnimationSpec = scaleYAnimationSpec
-        )
-    }
-}
-
-class MomentumAnimation(
-    val maxScale: Float,
-    private val animationScope: CoroutineScope,
-    private val progressAnimationSpec: FiniteAnimationSpec<Float>,
-    private val velocityAnimationSpec: FiniteAnimationSpec<Float>,
-    private val scaleXAnimationSpec: FiniteAnimationSpec<Float>,
-    private val scaleYAnimationSpec: FiniteAnimationSpec<Float>
-) {
-
-    private val velocityTracker = VelocityTracker()
-
-    private val progressAnimation = Animatable(0f)
-    private val velocityAnimation = Animatable(0f)
-    private val scaleXAnimation = Animatable(1f)
-    private val scaleYAnimation = Animatable(1f)
-
-    val progress: Float get() = progressAnimation.value
-    val velocity: Float get() = velocityAnimation.value
-    val scaleX: Float get() = scaleXAnimation.value
-    val scaleY: Float get() = scaleYAnimation.value
-
-    var isDragging: Boolean by mutableStateOf(false)
-        private set
-
-    val modifier: Modifier = Modifier.pointerInput(Unit) {
-        inspectDragGestures(
-            onDragStart = {
-                isDragging = true
-                velocityTracker.resetTracking()
-                startPressingAnimation()
-            },
-            onDragEnd = { change ->
-                isDragging = false
-                val velocity = velocityTracker.calculateVelocity()
-                updateVelocity(velocity)
-                velocityTracker.addPointerInputChange(change)
-                velocityTracker.resetTracking()
-                endPressingAnimation()
-                settleVelocity()
-            },
-            onDragCancel = {
-                isDragging = false
-                velocityTracker.resetTracking()
-                endPressingAnimation()
-                settleVelocity()
-            }
-        ) { change, _ ->
-            isDragging = true
-            velocityTracker.addPointerInputChange(change)
-            val velocity = velocityTracker.calculateVelocity()
-            updateVelocity(velocity)
-        }
-    }
-
-    private fun updateVelocity(velocity: Velocity) {
-        animationScope.launch { velocityAnimation.animateTo(velocity.x, velocityAnimationSpec) }
-    }
-
-    private fun settleVelocity() {
-        animationScope.launch { velocityAnimation.animateTo(0f, velocityAnimationSpec) }
-    }
-
-    fun startPressingAnimation() {
-        animationScope.launch {
-            launch { progressAnimation.animateTo(1f, progressAnimationSpec) }
-            launch { scaleXAnimation.animateTo(maxScale, scaleXAnimationSpec) }
-            launch { scaleYAnimation.animateTo(maxScale, scaleYAnimationSpec) }
-        }
-    }
-
-    fun endPressingAnimation() {
-        animationScope.launch {
-            launch { progressAnimation.animateTo(0f, progressAnimationSpec) }
-            launch { scaleXAnimation.animateTo(1f, scaleXAnimationSpec) }
-            launch { scaleYAnimation.animateTo(1f, scaleYAnimationSpec) }
-        }
-    }
-}
-
-@SuppressLint("UnrememberedMutableState")
-@Composable
-fun StyledSlider(
-    label: String? = null,
-    value: Float,
-    onValueChange: (Float) -> Unit,
-    valueRange: ClosedFloatingPointRange<Float>,
-    backdrop: Backdrop = rememberLayerBackdrop(),
-    snapPoints: List<Float> = emptyList(),
-    snapThreshold: Float = 0.05f,
-    startIcon: String? = null,
-    endIcon: String? = null,
-    startLabel: String? = null,
-    endLabel: String? = null,
-    independent: Boolean = false,
-    description: String? = null,
-    enabled: Boolean = true
-) {
-    val backgroundColor = if (isSystemInDarkTheme()) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val isLightTheme = !isSystemInDarkTheme()
-    val trackColor =
-        if (isLightTheme) Color(0xFF787878).copy(0.2f)
-        else Color(0xFF787880).copy(0.36f)
-    val accentColor =
-        if (enabled) {
-            if (isLightTheme) Color(0xFF0088FF)
-            else Color(0xFF0091FF)
-        } else {
-            trackColor
-        }
-    val labelTextColor = if (isLightTheme) Color.Black else Color.White
-
-    val fraction by derivedStateOf {
-        ((value - valueRange.start) / (valueRange.endInclusive - valueRange.start))
-            .fastCoerceIn(0f, 1f)
-    }
-
-    val sliderBackdrop = rememberLayerBackdrop()
-    val trackWidthState = remember { mutableFloatStateOf(0f) }
-    val trackPositionState = remember { mutableFloatStateOf(0f) }
-    val startIconWidthState = remember { mutableFloatStateOf(0f) }
-    val endIconWidthState = remember { mutableFloatStateOf(0f) }
-    val density = LocalDensity.current
-    val haptics = LocalHapticFeedback.current
-    var lastDragValue by remember { mutableFloatStateOf(value) }
-
-    val momentumAnimation = rememberMomentumAnimation(maxScale = 1.5f)
-
-    val content = @Composable {
-        Box(
-            Modifier
-                .fillMaxWidth(if (startIcon == null && endIcon == null) 0.95f else 1f)
-        ) {
-            Box(
-                Modifier
-                    .padding(vertical = 4.dp)
-                    .layerBackdrop(sliderBackdrop)
-                    .fillMaxWidth()
-            ) {
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth(1f)
-                        .padding(vertical = 12.dp),
-                    horizontalAlignment = Alignment.CenterHorizontally,
-                ) {
-                    if (startLabel != null || endLabel != null) {
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(horizontal = 8.dp),
-                            horizontalArrangement = Arrangement.SpaceBetween
-                        ) {
-                            Text(
-                                text = startLabel ?: "",
-                                style = TextStyle(
-                                    fontSize = 16.sp,
-                                    fontWeight = FontWeight.Normal,
-                                    color = labelTextColor,
-                                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                                )
-                            )
-                            Text(
-                                text = endLabel ?: "",
-                                style = TextStyle(
-                                    fontSize = 16.sp,
-                                    fontWeight = FontWeight.Normal,
-                                    color = labelTextColor,
-                                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                                )
-                            )
-                        }
-                        Spacer(modifier = Modifier.height(12.dp))
-                    }
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(vertical = 4.dp)
-                            .then(if (startIcon == null && endIcon == null) Modifier.padding(horizontal = 8.dp) else Modifier),
-                    ) {
-                        Row(
-                            verticalAlignment = Alignment.CenterVertically,
-                            horizontalArrangement = Arrangement.spacedBy(0.dp)
-                        ) {
-                            if (startIcon != null) {
-                                Text(
-                                    text = startIcon,
-                                    style = TextStyle(
-                                        fontSize = 18.sp,
-                                        fontWeight = FontWeight.Normal,
-                                        color = accentColor,
-                                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                                    ),
-                                    modifier = Modifier
-                                        .padding(horizontal = 12.dp)
-                                        .onGloballyPositioned {
-                                            startIconWidthState.floatValue = it.size.width.toFloat()
-                                        }
-                                )
-                            }
-                            Box(
-                                Modifier
-                                    .weight(1f)
-                                    .onSizeChanged { trackWidthState.floatValue = it.width.toFloat() }
-                                    .onGloballyPositioned {
-                                        trackPositionState.floatValue =
-                                            it.positionInParent().y + it.size.height / 2f
-                                    }
-                            ) {
-                                Box(
-                                    Modifier
-                                        .clip(RoundedCornerShape(28.dp))
-                                        .background(trackColor)
-                                        .height(6f.dp)
-                                        .fillMaxWidth()
-                                )
-
-                                Box(
-                                    Modifier
-                                        .clip(RoundedCornerShape(28.dp))
-                                        .background(accentColor)
-                                        .height(6f.dp)
-                                        .layout { measurable, constraints ->
-                                            val placeable = measurable.measure(constraints)
-                                            val fraction = fraction
-                                            val width =
-                                                (fraction * constraints.maxWidth).fastRoundToInt()
-                                            layout(width, placeable.height) {
-                                                placeable.place(0, 0)
-                                            }
-                                        }
-                                )
-                            }
-                            if (endIcon != null) {
-                                Text(
-                                    text = endIcon,
-                                    style = TextStyle(
-                                        fontSize = 18.sp,
-                                        fontWeight = FontWeight.Normal,
-                                        color = accentColor,
-                                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                                    ),
-                                    modifier = Modifier
-                                        .padding(horizontal = 12.dp)
-                                        .onGloballyPositioned {
-                                            endIconWidthState.floatValue = it.size.width.toFloat()
-                                        }
-                                )
-                            }
-                        }
-                        if (snapPoints.isNotEmpty() && startLabel != null && endLabel != null) Spacer(modifier = Modifier.height(4.dp))
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth(),
-                            horizontalArrangement = Arrangement.Center
-                        ) {
-                            if (snapPoints.isNotEmpty()) {
-                                val trackWidth = if (startIcon != null && endIcon != null) trackWidthState.floatValue - with(density) { 6.dp.toPx() } * 2 else trackWidthState.floatValue- with(density) { 22.dp.toPx() }
-                                val startOffset =
-                                    if (startIcon != null) startIconWidthState.floatValue + with(
-                                        density
-                                    ) { 34.dp.toPx() } else with(density) { 14.dp.toPx() }
-                                Box(
-                                    Modifier
-                                        .fillMaxWidth()
-                                ) {
-                                    snapPoints.forEach { point ->
-                                        val pointFraction =
-                                            ((point - valueRange.start) / (valueRange.endInclusive - valueRange.start))
-                                                .fastCoerceIn(0f, 1f)
-                                        Box(
-                                            Modifier
-                                                .graphicsLayer {
-                                                    translationX =
-                                                        startOffset + pointFraction * trackWidth - 4.dp.toPx()
-                                                }
-                                                .size(2.dp)
-                                                .background(
-                                                    trackColor,
-                                                    CircleShape
-                                                )
-                                        )
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            Box(
-                Modifier
-                    .graphicsLayer {
-//                        val startOffset =
-//                            if (startIcon != null) startIconWidthState.floatValue + with(density) { 24.dp.toPx() } else with(density) { 12.dp.toPx() }
-//                        translationX =
-//                            startOffset + fraction * trackWidthState.floatValue - size.width / 2f
-                        val startOffset =
-                            if (startIcon != null)
-                                startIconWidthState.floatValue + with(density) { 24.dp.toPx() }
-                            else
-                                with(density) { 8.dp.toPx() }
-
-                        translationX =
-                            (startOffset + fraction * trackWidthState.floatValue - size.width / 2f)
-                                .fastCoerceIn(
-                                    startOffset - size.width / 4f,
-                                    startOffset + trackWidthState.floatValue - size.width * 3f / 4f
-                                )
-                        translationY =  if (startLabel != null || endLabel != null) trackPositionState.floatValue + with(density) { 26.dp.toPx() } + size.height / 2f else trackPositionState.floatValue + with(density) { 8.dp.toPx() }
-                    }
-                    .then(
-                        if (enabled) {
-                            Modifier
-                                .draggable(
-                                    rememberDraggableState { delta ->
-                                        val trackWidth = trackWidthState.floatValue
-                                        if (trackWidth > 0f) {
-                                            val targetFraction = fraction + delta / trackWidth
-                                            val targetValue =
-                                                lerp(
-                                                    valueRange.start,
-                                                    valueRange.endInclusive,
-                                                    targetFraction
-                                                )
-                                                    .fastCoerceIn(
-                                                        valueRange.start,
-                                                        valueRange.endInclusive
-                                                    )
-                                            snapPoints.forEach { snap ->
-                                                if ((lastDragValue < snap && targetValue >= snap) ||
-                                                    (snap in targetValue..<lastDragValue)) {
-                                                    haptics.performHapticFeedback(HapticFeedbackType.SegmentTick)
-                                                }
-                                            }
-                                            lastDragValue = targetValue
-                                            val snappedValue = if (snapPoints.isNotEmpty()) snapIfClose(
-                                                targetValue,
-                                                snapPoints,
-                                                snapThreshold,
-                                            ) else targetValue
-                                            onValueChange(snappedValue)
-                                        }
-                                    },
-                                    Orientation.Horizontal,
-                                    startDragImmediately = true,
-                                    onDragStarted = {
-                                        lastDragValue = value
-                                    },
-                                    onDragStopped = {
-                                        onValueChange((value * 100).roundToInt() / 100f)
-                                    }
-                                )
-                                .then(momentumAnimation.modifier)
-                                .drawBackdrop(
-                                    rememberCombinedBackdrop(backdrop, sliderBackdrop),
-                                    { RoundedCornerShape(28.dp) },
-                                    highlight = {
-                                        val progress = momentumAnimation.progress
-                                        Highlight.Ambient.copy(alpha = progress)
-                                    },
-                                    shadow = {
-                                        Shadow(
-                                            radius = 4f.dp,
-                                            color = Color.Black.copy(0.05f)
-                                        )
-                                    },
-                                    innerShadow = {
-                                        val progress = momentumAnimation.progress
-                                        InnerShadow(
-                                            radius = 4f.dp * progress,
-                                            alpha = progress
-                                        )
-                                    },
-                                    layerBlock = {
-                                        scaleX = momentumAnimation.scaleX
-                                        scaleY = momentumAnimation.scaleY
-                                        val velocity = momentumAnimation.velocity / 5000f
-                                        scaleX /= 1f - (velocity * 0.75f).fastCoerceIn(-0.15f, 0.15f)
-                                        scaleY *= 1f - (velocity * 0.25f).fastCoerceIn(-0.15f, 0.15f)
-                                    },
-                                    onDrawSurface = {
-                                        val progress = momentumAnimation.progress
-                                        drawRect(Color.White.copy(alpha = 1f - progress))
-                                    },
-                                    effects = {
-                                        val progress = momentumAnimation.progress
-                                        blur(8f.dp.toPx() * (1f - progress))
-                                        lens(
-                                            refractionHeight = 6f.dp.toPx() * progress,
-                                            refractionAmount = size.height / 2f * progress,
-                                            depthEffect = true,
-                                            chromaticAberration = true
-                                        )
-                                    }
-                                )
-                        } else {
-                            Modifier.background(trackColor, RoundedCornerShape(28.dp))
-                        }
-                    )
-                    .size(40f.dp, 24f.dp)
-            )
-        }
-    }
-
-    if (independent) {
-
-        Column (
-            modifier = Modifier
-                .fillMaxWidth(),
-            verticalArrangement = Arrangement.spacedBy(2.dp)
-        ) {
-            if (label != null) {
-                Text(
-                    text = label,
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = labelTextColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier.padding(horizontal = 18.dp, vertical = 4.dp)
-                )
-            }
-
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .background(backgroundColor, RoundedCornerShape(28.dp))
-                    .padding(horizontal = 8.dp, vertical = 0.dp)
-                    .heightIn(min = 58.dp),
-                contentAlignment = Alignment.Center
-            ) {
-                content()
-            }
-
-            if (description != null) {
-                Text(
-                    text = description,
-                    style = TextStyle(
-                        fontSize = 12.sp,
-                        fontWeight = FontWeight.Light,
-                        color = (if (isSystemInDarkTheme()) Color.White else Color.Black).copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier
-                        .padding(horizontal = 18.dp, vertical = 4.dp)
-                )
-            }
-        }
-    } else {
-        if (label != null) Log.w("StyledSlider", "Label is ignored when independent is false")
-        if (description != null) Log.w("StyledSlider", "Description is ignored when independent is false")
-        content()
-    }
-}
-
-private fun snapIfClose(value: Float, points: List<Float>, threshold: Float = 0.05f): Float {
-    val nearest = points.minByOrNull { abs(it - value) } ?: value
-    return if (abs(nearest - value) <= threshold) nearest else value
-}
-
-@Preview(uiMode = Configuration.UI_MODE_NIGHT_YES)
-@Composable
-fun StyledSliderPreview() {
-    val a = remember { mutableFloatStateOf(0.5f) }
-    Box(
-        Modifier
-            .background(if (isSystemInDarkTheme()) Color(0xFF000000) else Color(0xFFF0F0F0))
-            .padding(16.dp)
-            .fillMaxSize()
-    ) {
-        Column (
-            Modifier.align(Alignment.Center),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        )
-        {
-            StyledSlider(
-                value = a.floatValue,
-                onValueChange = {
-                    a.floatValue = it
-                },
-                valueRange = 0f..2f,
-                snapPoints = listOf(1f),
-                snapThreshold = 0.1f,
-                independent = true,
-                startIcon = "A",
-                endIcon = "B",
-            )
-            StyledSlider(
-                value = a.floatValue,
-                onValueChange = {
-                    a.floatValue = it
-                },
-                valueRange = 0f..2f,
-                snapPoints = listOf(1f),
-                snapThreshold = 0.1f,
-                independent = true,
-                startIcon = "A",
-                endIcon = "B",
-                enabled = false
-            )
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/StyledToggle.kt

@@ -1,273 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.animateColorAsState
-import androidx.compose.animation.core.tween
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.interaction.MutableInteractionSource
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.rememberUpdatedState
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@Composable
-fun StyledToggle(
-    title: String? = null,
-    label: String,
-    description: String? = null,
-    checked: Boolean = false,
-    independent: Boolean = true,
-    enabled: Boolean = true,
-    onCheckedChange: (Boolean) -> Unit,
-) {
-    val currentChecked by rememberUpdatedState(checked)
-
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    val haptics = LocalHapticFeedback.current
-    val scope = rememberCoroutineScope()
-
-    var backgroundColor by remember {
-        mutableStateOf(
-            if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-        )
-    }
-
-    val animatedBackgroundColor by animateColorAsState(
-        targetValue = backgroundColor,
-        animationSpec = tween(durationMillis = 500)
-    )
-
-    if (independent) {
-        Column(modifier = Modifier.padding(vertical = 8.dp)) {
-            if (title != null) {
-                Text(
-                    text = title,
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier.padding(
-                        start = 16.dp,
-                        end = 16.dp,
-                        top = 8.dp,
-                        bottom = 4.dp
-                    )
-                )
-            }
-
-            Box(
-                modifier = Modifier
-                    .background(animatedBackgroundColor, RoundedCornerShape(28.dp))
-                    .padding(4.dp)
-                    .pointerInput(Unit) {
-                        detectTapGestures(
-                            onPress = {
-                                if (enabled) {
-                                    backgroundColor =
-                                        if (isDarkTheme) Color(0x40888888) else Color(0x40D9D9D9)
-                                    tryAwaitRelease()
-                                    backgroundColor =
-                                        if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-                                }
-                            },
-                            onTap = {
-                                if (enabled) {
-                                    scope.launch { haptics.performHapticFeedback(if (!currentChecked) HapticFeedbackType.ToggleOn else HapticFeedbackType.ToggleOff) }
-                                    onCheckedChange(!currentChecked)
-                                }
-                            }
-                        )
-                    }
-            ) {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .height(55.dp)
-                        .padding(horizontal = 12.dp),
-                    verticalAlignment = Alignment.CenterVertically
-                ) {
-                    Text(
-                        text = label,
-                        modifier = Modifier.weight(1f),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            fontWeight = FontWeight.Normal,
-                            color = textColor
-                        )
-                    )
-
-                    StyledSwitch(
-                        checked = checked,
-                        enabled = enabled,
-                        onCheckedChange = {
-                            if (enabled) {
-                                scope.launch { haptics.performHapticFeedback(if (it) HapticFeedbackType.ToggleOn else HapticFeedbackType.ToggleOff) }
-                                onCheckedChange(it)
-                            }
-                        }
-                    )
-                }
-            }
-
-            if (description != null) {
-                Spacer(modifier = Modifier.height(8.dp))
-
-                Box(
-                    modifier = Modifier
-                        .padding(horizontal = 16.dp)
-                        .background(
-                            if (isDarkTheme) Color(0xFF000000)
-                            else Color(0xFFF2F2F7)
-                        )
-                ) {
-                    Text(
-                        text = description,
-                        style = TextStyle(
-                            fontSize = 12.sp,
-                            fontWeight = FontWeight.Light,
-                            color = textColor.copy(alpha = 0.6f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-            }
-        }
-    } else {
-        val isPressed = remember { mutableStateOf(false) }
-
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .background(
-                    shape = RoundedCornerShape(28.dp),
-                    color = if (isPressed.value) Color(0xFFE0E0E0) else Color.Transparent
-                )
-                .padding(16.dp)
-                .pointerInput(Unit) {
-                    detectTapGestures(
-                        onPress = {
-                            isPressed.value = true
-                            tryAwaitRelease()
-                            isPressed.value = false
-                        }
-                    )
-                }
-                .clickable(
-                    indication = null,
-                    interactionSource = remember { MutableInteractionSource() }
-                ) {
-                    if (enabled) {
-                        scope.launch { haptics.performHapticFeedback(if (!currentChecked) HapticFeedbackType.ToggleOn else HapticFeedbackType.ToggleOff) }
-                        onCheckedChange(!currentChecked)
-                    }
-                },
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Column(
-                modifier = Modifier
-                    .weight(1f)
-                    .padding(end = 4.dp)
-            ) {
-                Text(
-                    text = label,
-                    style = TextStyle(
-                        fontSize = 16.sp,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        fontWeight = FontWeight.Normal,
-                        color = textColor
-                    )
-                )
-
-                Spacer(modifier = Modifier.height(4.dp))
-
-                if (description != null) {
-                    Text(
-                        text = description,
-                        style = TextStyle(
-                            fontSize = 12.sp,
-                            color = textColor.copy(0.6f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        )
-                    )
-                }
-            }
-
-            StyledSwitch(
-                checked = checked,
-                enabled = enabled,
-                onCheckedChange = {
-                    if (enabled) {
-                        onCheckedChange(it)
-                    }
-                }
-            )
-        }
-    }
-}
-
-@Preview
-@Composable
-fun StyledTogglePreview() {
-    val checked = remember { mutableStateOf(false) }
-    StyledToggle(
-        label = "Example Toggle",
-        description = "This is an example description for the styled toggle.",
-        checked = checked.value,
-        onCheckedChange = { checked.value = !checked.value }
-    )
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/components/VerticalVolumeSlider.kt

@@ -1,190 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.components
-
-import androidx.compose.animation.core.Spring
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.spring
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.Orientation
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.gestures.draggable
-import androidx.compose.foundation.gestures.rememberDraggableState
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxHeight
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.offset
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.unit.Dp
-import androidx.compose.ui.unit.dp
-import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.roundToInt
-import kotlin.math.sign
-
-@Composable
-fun VerticalVolumeSlider(
-    displayFraction: Float,
-    maxVolume: Int,
-    onVolumeChange: (Int) -> Unit,
-    initialFraction: Float,
-    onDragStateChange: (Boolean) -> Unit,
-    modifier: Modifier = Modifier,
-    baseSliderHeight: Dp = 400.dp,
-    baseSliderWidth: Dp = 145.dp,
-    baseCornerRadius: Dp = 45.dp,
-    maxStretchFactor: Float = 1.15f,
-    minCompressionFactor: Float = 0.875f,
-    stretchSensitivity: Float = 1.0f,
-    compressionSensitivity: Float = 1.0f,
-    cornerRadiusChangeFactor: Float = 0.2f,
-    directionalStretchRatio: Float = 0.75f
-) {
-    val trackColor = Color(0x593C3C3E)
-    val progressColor = Color.White
-
-    var dragFraction by remember { mutableFloatStateOf(initialFraction) }
-    var isDragging by remember { mutableStateOf(false) }
-
-    var rawDragPosition by remember { mutableFloatStateOf(initialFraction) }
-    var overscrollAmount by remember { mutableFloatStateOf(0f) }
-
-    val baseHeightPx = with(LocalDensity.current) { baseSliderHeight.toPx() }
-
-    val animatedProgress by animateFloatAsState(
-        targetValue = dragFraction.coerceIn(0f, 1f),
-        animationSpec = spring(
-            dampingRatio = Spring.DampingRatioLowBouncy,
-            stiffness = Spring.StiffnessMedium
-        ),
-        label = "ProgressAnimation"
-    )
-
-    val animatedOverscroll by animateFloatAsState(
-        targetValue = overscrollAmount,
-        animationSpec = spring(
-            dampingRatio = Spring.DampingRatioMediumBouncy,
-            stiffness = Spring.StiffnessMediumLow
-        ),
-        label = "OverscrollAnimation"
-    )
-
-    val maxOverscrollEffect = (maxStretchFactor - 1f).coerceAtLeast(0f)
-
-    val stretchMultiplier = stretchSensitivity
-    val compressionMultiplier = compressionSensitivity
-
-    val overscrollDirection = sign(animatedOverscroll)
-
-    val totalStretchAmount = (min(maxOverscrollEffect, abs(animatedOverscroll) * stretchMultiplier) * baseSliderHeight.value).dp
-
-    val offsetY = if (abs(animatedOverscroll) > 0.001f) {
-        val asymmetricOffset = totalStretchAmount * (directionalStretchRatio - 0.5f)
-        (-overscrollDirection * asymmetricOffset.value).dp
-    } else {
-        0.dp
-    }
-
-    val heightStretch = baseSliderHeight + totalStretchAmount
-
-    val widthCompression = baseSliderWidth * max(
-        minCompressionFactor,
-        1f - min(1f - minCompressionFactor, abs(animatedOverscroll) * compressionMultiplier)
-    )
-
-    val dynamicCornerRadius = baseCornerRadius * (1f - min(cornerRadiusChangeFactor, abs(animatedOverscroll) * cornerRadiusChangeFactor * 2f))
-
-    Box(
-        modifier = modifier,
-        contentAlignment = Alignment.Center
-    ) {
-        Box(
-            modifier = Modifier
-                .height(heightStretch)
-                .width(widthCompression)
-                .offset(y = offsetY)
-                .clip(RoundedCornerShape(dynamicCornerRadius))
-                .background(trackColor)
-                .pointerInput(Unit) {
-                    detectTapGestures { offset ->
-                        val newFraction = 1f - (offset.y / size.height).coerceIn(0f, 1f)
-                        dragFraction = newFraction
-                        rawDragPosition = newFraction
-                        overscrollAmount = 0f
-
-                        val newVolume = (newFraction * maxVolume).roundToInt()
-                        onVolumeChange(newVolume)
-                    }
-                }
-                .draggable(
-                    orientation = Orientation.Vertical,
-                    state = rememberDraggableState { delta ->
-                        rawDragPosition -= (delta / baseHeightPx)
-
-                        dragFraction = rawDragPosition.coerceIn(0f, 1f)
-
-                        overscrollAmount = when {
-                            rawDragPosition > 1f -> min(1.0f, (rawDragPosition - 1f) * 2.0f)
-                            rawDragPosition < 0f -> max(-1.0f, rawDragPosition * 2.0f)
-                            else -> 0f
-                        }
-
-                        val newVolume = (dragFraction * maxVolume).roundToInt()
-                        onVolumeChange(newVolume)
-                    },
-                    onDragStarted = {
-                        isDragging = true
-                        dragFraction = displayFraction
-                        rawDragPosition = displayFraction
-                        overscrollAmount = 0f
-                        onDragStateChange(true)
-                    },
-                    onDragStopped = {
-                        isDragging = false
-                        overscrollAmount = 0f
-                        rawDragPosition = dragFraction
-                        onDragStateChange(false)
-                    }
-                ),
-            contentAlignment = Alignment.BottomCenter
-        ) {
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .fillMaxHeight(animatedProgress)
-                    .background(progressColor)
-            )
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/AccessibilitySettingsScreen.kt

@@ -1,844 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-// import me.kavishdevar.librepods.utils.RadareOffsetFinder
-import android.annotation.SuppressLint
-import android.util.Log
-import androidx.compose.foundation.background
-import androidx.compose.foundation.gestures.detectDragGesturesAfterLongPress
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.hapticfeedback.HapticFeedbackType
-import androidx.compose.ui.input.pointer.PointerEventPass
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.layout.onGloballyPositioned
-import androidx.compose.ui.layout.positionInParent
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.LocalHapticFeedback
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.hazeSource
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.bluetooth.ATTHandles
-import me.kavishdevar.librepods.data.Capability
-import me.kavishdevar.librepods.presentation.components.NavigationButton
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledDropdown
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledSlider
-import me.kavishdevar.librepods.presentation.components.StyledToggle
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-private var phoneMediaDebounceJob: Job? = null
-private var toneVolumeDebounceJob: Job? = null
-//private const val TAG = "AccessibilitySettings"
-
-@SuppressLint("DefaultLocale")
-@ExperimentalHazeMaterialsApi
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalEncodingApi::class)
-@Composable
-fun AccessibilitySettingsScreen(viewModel: AirPodsViewModel, navController: NavController) {
-    val state by viewModel.uiState.collectAsState()
-
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    val hearingAidEnabled =
-        state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID]?.getOrNull(
-            1
-        )
-            ?.toInt() == 1 && state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID]?.getOrNull(
-            0
-        )?.toInt() == 1
-
-    val backdrop = rememberLayerBackdrop()
-
-    StyledScaffold(
-        title = stringResource(R.string.accessibility)
-    ) { topPadding, hazeState, bottomPadding ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .hazeSource(hazeState)
-                .layerBackdrop(backdrop)
-                .verticalScroll(rememberScrollState())
-                .padding(horizontal = 16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(topPadding))
-
-            if (!state.isPremium) {
-                StyledButton(
-                    onClick = {
-                        navController.navigate("purchase_screen")
-                    },
-                    backdrop = rememberLayerBackdrop(),
-                    modifier = Modifier.fillMaxWidth(),
-                    maxScale = 0.05f,
-                    surfaceColor = if (isSystemInDarkTheme()) Color(0xFF916100) else Color(0xFFE59900)
-                ) {
-                    Text(
-                        stringResource(R.string.unlock_advanced_features),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = Color.White
-                        ),
-                    )
-                }
-            }
-
-//            val phoneMediaEQ = remember { mutableStateOf(FloatArray(8) { 0.5f }) }
-//            val phoneEQEnabled = remember { mutableStateOf(false) }
-//            val mediaEQEnabled = remember { mutableStateOf(false) }
-
-            val pressSpeedOptions = mapOf(
-                0.toByte() to stringResource(R.string.default_option),
-                1.toByte() to stringResource(R.string.slower),
-                2.toByte() to stringResource(R.string.slowest)
-            )
-
-            val selectedPressSpeedValue =
-                state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.DOUBLE_CLICK_INTERVAL]?.getOrNull(
-                    0
-                )
-            var selectedPressSpeed by remember {
-                mutableStateOf(
-                    pressSpeedOptions[selectedPressSpeedValue] ?: pressSpeedOptions[0]
-                )
-            }
-
-            val pressAndHoldDurationOptions = mapOf(
-                0.toByte() to stringResource(R.string.default_option),
-                1.toByte() to stringResource(R.string.slower),
-                2.toByte() to stringResource(R.string.slowest)
-            )
-
-            val selectedPressAndHoldDurationValue =
-                state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.CLICK_HOLD_INTERVAL]?.getOrNull(
-                    0
-                )
-            var selectedPressAndHoldDuration by remember {
-                mutableStateOf(
-                    pressAndHoldDurationOptions[selectedPressAndHoldDurationValue]
-                        ?: pressAndHoldDurationOptions[0]
-                )
-            }
-
-            val volumeSwipeSpeedOptions = mapOf(
-                1.toByte() to stringResource(R.string.default_option),
-                2.toByte() to stringResource(R.string.longer),
-                3.toByte() to stringResource(R.string.longest)
-            )
-            val selectedVolumeSwipeSpeedValue =
-                state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_INTERVAL]?.getOrNull(
-                    0
-                )
-            var selectedVolumeSwipeSpeed by remember {
-                mutableStateOf(
-                    volumeSwipeSpeedOptions[selectedVolumeSwipeSpeedValue]
-                        ?: volumeSwipeSpeedOptions[1]
-                )
-            }
-
-            val phoneMediaEQ = remember { mutableStateOf(FloatArray(8) { 0.5f }) }
-            val phoneEQEnabled = remember { mutableStateOf(false) }
-            val mediaEQEnabled = remember { mutableStateOf(false) }
-
-            LaunchedEffect(phoneMediaEQ.value, phoneEQEnabled.value, mediaEQEnabled.value) {
-                phoneMediaDebounceJob?.cancel()
-                phoneMediaDebounceJob = CoroutineScope(Dispatchers.IO).launch {
-                    delay(150)
-                    try {
-                        val phoneByte = if (phoneEQEnabled.value) 0x01.toByte() else 0x02.toByte()
-                        val mediaByte = if (mediaEQEnabled.value) 0x01.toByte() else 0x02.toByte()
-                        Log.d(
-                            "AccessibilitySettingsScreen",
-                            "Sending phone/media EQ (phoneEnabled=${phoneEQEnabled.value}, mediaEnabled=${mediaEQEnabled.value})"
-                        )
-                        viewModel.sendPhoneMediaEQ(phoneMediaEQ.value, phoneByte, mediaByte)
-                    } catch (e: Exception) {
-                        Log.w(
-                            "AccessibilitySettingsScreen",
-                            "Error sending phone/media EQ: ${e.message}"
-                        )
-                    }
-                }
-            }
-            Box(
-                modifier = Modifier.then(
-                    if (!state.isPremium) {
-                Modifier.pointerInput(Unit) {
-                    awaitPointerEventScope {
-                        while (true) {
-                            val event = awaitPointerEvent(PointerEventPass.Initial)
-                            event.changes.forEach { it.consume() }
-                        }
-                    }
-                }
-            } else Modifier)) {
-                DropdownMenuComponent(
-                    label = stringResource(R.string.press_speed),
-                    description = stringResource(R.string.press_speed_description),
-                    options = pressSpeedOptions.values.toList(),
-                    selectedOption = selectedPressSpeed ?: stringResource(R.string.default_option),
-                    onOptionSelected = { newValue ->
-                        selectedPressSpeed = newValue
-                        viewModel.setControlCommandByte(
-                            identifier = AACPManager.Companion.ControlCommandIdentifiers.DOUBLE_CLICK_INTERVAL,
-                            value = pressSpeedOptions.filterValues { it == newValue }.keys.firstOrNull()
-                                ?: 0.toByte()
-                        )
-                    },
-                    textColor = textColor,
-                    hazeState = hazeState,
-                    independent = true
-                )
-            }
-
-            Box(
-                modifier = Modifier.then(
-                if (!state.isPremium) {
-                Modifier.pointerInput(Unit) {
-                    awaitPointerEventScope {
-                        while (true) {
-                            val event = awaitPointerEvent(PointerEventPass.Initial)
-                            event.changes.forEach { it.consume() }
-                        }
-                    }
-                }
-            } else Modifier)) {
-                DropdownMenuComponent(
-                    label = stringResource(R.string.press_and_hold_duration),
-                    description = stringResource(R.string.press_and_hold_duration_description),
-                    options = pressAndHoldDurationOptions.values.toList(),
-                    selectedOption = selectedPressAndHoldDuration
-                        ?: stringResource(R.string.default_option),
-                    onOptionSelected = { newValue ->
-                        selectedPressAndHoldDuration = newValue
-                        viewModel.setControlCommandByte(
-                            identifier = AACPManager.Companion.ControlCommandIdentifiers.CLICK_HOLD_INTERVAL,
-                            value = pressAndHoldDurationOptions.filterValues { it == newValue }.keys.firstOrNull()
-                                ?: 0.toByte()
-                        )
-                    },
-                    textColor = textColor,
-                    hazeState = hazeState,
-                    independent = true
-                )
-            }
-            StyledToggle(
-                title = stringResource(R.string.noise_control),
-                label = stringResource(R.string.noise_cancellation_single_airpod),
-                description = stringResource(R.string.noise_cancellation_single_airpod_description),
-                independent = true,
-                checked = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.ONE_BUD_ANC_MODE]?.getOrNull(
-                    0
-                ) == 0x01.toByte(),
-                onCheckedChange = {
-                    viewModel.setControlCommandBoolean(
-                        AACPManager.Companion.ControlCommandIdentifiers.ONE_BUD_ANC_MODE, it
-                    )
-                },
-                enabled = state.isPremium
-            )
-
-            if (state.capabilities.contains(Capability.LOUD_SOUND_REDUCTION) && state.vendorIdHook) {
-                StyledToggle(
-                    label = stringResource(R.string.loud_sound_reduction),
-                    description = stringResource(R.string.loud_sound_reduction_description),
-                    checked = state.loudSoundReductionEnabled,
-                    onCheckedChange = {
-                        viewModel.setATTCharacteristicValue(
-                            ATTHandles.LOUD_SOUND_REDUCTION,
-                            if (it) byteArrayOf(0x01) else byteArrayOf(0x00)
-                        )
-                    },
-                    enabled = state.isPremium
-                )
-            }
-
-            if (!hearingAidEnabled && state.vendorIdHook) {
-                NavigationButton(
-                    to = "transparency_customization",
-                    name = stringResource(R.string.customize_transparency_mode),
-                    navController = navController,
-                    enabled = state.isPremium
-                )
-            }
-
-            val toneVolumeValue =
-                state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.CHIME_VOLUME]?.getOrNull(
-                    0
-                )?.toFloat() ?: 75f
-            StyledSlider(
-                label = stringResource(R.string.tone_volume),
-                description = stringResource(R.string.tone_volume_description),
-                value = toneVolumeValue,
-                onValueChange = {
-                    viewModel.setControlCommandValue(
-                        AACPManager.Companion.ControlCommandIdentifiers.CHIME_VOLUME,
-                        byteArrayOf(it.toInt().toByte(), 0x50)
-                    )
-                },
-                valueRange = 0f..100f,
-                snapPoints = listOf(75f),
-                startIcon = "\uDBC0\uDEA1",
-                endIcon = "\uDBC0\uDEA9",
-                independent = true,
-                enabled = state.isPremium
-            )
-
-            if (state.capabilities.contains(Capability.SWIPE_FOR_VOLUME)) {
-                val volumeSwipeEnabled =
-                    state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_MODE]?.getOrNull(
-                        0
-                    )?.toInt() == 0x01
-                StyledToggle(
-                    label = stringResource(R.string.volume_control),
-                    description = stringResource(R.string.volume_control_description),
-                    checked = volumeSwipeEnabled,
-                    onCheckedChange = {
-                        viewModel.setControlCommandBoolean(
-                            AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_MODE, it
-                        )
-                    },
-                    enabled = state.isPremium
-                )
-
-                Box(
-                    modifier = Modifier.then(
-                        if (!state.isPremium) {
-                    Modifier.pointerInput(Unit) {
-                        awaitPointerEventScope {
-                            while (true) {
-                                val event = awaitPointerEvent(PointerEventPass.Initial)
-                                event.changes.forEach { it.consume() }
-                            }
-                        }
-                    }
-                } else Modifier)) {
-                    DropdownMenuComponent(
-                        label = stringResource(R.string.volume_swipe_speed),
-                        description = stringResource(R.string.volume_swipe_speed_description),
-                        options = volumeSwipeSpeedOptions.values.toList(),
-                        selectedOption = selectedVolumeSwipeSpeed
-                            ?: stringResource(R.string.default_option),
-                        onOptionSelected = { newValue ->
-                            selectedVolumeSwipeSpeed = newValue
-                            viewModel.setControlCommandByte(
-                                identifier = AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_INTERVAL,
-                                value = volumeSwipeSpeedOptions.filterValues { it == newValue }.keys.firstOrNull()
-                                    ?: 1.toByte()
-                            )
-                        },
-                        textColor = textColor,
-                        hazeState = hazeState,
-                        independent = true
-                    )
-                }
-            }
-
-//            if (!hearingAidEnabled && XposedState.isAvailable) {
-//                Text(
-//                    text = stringResource(R.string.apply_eq_to), style = TextStyle(
-//                        fontSize = 14.sp,
-//                        fontWeight = FontWeight.Bold,
-//                        color = textColor.copy(alpha = 0.6f),
-//                        fontFamily = FontFamily(Font(R.font.sf_pro))
-//                    ), modifier = Modifier.padding(8.dp, bottom = 0.dp)
-//                )
-//                Column(
-//                    modifier = Modifier
-//                        .fillMaxWidth()
-//                        .background(
-//                            if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF),
-//                            RoundedCornerShape(28.dp)
-//                        )
-//                        .padding(vertical = 0.dp)
-//                ) {
-//                    val darkModeLocal = isSystemInDarkTheme()
-//
-//                    val phoneShape = RoundedCornerShape(topStart = 28.dp, topEnd = 28.dp)
-//                    var phoneBackgroundColor by remember {
-//                        mutableStateOf(
-//                            if (darkModeLocal) Color(
-//                                0xFF1C1C1E
-//                            ) else Color(0xFFFFFFFF)
-//                        )
-//                    }
-//                    val phoneAnimatedBackgroundColor by animateColorAsState(
-//                        targetValue = phoneBackgroundColor,
-//                        animationSpec = tween(durationMillis = 500)
-//                    )
-//
-//                    Row(
-//                        modifier = Modifier
-//                            .height(48.dp)
-//                            .fillMaxWidth()
-//                            .background(phoneAnimatedBackgroundColor, phoneShape)
-//                            .pointerInput(Unit) {
-//                                detectTapGestures(
-//                                    onPress = {
-//                                        phoneBackgroundColor =
-//                                            if (darkModeLocal) Color(0x40888888) else Color(
-//                                                0x40D9D9D9
-//                                            )
-//                                        tryAwaitRelease()
-//                                        phoneBackgroundColor =
-//                                            if (darkModeLocal) Color(0xFF1C1C1E) else Color(
-//                                                0xFFFFFFFF
-//                                            )
-//                                        phoneEQEnabled.value = !phoneEQEnabled.value
-//                                    })
-//                            }
-//                            .padding(horizontal = 16.dp),
-//                        verticalAlignment = Alignment.CenterVertically) {
-//                        Text(
-//                            stringResource(R.string.phone),
-//                            fontSize = 16.sp,
-//                            color = textColor,
-//                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-//                            modifier = Modifier.weight(1f)
-//                        )
-//                        Checkbox(
-//                            checked = phoneEQEnabled.value,
-//                            onCheckedChange = { phoneEQEnabled.value = it },
-//                            colors = CheckboxDefaults.colors().copy(
-//                                checkedCheckmarkColor = Color(0xFF007AFF),
-//                                uncheckedCheckmarkColor = Color.Transparent,
-//                                checkedBoxColor = Color.Transparent,
-//                                uncheckedBoxColor = Color.Transparent,
-//                                checkedBorderColor = Color.Transparent,
-//                                uncheckedBorderColor = Color.Transparent
-//                            ),
-//                            modifier = Modifier
-//                                .height(24.dp)
-//                                .scale(1.5f)
-//                        )
-//                    }
-//
-//                    HorizontalDivider(
-//                        thickness = 1.dp, color = Color(0x40888888)
-//                    )
-//
-//                    val mediaShape = RoundedCornerShape(bottomStart = 28.dp, bottomEnd = 28.dp)
-//                    var mediaBackgroundColor by remember {
-//                        mutableStateOf(
-//                            if (darkModeLocal) Color(
-//                                0xFF1C1C1E
-//                            ) else Color(0xFFFFFFFF)
-//                        )
-//                    }
-//                    val mediaAnimatedBackgroundColor by animateColorAsState(
-//                        targetValue = mediaBackgroundColor,
-//                        animationSpec = tween(durationMillis = 500)
-//                    )
-//
-//                    Row(
-//                        modifier = Modifier
-//                            .height(48.dp)
-//                            .fillMaxWidth()
-//                            .background(mediaAnimatedBackgroundColor, mediaShape)
-//                            .pointerInput(Unit) {
-//                                detectTapGestures(
-//                                    onPress = {
-//                                        mediaBackgroundColor =
-//                                            if (darkModeLocal) Color(0x40888888) else Color(
-//                                                0x40D9D9D9
-//                                            )
-//                                        tryAwaitRelease()
-//                                        mediaBackgroundColor =
-//                                            if (darkModeLocal) Color(0xFF1C1C1E) else Color(
-//                                                0xFFFFFFFF
-//                                            )
-//                                        mediaEQEnabled.value = !mediaEQEnabled.value
-//                                    })
-//                            }
-//                            .padding(horizontal = 16.dp),
-//                        verticalAlignment = Alignment.CenterVertically) {
-//                        Text(
-//                            stringResource(R.string.media),
-//                            fontSize = 16.sp,
-//                            color = textColor,
-//                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-//                            modifier = Modifier.weight(1f)
-//                        )
-//                        Checkbox(
-//                            checked = mediaEQEnabled.value,
-//                            onCheckedChange = { mediaEQEnabled.value = it },
-//                            colors = CheckboxDefaults.colors().copy(
-//                                checkedCheckmarkColor = Color(0xFF007AFF),
-//                                uncheckedCheckmarkColor = Color.Transparent,
-//                                checkedBoxColor = Color.Transparent,
-//                                uncheckedBoxColor = Color.Transparent,
-//                                checkedBorderColor = Color.Transparent,
-//                                uncheckedBorderColor = Color.Transparent
-//                            ),
-//                            modifier = Modifier
-//                                .height(24.dp)
-//                                .scale(1.5f)
-//                        )
-//                    }
-//                }
-//
-////                 EQ Settings. Don't seem to have an effect?
-//                Column(
-//                    modifier = Modifier
-//                        .fillMaxWidth()
-//                        .background(
-//                            if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF),
-//                            RoundedCornerShape(28.dp)
-//                        )
-//                        .padding(12.dp), horizontalAlignment = Alignment.CenterHorizontally
-//                ) {
-//                    val trackColor = if (isDarkTheme) Color(0xFFB3B3B3) else Color(0xFF929491)
-//                    val activeTrackColor = if (isDarkTheme) Color(0xFF007AFF) else Color(0xFF3C6DF5)
-//                    val thumbColor = if (isDarkTheme) Color(0xFFFFFFFF) else Color(0xFFFFFFFF)
-//
-//                    for (i in 0 until 8) {
-//                        val eqPhoneValue =
-//                            remember(phoneMediaEQ.value[i]) { mutableFloatStateOf(phoneMediaEQ.value[i]) }
-//                        Row(
-//                            horizontalArrangement = Arrangement.SpaceBetween,
-//                            verticalAlignment = Alignment.CenterVertically,
-//                            modifier = Modifier
-//                                .fillMaxWidth()
-//                                .height(38.dp)
-//                        ) {
-//                            Text(
-//                                text = String.format("%.2f", eqPhoneValue.floatValue),
-//                                fontSize = 12.sp,
-//                                color = textColor,
-//                                modifier = Modifier.padding(bottom = 4.dp)
-//                            )
-//
-//                            Slider(
-//                                value = eqPhoneValue.floatValue,
-//                                onValueChange = { newVal ->
-//                                    eqPhoneValue.floatValue = newVal
-//                                    val newEQ = phoneMediaEQ.value.copyOf()
-//                                    newEQ[i] = eqPhoneValue.floatValue
-//                                    phoneMediaEQ.value = newEQ
-//                                },
-//                                valueRange = 0f..100f,
-//                                modifier = Modifier
-//                                    .fillMaxWidth(0.9f)
-//                                    .height(36.dp),
-//                                colors = SliderDefaults.colors(
-//                                    thumbColor = thumbColor,
-//                                    activeTrackColor = activeTrackColor,
-//                                    inactiveTrackColor = trackColor
-//                                ),
-//                                thumb = {
-//                                    Box(
-//                                        modifier = Modifier
-//                                            .size(24.dp)
-//                                            .shadow(4.dp, CircleShape)
-//                                            .background(thumbColor, CircleShape)
-//                                    )
-//                                },
-//                                track = {
-//                                    Box(
-//                                        modifier = Modifier
-//                                            .fillMaxWidth()
-//                                            .height(12.dp),
-//                                        contentAlignment = Alignment.CenterStart
-//                                    ) {
-//                                        Box(
-//                                            modifier = Modifier
-//                                                .fillMaxWidth()
-//                                                .height(4.dp)
-//                                                .background(trackColor, RoundedCornerShape(4.dp))
-//                                        )
-//                                        Box(
-//                                            modifier = Modifier
-//                                                .fillMaxWidth(eqPhoneValue.floatValue / 100f)
-//                                                .height(4.dp)
-//                                                .background(
-//                                                    activeTrackColor, RoundedCornerShape(4.dp)
-//                                                )
-//                                        )
-//                                    }
-//                                })
-//
-//                            Text(
-//                                text = stringResource(R.string.band_label, i + 1),
-//                                fontSize = 12.sp,
-//                                color = textColor,
-//                                modifier = Modifier.padding(top = 4.dp)
-//                            )
-//                        }
-//                    }
-//                }
-//            }
-            Spacer(modifier = Modifier.height(bottomPadding))
-        }
-    }
-}
-
-@ExperimentalHazeMaterialsApi
-@Composable
-private fun DropdownMenuComponent(
-    label: String,
-    options: List<String>,
-    selectedOption: String,
-    onOptionSelected: (String) -> Unit,
-    textColor: Color,
-    hazeState: HazeState,
-    description: String? = null,
-    independent: Boolean = true
-) {
-    val density = LocalDensity.current
-    val itemHeightPx = with(density) { 48.dp.toPx() }
-
-    var expanded by remember { mutableStateOf(false) }
-    var touchOffset by remember { mutableStateOf<Offset?>(null) }
-    var boxPosition by remember { mutableStateOf(Offset.Zero) }
-    var lastDismissTime by remember { mutableLongStateOf(0L) }
-    var parentHoveredIndex by remember { mutableStateOf<Int?>(null) }
-    var parentDragActive by remember { mutableStateOf(false) }
-    var previousIdx by remember { mutableStateOf<Int?>(null) }
-    val haptics = LocalHapticFeedback.current
-    val scope = rememberCoroutineScope()
-
-    Column(modifier = Modifier.fillMaxWidth()) {
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .then(
-                    if (independent) {
-                        if (description != null) {
-                            Modifier.padding(top = 8.dp, bottom = 4.dp)
-                        } else {
-                            Modifier.padding(vertical = 8.dp)
-                        }
-                    } else Modifier
-                )
-                .background(
-                    if (independent) (if (isSystemInDarkTheme()) Color(0xFF1C1C1E) else Color(
-                        0xFFFFFFFF
-                    )) else Color.Transparent,
-                    if (independent) RoundedCornerShape(28.dp) else RoundedCornerShape(0.dp)
-                ) then (if (independent) Modifier.padding(horizontal = 4.dp) else Modifier).clip(
-                if (independent) RoundedCornerShape(28.dp) else RoundedCornerShape(0.dp)
-            )
-        ) {
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(start = 12.dp, end = 12.dp)
-                    .height(58.dp)
-                    .pointerInput(Unit) {
-                        detectTapGestures { offset ->
-                            val now = System.currentTimeMillis()
-                            if (expanded) {
-                                expanded = false
-                                lastDismissTime = now
-                            } else {
-                                if (now - lastDismissTime > 250L) {
-                                    touchOffset = offset
-                                    expanded = true
-                                }
-                            }
-                        }
-                    }
-                    .pointerInput(Unit) {
-                        detectDragGesturesAfterLongPress(onDragStart = { offset ->
-                            val now = System.currentTimeMillis()
-                            touchOffset = offset
-                            if (!expanded && now - lastDismissTime > 250L) {
-                                expanded = true
-                            }
-                            lastDismissTime = now
-                            parentDragActive = true
-                            parentHoveredIndex = 0
-                        }, onDrag = { change, _ ->
-                            val current = change.position
-                            val touch = touchOffset ?: current
-                            val posInPopupY = current.y - touch.y
-                            val idx = (posInPopupY / itemHeightPx).toInt()
-                            if (idx != previousIdx) {
-                                scope.launch {
-                                    haptics.performHapticFeedback(
-                                        HapticFeedbackType.SegmentTick
-                                    )
-                                }
-                            }
-                            parentHoveredIndex = idx
-                            previousIdx = idx
-                        }, onDragEnd = {
-                            parentDragActive = false
-                            parentHoveredIndex?.let { idx ->
-                                if (idx in options.indices) {
-                                    onOptionSelected(options[idx])
-                                    expanded = false
-                                    lastDismissTime = System.currentTimeMillis()
-                                }
-                            }
-                            if (parentHoveredIndex != null && parentHoveredIndex in options.indices) {
-                                scope.launch {
-                                    haptics.performHapticFeedback(
-                                        HapticFeedbackType.GestureEnd
-                                    )
-                                }
-                            }
-                            parentHoveredIndex = null
-                        }, onDragCancel = {
-                            parentDragActive = false
-                            parentHoveredIndex = null
-                        })
-                    },
-                horizontalArrangement = Arrangement.SpaceBetween,
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                Column(
-                    modifier = Modifier.weight(1f)
-                ) {
-                    Text(
-                        text = label,
-                        fontSize = 16.sp,
-                        color = textColor,
-                        modifier = Modifier.padding(bottom = 4.dp)
-                    )
-                    if (!independent && description != null) {
-                        Text(
-                            text = description, style = TextStyle(
-                                fontSize = 12.sp,
-                                fontWeight = FontWeight.Light,
-                                color = textColor.copy(alpha = 0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ), modifier = Modifier.padding(16.dp, top = 0.dp, bottom = 2.dp)
-                        )
-                    }
-                }
-                Box(
-                    modifier = Modifier.onGloballyPositioned { coordinates ->
-                        boxPosition = coordinates.positionInParent()
-                    }) {
-                    Row(
-                        verticalAlignment = Alignment.CenterVertically
-                    ) {
-                        Text(
-                            text = selectedOption, style = TextStyle(
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = 0.8f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            )
-                        )
-                        Text(
-                            text = "􀆏", style = TextStyle(
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = 0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ), modifier = Modifier.padding(start = 6.dp)
-                        )
-                    }
-
-                    StyledDropdown(
-                        expanded = expanded,
-                        onDismissRequest = {
-                            expanded = false
-                            lastDismissTime = System.currentTimeMillis()
-                        },
-                        options = options,
-                        selectedOption = selectedOption,
-                        touchOffset = touchOffset,
-                        boxPosition = boxPosition,
-                        externalHoveredIndex = parentHoveredIndex,
-                        externalDragActive = parentDragActive,
-                        onOptionSelected = { option ->
-                            onOptionSelected(option)
-                            expanded = false
-                        },
-                        hazeState = hazeState
-                    )
-                }
-            }
-        }
-        if (independent && description != null) {
-            Box(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = 16.dp)
-                    .background(
-                        if (isSystemInDarkTheme()) Color(0xFF000000) else Color(0xFFF2F2F7)
-                    )
-            ) {
-                Text(
-                    text = description, style = TextStyle(
-                        fontSize = 12.sp,
-                        fontWeight = FontWeight.Light,
-                        color = (if (isSystemInDarkTheme()) Color.White else Color.Black).copy(
-                            alpha = 0.6f
-                        ),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/AdaptiveStrengthScreen.kt

@@ -1,126 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledSlider
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-
-@Composable
-fun AdaptiveStrengthScreen(viewModel: AirPodsViewModel, navController: NavController) {
-    val state by viewModel.uiState.collectAsState()
-    val backdrop = rememberLayerBackdrop()
-
-    StyledScaffold(
-        title = stringResource(R.string.customize_adaptive_audio)
-    ) { spacerHeight ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .layerBackdrop(backdrop)
-                .padding(horizontal = 16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(spacerHeight))
-            if (!state.isPremium) {
-                StyledButton(
-                    onClick = {
-                        navController.navigate("purchase_screen")
-                    },
-                    backdrop = rememberLayerBackdrop(),
-                    modifier = Modifier.fillMaxWidth(),
-                    maxScale = 0.05f,
-                    surfaceColor = if (isSystemInDarkTheme()) Color(0xFF916100) else Color(0xFFE59900)
-                ) {
-                    Text(
-                        stringResource(R.string.unlock_advanced_features),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = Color.White
-                        ),
-                    )
-                }
-            }
-            val sliderValue = remember {
-                mutableFloatStateOf(100f - (state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.AUTO_ANC_STRENGTH]?.getOrNull(0)?.toFloat() ?: 50f))
-            }
-            var job by remember { mutableStateOf<Job?>(null) }
-            val scope = rememberCoroutineScope()
-            StyledSlider(
-                label = stringResource(R.string.customize_adaptive_audio),
-                value = sliderValue.floatValue,
-                onValueChange = {
-                    sliderValue.floatValue = it
-                    job?.cancel()
-                    job = scope.launch {
-                        delay(150)
-                        viewModel.setControlCommandValue(
-                            AACPManager.Companion.ControlCommandIdentifiers.AUTO_ANC_STRENGTH,
-                            byteArrayOf((100 - it).toInt().toByte())
-                        )
-                    }
-                },
-                valueRange = 0f..100f,
-                snapPoints = listOf(0f, 50f, 100f),
-                startIcon = "􀊥",
-                endIcon = "􀊩",
-                independent = true,
-                description = stringResource(R.string.adaptive_audio_description),
-                enabled = state.isPremium
-            )
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/AirPodsSettingsScreen.kt

@@ -1,619 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.screens
-
-// import me.kavishdevar.librepods.utils.RadareOffsetFinder
-import android.annotation.SuppressLint
-import android.content.Context.MODE_PRIVATE
-import android.content.Intent
-import android.content.SharedPreferences
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.detectTapGestures
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.heightIn
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.SnackbarHostState
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.input.pointer.PointerEventPass
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.core.net.toUri
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import com.kyant.backdrop.drawBackdrop
-import com.kyant.backdrop.highlight.Highlight
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.hazeSource
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.delay
-import me.kavishdevar.librepods.BuildConfig
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.bluetooth.ATTHandles
-import me.kavishdevar.librepods.data.AirPodsPro3
-import me.kavishdevar.librepods.data.Capability
-import me.kavishdevar.librepods.presentation.components.AboutCard
-import me.kavishdevar.librepods.presentation.components.AudioSettings
-import me.kavishdevar.librepods.presentation.components.BatteryView
-import me.kavishdevar.librepods.presentation.components.CallControlSettings
-import me.kavishdevar.librepods.presentation.components.ConnectionSettings
-import me.kavishdevar.librepods.presentation.components.HearingHealthSettings
-import me.kavishdevar.librepods.presentation.components.MicrophoneSettings
-import me.kavishdevar.librepods.presentation.components.NavigationButton
-import me.kavishdevar.librepods.presentation.components.NoiseControlSettings
-import me.kavishdevar.librepods.presentation.components.PressAndHoldSettings
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledIconButton
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledToggle
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-import java.util.concurrent.TimeUnit
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalHazeMaterialsApi::class)
-@SuppressLint("MissingPermission", "UnspecifiedRegisterReceiverFlag")
-@Composable
-fun AirPodsSettingsScreen(viewModel: AirPodsViewModel, navController: NavController) {
-    val state by viewModel.uiState.collectAsState()
-    val sharedPreferences = LocalContext.current.getSharedPreferences("settings", MODE_PRIVATE)
-    var deviceName by remember {
-        mutableStateOf(
-            TextFieldValue(
-                sharedPreferences.getString("name", state.deviceName).toString()
-            )
-        )
-    }
-
-    val nameChangeListener = remember {
-        SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
-            if (key == "name") {
-                deviceName =
-                    TextFieldValue(sharedPreferences.getString("name", "AirPods Pro").toString())
-            }
-        }
-    }
-
-    DisposableEffect(Unit) {
-        sharedPreferences.registerOnSharedPreferenceChangeListener(nameChangeListener)
-        onDispose {
-            sharedPreferences.unregisterOnSharedPreferenceChangeListener(nameChangeListener)
-        }
-    }
-
-    val snackbarHostState = remember { SnackbarHostState() }
-
-    LaunchedEffect(Unit) {
-        viewModel.refreshInitialData()
-    }
-
-    val hazeStateS = remember { mutableStateOf(HazeState()) }
-
-    StyledScaffold(
-        title = deviceName.text, actionButtons = listOf(
-            { scaffoldBackdrop ->
-                StyledIconButton(
-                    onClick = { navController.navigate("app_settings") },
-                    icon = "􀍟",
-                    backdrop = scaffoldBackdrop
-                )
-            }), snackbarHostState = snackbarHostState
-    ) { topPadding, hazeState, bottomPadding ->
-        hazeStateS.value = hazeState
-        var blockTouches by remember { mutableStateOf(false) }
-
-        LaunchedEffect(Unit) {
-            viewModel.demoActivated.collect {
-                blockTouches = true
-                delay(1000)
-                blockTouches = false
-            }
-        }
-
-        if (state.isLocallyConnected) {
-            val capabilities = state.capabilities
-            LazyColumn(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .hazeSource(hazeState)
-                    .padding(horizontal = 16.dp)
-                    .then(if (blockTouches) Modifier.pointerInput(Unit) {
-                        awaitPointerEventScope {
-                            while (true) {
-                                val event = awaitPointerEvent(PointerEventPass.Initial)
-                                event.changes.forEach { it.consume() }
-                            }
-                        }
-                    } else Modifier)) {
-                item(key = "spacer_top") { Spacer(modifier = Modifier.height(topPadding)) }
-
-                item(key = "play_update_banner") {
-                    if (state.timeUntilFOSSPremiumExpiry > 0L) {
-                        val context = LocalContext.current
-                        Box(
-                            modifier = Modifier
-                                .background(Color(0xFF32829B), RoundedCornerShape(28.dp))
-                                .clip(RoundedCornerShape(28.dp))
-                                .clickable {
-                                    val emailIntent = Intent(Intent.ACTION_SENDTO).apply {
-                                        data = "mailto:".toUri()
-                                        putExtra(Intent.EXTRA_EMAIL, arrayOf("billing@kavish.xyz"))
-                                        putExtra(Intent.EXTRA_SUBJECT, "LibrePods Play billing error")
-                                        putExtra(
-                                            Intent.EXTRA_TEXT,
-                                            "Please enter your GitHub username to restore your premium access:\n\nGitHub username: "
-                                        )
-                                    }
-                                    context.startActivity(emailIntent)
-                                }
-                        ) {
-                            Text(
-                                text = stringResource(
-                                    R.string.play_foss_premium_banner, maxOf(1, TimeUnit.MILLISECONDS.toDays(state.timeUntilFOSSPremiumExpiry).toInt())
-                                ),
-                                modifier = Modifier
-                                    .padding(16.dp),
-                                style = TextStyle(
-                                    fontSize = 16.sp,
-                                    fontWeight = FontWeight.Bold,
-                                    color = Color.White,
-                                    fontFamily = FontFamily(Font(R.font.sf_pro))
-                                )
-                            )
-                        }
-                    }
-                }
-
-                item(key = "battery") {
-                    BatteryView(
-                        batteryList = state.battery,
-                        budsRes = state.instance?.model?.budsRes ?: R.drawable.airpods_pro_2_case,
-                        caseRes = state.instance?.model?.caseRes ?: R.drawable.airpods_pro_2_case
-                    )
-                }
-                item(key = "spacer_battery") { Spacer(modifier = Modifier.height(32.dp)) }
-
-                item(key = "name") {
-                    NavigationButton(
-                        to = "rename",
-                        name = stringResource(R.string.name),
-                        currentState = deviceName.text,
-                        navController = navController,
-                        independent = true
-                    )
-                }
-
-                val hasHearingAidCapability =
-                    state.instance?.model?.capabilities?.contains(Capability.HEARING_AID) == true
-                val hasPPECapability =
-                    state.instance?.model?.capabilities?.contains(Capability.PPE) == true
-
-                if (hasHearingAidCapability || hasPPECapability) {
-                    if (hasPPECapability || (state.vendorIdHook && hasHearingAidCapability)) item(
-                        key = "spacer_hearing_health"
-                    ) { Spacer(modifier = Modifier.height(24.dp)) }
-                    item(key = "hearing_health") {
-                        HearingHealthSettings(
-                            navController = navController,
-                            hasPPECapability = hasPPECapability,
-                            hasHearingAidCapability = hasHearingAidCapability,
-                            vendorIdHook = state.vendorIdHook
-                        )
-                    }
-                }
-
-                if (capabilities.contains(Capability.LISTENING_MODE)) {
-                    item(key = "spacer_noise") { Spacer(modifier = Modifier.height(16.dp)) }
-                    item(key = "noise_control") {
-                        NoiseControlSettings(
-                            showOffListeningMode = state.offListeningMode,
-                            noiseControlModeValue = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE]?.getOrNull(
-                                0
-                            )?.toInt() ?: 3,
-                            onNoiseControlModeChanged = {
-                                viewModel.setControlCommandInt(
-                                    AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE,
-                                    it
-                                )
-                            },
-                        )
-                    }
-                }
-
-                if (capabilities.contains(Capability.STEM_CONFIG)) {
-                    item(key = "spacer_press_hold") { Spacer(modifier = Modifier.height(16.dp)) }
-                    item(key = "press_hold") {
-                        PressAndHoldSettings(
-                            navController = navController,
-                            leftAction = state.leftAction,
-                            rightAction = state.rightAction
-                        )
-                    }
-                }
-
-                item(key = "spacer_call") { Spacer(modifier = Modifier.height(16.dp)) }
-                item(key = "call_control") {
-                    val bytes = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.CALL_MANAGEMENT_CONFIG]?.take(2)?.toByteArray() ?: byteArrayOf(0x00, 0x00)
-                    val flipped = try { bytes[1] == 0x02.toByte() } catch (e: Exception) { false }
-                    CallControlSettings(
-                        hazeState = hazeState,
-                        flipped = flipped,
-                        onCallControlValueChanged = {
-                            viewModel.setControlCommandValue(
-                                AACPManager.Companion.ControlCommandIdentifiers.CALL_MANAGEMENT_CONFIG,
-                                if (it) byteArrayOf(0x00, 0x02) else byteArrayOf(0x00, 0x03)
-                            )
-                        })
-                }
-
-//                if (capabilities.contains(Capability.STEM_CONFIG) && !BuildConfig.PLAY_BUILD) {
-//                    item(key = "spacer_camera") { Spacer(modifier = Modifier.height(16.dp)) }
-//                    item(key = "camera_control") {
-//                        NavigationButton(
-//                            to = "camera_control",
-//                            name = stringResource(R.string.camera_remote),
-//                            description = stringResource(R.string.camera_control_description),
-//                            title = stringResource(R.string.camera_control),
-//                            navController = navController
-//                        )
-//                    }
-//                }
-
-                item(key = "upgrade_button") {
-                    if (!state.isPremium) {
-                        Spacer(modifier = Modifier.height(28.dp))
-                        StyledButton(
-                            onClick = {
-                                navController.navigate("purchase_screen")
-                            },
-                            backdrop = rememberLayerBackdrop(),
-                            modifier = Modifier.fillMaxWidth(),
-                            maxScale = 0.05f,
-                            surfaceColor = if (isSystemInDarkTheme()) Color(0xFF916100) else Color(
-                                0xFFE59900
-                            )
-                        ) {
-                            Text(
-                                stringResource(R.string.unlock_advanced_features),
-                                style = TextStyle(
-                                    fontSize = 16.sp,
-                                    fontWeight = FontWeight.Medium,
-                                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                    color = Color.White
-                                ),
-                            )
-                        }
-                        Spacer(modifier = Modifier.height(16.dp))
-                    }
-                }
-
-                item(key = "spacer_audio") { Spacer(modifier = Modifier.height(16.dp)) }
-                item(key = "audio") {
-                    val model = state.instance?.model ?: AirPodsPro3()
-                    val adaptiveVolumeCapability =
-                        model.capabilities.contains(Capability.ADAPTIVE_VOLUME)
-                    val conversationalAwarenessCapability =
-                        model.capabilities.contains(Capability.CONVERSATION_AWARENESS)
-                    val loudSoundReductionCapability =
-                        model.capabilities.contains(Capability.LOUD_SOUND_REDUCTION)
-                    val adaptiveAudioCapability =
-                        model.capabilities.contains(Capability.ADAPTIVE_VOLUME)
-
-                    val adaptiveVolumeChecked =
-                        state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.ADAPTIVE_VOLUME_CONFIG]?.getOrNull(
-                            0
-                        ) == 0x01.toByte()
-                    val conversationalAwarenessChecked =
-                        state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG]?.getOrNull(
-                            0
-                        ) == 0x01.toByte()
-
-                    AudioSettings(
-                        navController = navController,
-                        adaptiveVolumeCapability = adaptiveVolumeCapability,
-                        conversationalAwarenessCapability = conversationalAwarenessCapability,
-                        loudSoundReductionCapability = loudSoundReductionCapability,
-                        adaptiveAudioCapability = adaptiveAudioCapability,
-                        adaptiveVolumeChecked = adaptiveVolumeChecked,
-                        onAdaptiveVolumeCheckedChange = { checked ->
-                            viewModel.setControlCommandBoolean(
-                                AACPManager.Companion.ControlCommandIdentifiers.ADAPTIVE_VOLUME_CONFIG,
-                                checked
-                            )
-                        },
-                        conversationalAwarenessChecked = conversationalAwarenessChecked && state.isPremium,
-                        onConversationalAwarenessCheckedChange = { checked ->
-                            viewModel.setControlCommandBoolean(
-                                AACPManager.Companion.ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG,
-                                checked
-                            )
-                        },
-                        loudSoundReductionChecked = state.loudSoundReductionEnabled,
-                        onLoudSoundReductionCheckedChange = {
-                            viewModel.setATTCharacteristicValue(
-                                ATTHandles.LOUD_SOUND_REDUCTION,
-                                byteArrayOf(if (it) 0x01.toByte() else 0x00.toByte())
-                            )
-                        },
-                        vendorIdHook = state.vendorIdHook,
-                        isPremium = state.isPremium
-                    )
-                }
-
-                item(key = "spacer_connection") { Spacer(modifier = Modifier.height(16.dp)) }
-                item(key = "connection") {
-                    ConnectionSettings(
-                        automaticEarDetectionEnabled = state.automaticEarDetectionEnabled,
-                        onAutomaticEarDetectionChanged = {
-                            viewModel.setAutomaticEarDetectionEnabled(it)
-                        },
-                        automaticConnectionEnabled = state.automaticConnectionEnabled,
-                        onAutomaticConnectionChanged = { viewModel.setAutomaticConnectionEnabled(it) })
-                }
-
-                item(key = "spacer_microphone") { Spacer(modifier = Modifier.height(16.dp)) }
-                item(key = "microphone") {
-                    val id = AACPManager.Companion.ControlCommandIdentifiers.MIC_MODE
-                    MicrophoneSettings(
-                        hazeState = hazeState,
-                        micModeValue = state.controlStates[id]?.getOrNull(0) ?: 0x00.toByte(),
-                        onMicModeValueChanged = { viewModel.setControlCommandByte(id, it) })
-                }
-
-                if (capabilities.contains(Capability.SLEEP_DETECTION)) {
-                    item(key = "spacer_sleep") { Spacer(modifier = Modifier.height(16.dp)) }
-                    item(key = "sleep_detection") {
-                        val id =
-                            AACPManager.Companion.ControlCommandIdentifiers.SLEEP_DETECTION_CONFIG
-                        StyledToggle(
-                            label = stringResource(R.string.sleep_detection),
-                            checked = state.controlStates[id]?.getOrNull(0) == 0x01.toByte(),
-                            onCheckedChange = {
-                                viewModel.setControlCommandBoolean(id, it)
-                            },
-                            enabled = state.isPremium
-                        )
-                    }
-                }
-
-                if (capabilities.contains(Capability.HEAD_GESTURES)) {
-                    item(key = "spacer_head_tracking") { Spacer(modifier = Modifier.height(16.dp)) }
-                    item(key = "head_tracking") {
-                        NavigationButton(
-                            to = "head_tracking",
-                            name = stringResource(R.string.head_gestures),
-                            navController = navController,
-                            currentState = if (sharedPreferences.getBoolean(
-                                    "head_gestures", false
-                                )
-                            ) stringResource(R.string.on) else stringResource(R.string.off)
-                        )
-                    }
-                }
-
-                item(key = "spacer_dynamic_end_of_charge") { Spacer(modifier = Modifier.height(16.dp)) }
-                item(key = "dynamic_end_of_charge") {
-                    StyledToggle(
-                        label = stringResource(R.string.optimized_charging),
-                        description = stringResource(R.string.optimized_charging_description),
-                        checked = state.dynamicEndOfCharge,
-                        onCheckedChange = viewModel::setDynamicEndOfCharge
-                    )
-                }
-
-                item(key = "spacer_accessibility") { Spacer(modifier = Modifier.height(16.dp)) }
-                item(key = "accessibility") {
-                    NavigationButton(
-                        to = "accessibility",
-                        name = stringResource(R.string.accessibility),
-                        navController = navController
-                    )
-                }
-
-                if (capabilities.contains(Capability.LOUD_SOUND_REDUCTION)) {
-                    item(key = "spacer_off_listening") { Spacer(modifier = Modifier.height(16.dp)) }
-                    item(key = "off_listening") {
-                        val id = AACPManager.Companion.ControlCommandIdentifiers.ALLOW_OFF_OPTION
-                        StyledToggle(
-                            label = stringResource(R.string.off_listening_mode),
-                            description = stringResource(R.string.off_listening_mode_description),
-                            checked = state.controlStates[id]?.getOrNull(0) == 0x01.toByte(),
-                            onCheckedChange = viewModel::setOffListeningMode
-                        )
-                    }
-                }
-
-                item(key = "spacer_about") { Spacer(modifier = Modifier.height(32.dp)) }
-                item(key = "about") {
-                    AboutCard(
-                        navController = navController,
-                        modelName = state.modelName,
-                        actualModel = state.actualModel,
-                        serialNumbers = state.serialNumbers,
-                        version = state.version3,
-                    )
-                }
-
-                item(key = "spacer_disconnect") { Spacer(modifier = Modifier.height(28.dp)) }
-                item(key = "disconnect_button") {
-                    StyledButton(
-                        onClick = viewModel::disconnect,
-                        backdrop = rememberLayerBackdrop(),
-                        isInteractive = false,
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .heightIn(min = 56.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.disconnect),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                color = if (isSystemInDarkTheme()) Color(0xFF0091FF) else Color(0xFF0088FF),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            textAlign = TextAlign.Start,
-                            modifier = Modifier.fillMaxWidth()
-                        )
-                    }
-                }
-
-//                item(key = "spacer_debug") { Spacer(modifier = Modifier.height(16.dp)) }
-//                item(key = "debug") { NavigationButton("debug", "Debug", navController) }
-                item(key = "spacer_bottom") { Spacer(Modifier.height(bottomPadding)) }
-            }
-        } else {
-            val backdrop = rememberLayerBackdrop()
-            Column(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .drawBackdrop(
-                        backdrop = rememberLayerBackdrop(),
-                        exportedBackdrop = backdrop,
-                        shape = { RoundedCornerShape(0.dp) },
-                        highlight = {
-                            Highlight.Ambient.copy(alpha = 0f)
-                        },
-                        effects = {})
-                    .hazeSource(hazeState)
-                    .padding(horizontal = 8.dp),
-                horizontalAlignment = Alignment.CenterHorizontally,
-                verticalArrangement = Arrangement.Center
-            ) {
-                val tapCount = remember { mutableIntStateOf(0) }
-                val lastTapTime = remember { mutableLongStateOf(0L) }
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .pointerInput(Unit) {
-                            detectTapGestures(
-                                onTap = {
-                                    val now = System.currentTimeMillis()
-
-                                    if (now - lastTapTime.longValue > 400) {
-                                        tapCount.intValue = 0
-                                    }
-
-                                    tapCount.intValue++
-                                    lastTapTime.longValue = now
-
-                                    if (tapCount.intValue >= 5) {
-                                        tapCount.intValue = 0
-                                        viewModel.activateDemoMode()
-                                    }
-                                })
-                        }) {
-                    Text(
-                        text = stringResource(R.string.airpods_not_connected), style = TextStyle(
-                            fontSize = 24.sp,
-                            fontWeight = FontWeight.Medium,
-                            color = if (isSystemInDarkTheme()) Color.White else Color.Black,
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        ), textAlign = TextAlign.Center, modifier = Modifier.fillMaxWidth()
-                    )
-                    Spacer(Modifier.height(24.dp))
-                    Text(
-                        text = stringResource(R.string.airpods_not_connected_description),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Light,
-                            color = if (isSystemInDarkTheme()) Color.White else Color.Black,
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        ),
-                        textAlign = TextAlign.Center,
-                        modifier = Modifier.fillMaxWidth(),
-                    )
-                }
-
-                Spacer(Modifier.height(32.dp))
-                if (!BuildConfig.PLAY_BUILD) {
-                    StyledButton(
-                        onClick = { navController.navigate("troubleshooting") },
-                        backdrop = backdrop,
-                        modifier = Modifier
-                            .fillMaxWidth(0.9f)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.troubleshooting),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Medium,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = if (isSystemInDarkTheme()) Color.White else Color.Black
-                            )
-                        )
-                    }
-                    Spacer(Modifier.height(16.dp))
-                }
-                if (state.connectionSuccessful) {
-                    StyledButton(
-                        onClick = {
-                            viewModel.reconnectFromSavedMac()
-                        }, backdrop = backdrop, modifier = Modifier.fillMaxWidth(0.9f)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.reconnect_to_last_device),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Medium,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = if (isSystemInDarkTheme()) Color.White else Color.Black
-                            )
-                        )
-                    }
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/AppSettingsScreen.kt

@@ -1,777 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.net.Uri
-import android.os.Build
-import android.widget.Toast
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.KeyboardOptions
-import androidx.compose.foundation.text.input.TextFieldState
-import androidx.compose.foundation.text.input.clearText
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.OutlinedTextField
-import androidx.compose.material3.OutlinedTextFieldDefaults
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.focus.FocusRequester
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.KeyboardCapitalization
-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.lerp
-import androidx.compose.ui.unit.sp
-import androidx.core.net.toUri
-import androidx.lifecycle.viewmodel.compose.viewModel
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.hazeSource
-import me.kavishdevar.librepods.BuildConfig
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.AppInfoCard
-import me.kavishdevar.librepods.presentation.components.DeviceInfoCard
-import me.kavishdevar.librepods.presentation.components.NavigationButton
-import me.kavishdevar.librepods.presentation.components.StyledBottomSheet
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledIconButton
-import me.kavishdevar.librepods.presentation.components.StyledInputField
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledSlider
-import me.kavishdevar.librepods.presentation.components.StyledToggle
-import me.kavishdevar.librepods.presentation.viewmodel.AppSettingsViewModel
-import me.kavishdevar.librepods.utils.XposedState
-import java.util.concurrent.TimeUnit
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun AppSettingsScreen(
-    navController: NavController, viewModel: AppSettingsViewModel = viewModel()
-) {
-    val context = LocalContext.current
-    val scrollState = rememberScrollState()
-    val state by viewModel.uiState.collectAsState()
-
-    val backdrop = rememberLayerBackdrop()
-
-    val contactBottomSheet = remember { mutableStateOf(false) }
-    val subjectState = remember { TextFieldState() }
-    val descriptionState = remember { TextFieldState() }
-    val subjectFocusRequester = remember { FocusRequester() }
-    val descriptionFocusRequester = remember { FocusRequester() }
-
-    StyledScaffold(
-        title = stringResource(R.string.settings)
-    ) { topPadding, hazeState, bottomPadding ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .layerBackdrop(backdrop)
-                .hazeSource(state = hazeState)
-                .verticalScroll(scrollState)
-                .padding(horizontal = 16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(topPadding))
-
-            val isDarkTheme = isSystemInDarkTheme()
-            val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-            val textColor = if (isDarkTheme) Color.White else Color.Black
-
-            if (!state.isPremium && state.connectionSuccessful) {
-                StyledButton(
-                    onClick = {
-                        navController.navigate("purchase_screen")
-                    },
-                    backdrop = rememberLayerBackdrop(),
-                    modifier = Modifier.fillMaxWidth(),
-                    maxScale = 0.05f,
-                    surfaceColor = if (isSystemInDarkTheme()) Color(0xFF916100) else Color(0xFFE59900)
-                ) {
-                    Text(
-                        stringResource(R.string.unlock_advanced_features),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = Color.White
-                        ),
-                    )
-                }
-            }
-            if (state.timeUntilFOSSPremiumExpiry > 0L) {
-                Box(
-                    modifier = Modifier
-                        .background(Color(0xFF32829B), RoundedCornerShape(28.dp))
-                        .clip(RoundedCornerShape(28.dp))
-                        .clickable {
-                            val emailIntent = Intent(Intent.ACTION_SENDTO).apply {
-                                data = "mailto:".toUri()
-                                putExtra(Intent.EXTRA_EMAIL, arrayOf("billing@kavish.xyz"))
-                                putExtra(Intent.EXTRA_SUBJECT, "LibrePods Play billing error")
-                                putExtra(
-                                    Intent.EXTRA_TEXT,
-                                    "Please enter your GitHub username to restore your premium access:\n\nGitHub username: "
-                                )
-                            }
-                            context.startActivity(emailIntent)
-                        }
-                ) {
-                    Text(
-                        text = stringResource(
-                            R.string.play_foss_premium_banner, maxOf(1, TimeUnit.MILLISECONDS.toDays(state.timeUntilFOSSPremiumExpiry).toInt())
-                        ),
-                        modifier = Modifier
-                            .padding(16.dp),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Bold,
-                            color = Color.White,
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-            }
-            if (state.connectionSuccessful) {
-                StyledToggle(
-                    title = stringResource(R.string.widget),
-                    label = stringResource(R.string.show_phone_battery_in_widget),
-                    description = stringResource(R.string.show_phone_battery_in_widget_description),
-                    checked = state.showPhoneBatteryInWidget,
-                    onCheckedChange = viewModel::setShowPhoneBatteryInWidget,
-                    enabled = state.isPremium
-                )
-
-                Text(
-                    text = stringResource(R.string.popup_animations), style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ), modifier = Modifier.padding(16.dp, bottom = 2.dp, top = 24.dp)
-                )
-
-                Spacer(modifier = Modifier.height(2.dp))
-
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(
-                            backgroundColor, RoundedCornerShape(28.dp)
-                        )
-                        .padding(vertical = 4.dp)
-                ) {
-                    StyledToggle(
-                        label = stringResource(R.string.show_bottom_sheet_popup),
-                        description = stringResource(R.string.show_bottom_sheet_popup_description),
-                        checked = state.showBottomSheetPopup,
-                        onCheckedChange = viewModel::setShowBottomSheetPopup,
-                        independent = false
-                    )
-
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(horizontal = 12.dp)
-                    )
-
-                    StyledToggle(
-                        label = stringResource(R.string.show_island_popup),
-                        description = stringResource(R.string.show_island_popup_description),
-                        checked = state.showIslandPopup,
-                        onCheckedChange = viewModel::setShowIslandPopup,
-                        independent = false
-                    )
-                }
-
-                Text(
-                    text = stringResource(R.string.conversational_awareness), style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ), modifier = Modifier.padding(16.dp, bottom = 2.dp, top = 24.dp)
-                )
-
-                Spacer(modifier = Modifier.height(2.dp))
-
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(
-                            backgroundColor, RoundedCornerShape(28.dp)
-                        )
-                        .padding(vertical = 4.dp)
-                ) {
-                    StyledToggle(
-                        label = stringResource(R.string.conversational_awareness_pause_music),
-                        description = stringResource(R.string.conversational_awareness_pause_music_description),
-                        checked = state.conversationalAwarenessPauseMusicEnabled,
-                        onCheckedChange = viewModel::setConversationalAwarenessPauseMusicEnabled,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(horizontal = 12.dp)
-                    )
-
-                    StyledToggle(
-                        label = stringResource(R.string.relative_conversational_awareness_volume),
-                        description = stringResource(R.string.relative_conversational_awareness_volume_description),
-                        checked = state.relativeConversationalAwarenessVolumeEnabled,
-                        onCheckedChange = viewModel::setRelativeConversationalAwarenessVolumeEnabled,
-                        independent = false,
-                        enabled = state.isPremium,
-                    )
-                }
-
-                Spacer(modifier = Modifier.height(16.dp))
-
-                val conversationalAwarenessVolume = state.conversationalAwarenessVolume
-                LaunchedEffect(conversationalAwarenessVolume) {
-                    viewModel.setConversationalAwarenessVolume(conversationalAwarenessVolume)
-                }
-
-                StyledSlider(
-                    label = stringResource(R.string.conversational_awareness_volume),
-                    value = conversationalAwarenessVolume,
-                    valueRange = 10f..85f,
-                    snapPoints = listOf(44f),
-                    startLabel = "10%",
-                    endLabel = "85%",
-                    onValueChange = { newValue ->
-                        viewModel.setConversationalAwarenessVolume(
-                            newValue
-                        )
-                    },
-                    independent = true,
-                    enabled = state.isPremium
-                )
-
-//            if (!BuildConfig.PLAY_BUILD) {
-//                Spacer(modifier = Modifier.height(16.dp))
-//
-//                NavigationButton(
-//                    to = "",
-//                    title = stringResource(R.string.camera_control),
-//                    name = stringResource(R.string.set_custom_camera_package),
-//                    navController = navController,
-//                    onClick = {
-//                        if (state.isPremium) viewModel.setShowCameraDialog(true)
-//                    },
-//                    independent = true,
-//                    description = stringResource(R.string.camera_control_app_description)
-//                )
-//            }
-
-                Spacer(modifier = Modifier.height(16.dp))
-                if (context.checkSelfPermission("android.permission.BLUETOOTH_PRIVILEGED") == PackageManager.PERMISSION_GRANTED) {
-                    StyledToggle(
-                        title = stringResource(R.string.ear_detection),
-                        label = stringResource(R.string.disconnect_when_not_wearing),
-                        description = stringResource(R.string.disconnect_when_not_wearing_description),
-                        checked = state.disconnectWhenNotWearing,
-                        onCheckedChange = viewModel::setDisconnectWhenNotWearing,
-                        enabled = state.isPremium
-                    )
-                }
-
-                Text(
-                    text = stringResource(R.string.takeover_airpods_state), style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ), modifier = Modifier.padding(16.dp, bottom = 2.dp, top = 24.dp)
-                )
-
-                Spacer(modifier = Modifier.height(4.dp))
-
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(
-                            backgroundColor, RoundedCornerShape(28.dp)
-                        )
-                        .padding(vertical = 4.dp)
-                ) {
-                    StyledToggle(
-                        label = stringResource(R.string.takeover_disconnected),
-                        description = stringResource(R.string.takeover_disconnected_desc),
-                        checked = state.takeoverWhenDisconnected,
-                        onCheckedChange = viewModel::setTakeoverWhenDisconnected,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(horizontal = 12.dp)
-                    )
-
-                    StyledToggle(
-                        label = stringResource(R.string.takeover_idle),
-                        description = stringResource(R.string.takeover_idle_desc),
-                        checked = state.takeoverWhenIdle,
-                        onCheckedChange = viewModel::setTakeoverWhenIdle,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(horizontal = 12.dp)
-                    )
-
-                    StyledToggle(
-                        label = stringResource(R.string.takeover_music),
-                        description = stringResource(R.string.takeover_music_desc),
-                        checked = state.takeoverWhenMusic,
-                        onCheckedChange = viewModel::setTakeoverWhenMusic,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(horizontal = 12.dp)
-                    )
-
-                    StyledToggle(
-                        label = stringResource(R.string.takeover_call),
-                        description = stringResource(R.string.takeover_call_desc),
-                        checked = state.takeoverWhenCall,
-                        onCheckedChange = viewModel::setTakeoverWhenCall,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-                }
-
-                Spacer(modifier = Modifier.height(16.dp))
-
-                Text(
-                    text = stringResource(R.string.takeover_phone_state), style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ), modifier = Modifier.padding(horizontal = 16.dp)
-                )
-                Spacer(modifier = Modifier.height(4.dp))
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(
-                            backgroundColor, RoundedCornerShape(28.dp)
-                        )
-                        .padding(vertical = 4.dp)
-                ) {
-                    StyledToggle(
-                        label = stringResource(R.string.takeover_ringing_call),
-                        description = stringResource(R.string.takeover_ringing_call_desc),
-                        checked = state.takeoverWhenRingingCall,
-                        onCheckedChange = viewModel::setTakeoverWhenRingingCall,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier.padding(horizontal = 12.dp)
-                    )
-
-                    StyledToggle(
-                        label = stringResource(R.string.takeover_media_start),
-                        description = stringResource(R.string.takeover_media_start_desc),
-                        checked = state.takeoverWhenMediaStart,
-                        onCheckedChange = viewModel::setTakeoverWhenMediaStart,
-                        independent = false,
-                        enabled = state.isPremium
-                    )
-                }
-
-                Text(
-                    text = stringResource(R.string.advanced_options), style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ), modifier = Modifier.padding(16.dp, bottom = 2.dp, top = 24.dp)
-                )
-
-                Spacer(modifier = Modifier.height(2.dp))
-
-                StyledToggle(
-                    label = stringResource(R.string.use_alternate_head_tracking_packets),
-                    description = stringResource(R.string.use_alternate_head_tracking_packets_description),
-                    checked = state.useAlternateHeadTrackingPackets,
-                    onCheckedChange = viewModel::setUseAlternateHeadTrackingPackets,
-                    independent = true,
-                    enabled = state.isPremium
-                )
-                Spacer(modifier = Modifier.height(16.dp))
-            } else {
-                Box(
-                    modifier = Modifier
-                        .background(if (isDarkTheme) Color.Black else Color(0xFFF2F2F7))
-                        .padding(horizontal = 16.dp)
-                        .padding(top = 16.dp, bottom = 2.dp)
-                ) {
-                    Text(
-                        text = stringResource(R.string.customizations_unavailable),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Normal,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = textColor.copy(alpha = 0.6f),
-                        ),
-                        modifier = Modifier
-                    )
-                }
-            }
-
-            if (XposedState.isAvailable && XposedState.bluetoothScopeEnabled) {
-                val restartBluetoothText =
-                    stringResource(R.string.found_offset_restart_bluetooth)
-                StyledToggle(
-                    label = stringResource(R.string.act_as_an_apple_device) + " (${
-                        stringResource(
-                            R.string.requires_xposed
-                        )
-                    })",
-                    description = stringResource(R.string.act_as_an_apple_device_description),
-                    checked = state.vendorIdHook,
-                    onCheckedChange = { enabled ->
-                        Toast.makeText(context, restartBluetoothText, Toast.LENGTH_SHORT).show()
-                        viewModel.setVendorIdHook(enabled)
-                    },
-                    independent = true,
-                    enabled = state.isPremium
-                )
-            }
-
-            if (!BuildConfig.PLAY_BUILD) {
-                Spacer(modifier = Modifier.height(16.dp))
-                NavigationButton(
-                    to = "troubleshooting",
-                    name = stringResource(R.string.troubleshooting),
-                    navController = navController,
-                    independent = true,
-                    description = stringResource(R.string.troubleshooting_description)
-                )
-            }
-
-            Spacer(modifier = Modifier.height(8.dp))
-
-            Box(
-                modifier = Modifier
-                    .background(if (isDarkTheme) Color.Black else Color(0xFFF2F2F7))
-                    .padding(start = 16.dp, bottom = 2.dp, top = 24.dp, end = 4.dp)
-            ) {
-                Text(
-                    text = stringResource(R.string.contact), style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-
-            Spacer(modifier = Modifier.height(4.dp))
-            Column(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .background(
-                        backgroundColor, RoundedCornerShape(28.dp)
-                    )
-                    .clip(RoundedCornerShape(28.dp))
-            ) {
-                NavigationButton(
-                    to = "",
-                    name = stringResource(R.string.email),
-                    navController = navController,
-                    onClick = { contactBottomSheet.value = true },
-                    independent = false
-                )
-
-                HorizontalDivider(
-                    thickness = 1.dp,
-                    color = Color(0x40888888),
-                    modifier = Modifier.padding(horizontal = 12.dp)
-                )
-
-                NavigationButton(
-                    to = "",
-                    name = stringResource(R.string.discord),
-                    navController = navController,
-                    onClick = {
-                        val intent =
-                            Intent(Intent.ACTION_VIEW, "https://discord.gg/Ts4wupXcmc".toUri())
-                        context.startActivity(intent)
-                    },
-                    independent = false
-                )
-
-                HorizontalDivider(
-                    thickness = 1.dp,
-                    color = Color(0x40888888),
-                    modifier = Modifier.padding(horizontal = 12.dp)
-                )
-
-                NavigationButton(
-                    to = "",
-                    name = stringResource(R.string.github_issues),
-                    navController = navController,
-                    onClick = {
-                        val appVersion = Uri.encode("v${BuildConfig.VERSION_NAME} (${BuildConfig.VERSION_CODE})")
-                        val device = Uri.encode("${Build.MANUFACTURER} ${Build.MODEL}")
-                        val androidVersion = Uri.encode("${Build.ID} (${Build.DISPLAY})")
-                        val appSource = Uri.encode(
-                            when {
-                                BuildConfig.PLAY_BUILD -> "Play"
-                                else -> "GitHub"
-                            }
-                        )
-                        val url = "https://github.com/kavishdevar/librepods/issues/new" +
-                            "?template=01-bug-report-android.yml" +
-                            "&app-source=$appSource" +
-                            "&app-version=$appVersion" +
-                            "&device=$device" +
-                            "&android-version=$androidVersion"
-
-                        val intent = Intent(Intent.ACTION_VIEW, url.toUri())
-                        context.startActivity(intent)
-                    },
-                    independent = false
-                )
-            }
-
-            Spacer(modifier = Modifier.height(20.dp))
-            DeviceInfoCard()
-            Spacer(modifier = Modifier.height(16.dp))
-            AppInfoCard()
-
-            Spacer(modifier = Modifier.height(16.dp))
-
-            NavigationButton(
-                to = "open_source_licenses",
-                name = stringResource(R.string.open_source_licenses),
-                navController = navController,
-                independent = true
-            )
-
-            Spacer(modifier = Modifier.height(bottomPadding))
-
-            if (state.showCameraDialog) {
-                AlertDialog(onDismissRequest = { viewModel.setShowCameraDialog(false) }, title = {
-                    Text(
-                        stringResource(R.string.set_custom_camera_package),
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        fontWeight = FontWeight.Medium
-                    )
-                }, text = {
-                    Column {
-                        Text(
-                            stringResource(R.string.enter_custom_camera_package),
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            modifier = Modifier.padding(bottom = 8.dp)
-                        )
-
-                        OutlinedTextField(
-                            value = state.cameraPackageValue,
-                            onValueChange = {
-                                viewModel.setCameraPackageValue(it)
-                                viewModel.setCameraPackageError(null)
-                            },
-                            modifier = Modifier.fillMaxWidth(),
-                            isError = state.cameraPackageError != null,
-                            keyboardOptions = KeyboardOptions(
-                                keyboardType = KeyboardType.Ascii,
-                                capitalization = KeyboardCapitalization.None
-                            ),
-                            colors = OutlinedTextFieldDefaults.colors(
-                                focusedBorderColor = if (isDarkTheme) Color(0xFF007AFF) else Color(
-                                    0xFF3C6DF5
-                                ),
-                                unfocusedBorderColor = if (isDarkTheme) Color.Gray else Color.LightGray
-                            ),
-                            supportingText = {
-                                if (state.cameraPackageError != null) {
-                                    Text(
-                                        state.cameraPackageError ?: "",
-                                        color = MaterialTheme.colorScheme.error
-                                    )
-                                }
-                            },
-                            label = { Text(stringResource(R.string.custom_camera_package)) })
-                    }
-                }, confirmButton = {
-                    val successText = stringResource(R.string.custom_camera_package_set_success)
-                    TextButton(
-                        onClick = {
-                            viewModel.saveCameraPackage()
-                            Toast.makeText(context, successText, Toast.LENGTH_SHORT).show()
-                        }) {
-                        Text(
-                            "Save",
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            fontWeight = FontWeight.Medium
-                        )
-                    }
-                }, dismissButton = {
-                    TextButton(
-                        onClick = { viewModel.setShowCameraDialog(false) }) {
-                        Text(
-                            "Cancel",
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            fontWeight = FontWeight.Medium
-                        )
-                    }
-                })
-            }
-        }
-        StyledBottomSheet(
-            visible = contactBottomSheet.value,
-            onDismiss = { contactBottomSheet.value = false },
-            backdrop = backdrop
-        ) { innerBackdrop, progress ->
-            val animatedPadding = lerp(16.dp, 2.dp, progress)
-
-            Column(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .padding(horizontal = animatedPadding)
-                    .padding(bottom = 16.dp),
-            ) {
-               Row(
-                   modifier = Modifier
-                       .fillMaxWidth()
-                       .padding(bottom = 16.dp),
-                   horizontalArrangement = Arrangement.SpaceBetween,
-                   verticalAlignment = Alignment.CenterVertically
-               ) {
-                   StyledIconButton(
-                       icon = "\uDBC0\uDD84",
-                       backdrop = innerBackdrop,
-                       onClick = { contactBottomSheet.value = false }
-                   )
-                   Text (
-                       text = stringResource(R.string.describe_your_issue),
-                       style = TextStyle(
-                           fontSize = 18.sp,
-                           fontFamily = FontFamily(Font(R.font.sf_pro)),
-                           fontWeight = FontWeight.Bold,
-                           textAlign = TextAlign.Center,
-                           color = if (isSystemInDarkTheme()) Color.White else Color.Black
-                       )
-                   )
-                   StyledIconButton(
-                       icon = "\uDBC0\uDE1F",
-                       backdrop = innerBackdrop,
-                       surfaceColor = if (isSystemInDarkTheme()) Color(0xFF0091FF) else Color(0xFF0088FF),
-                       iconTint = if (subjectState.text.isNotEmpty() && descriptionState.text.isNotEmpty()) Color.White else Color.Gray,
-                       enabled = subjectState.text.isNotEmpty() && descriptionState.text.isNotEmpty(),
-                       onClick = {
-                           contactBottomSheet.value = false
-                           val intent = Intent(Intent.ACTION_SENDTO).apply {
-                               data = "mailto:".toUri()
-                               putExtra(Intent.EXTRA_EMAIL, arrayOf("contact@kavish.xyz"))
-                               putExtra(Intent.EXTRA_SUBJECT, "LibrePods: ${subjectState.text}")
-                               putExtra(
-                                   Intent.EXTRA_TEXT,
-                                   "${descriptionState.text}" +
-                                       "\n\n----------" +
-                                       "\nPhone details:" +
-                                       "\nMANUFACTURER: ${Build.MANUFACTURER}" +
-                                       "\nMODEL: ${Build.MODEL} (${Build.PRODUCT})" +
-                                       "\nDISPLAY_VERSION: ${Build.DISPLAY}" +
-                                       "\nID: ${Build.ID} (SDK ${Build.VERSION.SDK_INT_FULL})" +
-                                       "\nXposed enabled/active: ${XposedState.isAvailable}/${XposedState.bluetoothScopeEnabled}" +
-                                       "\n\nApp details:" +
-                                       "\nVERSION: ${BuildConfig.VERSION_NAME}" +
-                                       "\nVERSION_CODE: ${BuildConfig.VERSION_CODE}" +
-                                       "\nFLAVOR: ${BuildConfig.FLAVOR}" +
-                                       "\nBUILD_TYPE: ${BuildConfig.BUILD_TYPE}"
-                               )
-                           }
-                           context.startActivity(intent)
-                           subjectState.clearText()
-                           descriptionState.clearText()
-                       }
-                   )
-               }
-
-               Spacer(modifier = Modifier.height(8.dp))
-
-               StyledInputField(
-                   inputState = subjectState,
-                   focusRequester = subjectFocusRequester,
-                   placeholder = stringResource(R.string.subject),
-               )
-
-               Spacer(modifier = Modifier.height(12.dp))
-
-               StyledInputField(
-                   inputState = descriptionState,
-                   focusRequester = descriptionFocusRequester,
-                   placeholder = stringResource(R.string.describe_your_issue),
-                   singleLine = false
-               )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/CameraControlScreen.kt

@@ -1,111 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.accessibilityservice.AccessibilityServiceInfo
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.provider.Settings
-import android.view.accessibility.AccessibilityManager
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.SelectItem
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledSelectList
-import me.kavishdevar.librepods.services.AppListenerService
-import me.kavishdevar.librepods.bluetooth.AACPManager.Companion.StemPressType
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-
-@Composable
-fun CameraControlScreen(viewModel: AirPodsViewModel) {
-    val context = LocalContext.current
-    val currentCameraAction by viewModel.cameraAction.collectAsState()
-
-    fun isAppListenerServiceEnabled(context: Context): Boolean {
-        val am = context.getSystemService(Context.ACCESSIBILITY_SERVICE) as AccessibilityManager
-        val enabledServices =
-            am.getEnabledAccessibilityServiceList(AccessibilityServiceInfo.FEEDBACK_ALL_MASK)
-        val serviceComponent = ComponentName(context, AppListenerService::class.java)
-        return enabledServices.any {
-            it.resolveInfo.serviceInfo.packageName == serviceComponent.packageName &&
-                it.resolveInfo.serviceInfo.name == serviceComponent.className
-        }
-    }
-
-    fun handleSelection(action: StemPressType?) {
-        if (action != null && !isAppListenerServiceEnabled(context)) {
-            context.startActivity(Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS))
-        } else {
-            viewModel.setCameraAction(action)
-        }
-    }
-
-    val cameraOptions = remember(currentCameraAction) {
-        listOf(
-            SelectItem(
-                name = "Off",
-                selected = currentCameraAction == null,
-                onClick = { handleSelection(null) }
-            ),
-            SelectItem(
-                name = "Press once",
-                selected = currentCameraAction == StemPressType.SINGLE_PRESS,
-                onClick = { handleSelection(StemPressType.SINGLE_PRESS) }
-            ),
-            SelectItem(
-                name = "Press and hold AirPods",
-                selected = currentCameraAction == StemPressType.LONG_PRESS,
-                onClick = { handleSelection(StemPressType.LONG_PRESS) }
-            )
-        )
-    }
-
-    val backdrop = rememberLayerBackdrop()
-
-    StyledScaffold(
-        title = stringResource(R.string.camera_control)
-    ) { spacerHeight ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .layerBackdrop(backdrop)
-                .padding(horizontal = 16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(spacerHeight))
-            StyledSelectList(items = cameraOptions)
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/DebugScreen.kt

@@ -1,523 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalHazeMaterialsApi::class, ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.annotation.SuppressLint
-import android.content.ClipData
-import android.content.ClipboardManager
-import android.content.Context
-import android.os.Build
-import android.widget.Toast
-import androidx.annotation.RequiresApi
-import androidx.compose.foundation.ExperimentalFoundationApi
-import androidx.compose.foundation.background
-import androidx.compose.foundation.combinedClickable
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.navigationBarsPadding
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.lazy.LazyColumn
-import androidx.compose.foundation.lazy.rememberLazyListState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Send
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
-import androidx.compose.material3.TextFieldDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.platform.LocalFocusManager
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.hazeSource
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.StyledIconButton
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.data.BatteryStatus
-import me.kavishdevar.librepods.data.isHeadTrackingData
-import me.kavishdevar.librepods.services.ServiceManager
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-data class PacketInfo(
-    val type: String,
-    val description: String,
-    val rawData: String,
-    val parsedData: Map<String, String> = emptyMap(),
-    val isUnknown: Boolean = false
-)
-
-fun parsePacket(message: String): PacketInfo {
-    val rawData = if (message.startsWith("Sent")) message.substring(5) else message.substring(9)
-    val bytes = rawData.split(" ").mapNotNull {
-        it.takeIf { it.isNotEmpty() }?.toIntOrNull(16)?.toByte()
-    }.toByteArray()
-
-    val airPodsService = ServiceManager.getService()
-    if (airPodsService != null) {
-        return when {
-            message.startsWith("Sent") -> parseOutgoingPacket(bytes, rawData)
-            airPodsService.batteryNotification.isBatteryData(bytes) -> {
-                val batteryInfo = mutableMapOf<String, String>()
-                airPodsService.batteryNotification.setBattery(bytes)
-                val batteries = airPodsService.batteryNotification.getBattery()
-                val batteryInfoString = batteries.joinToString(", ") { battery ->
-                    "${battery.getComponentName() ?: "Unknown"}: ${battery.level}% ${if (battery.status == BatteryStatus.CHARGING) "(Charging)" else ""}"
-                }
-                batteries.forEach { battery ->
-                    if (battery.status != BatteryStatus.DISCONNECTED) {
-                        batteryInfo[battery.getComponentName() ?: "Unknown"] =
-                            "${battery.level}% ${if (battery.status == BatteryStatus.CHARGING) "(Charging)" else ""}"
-                    }
-                }
-
-                PacketInfo(
-                    "Battery",
-                    batteryInfoString,
-                    rawData,
-                    batteryInfo
-                )
-            }
-            airPodsService.ancNotification.isANCData(bytes) -> {
-                airPodsService.ancNotification.setStatus(bytes)
-                val mode = when (airPodsService.ancNotification.status) {
-                    1 -> "Off"
-                    2 -> "Noise Cancellation"
-                    3 -> "Transparency"
-                    4 -> "Adaptive"
-                    else -> "Unknown"
-                }
-
-                PacketInfo(
-                    "Noise Control",
-                    "Mode: $mode",
-                    rawData,
-                    mapOf("Mode" to mode)
-                )
-            }
-            airPodsService.earDetectionNotification.isEarDetectionData(bytes) -> {
-                airPodsService.earDetectionNotification.setStatus(bytes)
-                val status = airPodsService.earDetectionNotification.status
-                val primaryStatus = if (status[0] == 0.toByte()) "In ear" else "Out of ear"
-                val secondaryStatus = if (status[1] == 0.toByte()) "In ear" else "Out of ear"
-
-                PacketInfo(
-                    "Ear Detection",
-                    "Primary: $primaryStatus, Secondary: $secondaryStatus",
-                    rawData,
-                    mapOf("Primary" to primaryStatus, "Secondary" to secondaryStatus)
-                )
-            }
-            airPodsService.conversationAwarenessNotification.isConversationalAwarenessData(bytes) -> {
-                airPodsService.conversationAwarenessNotification.setData(bytes)
-                val statusMap = mapOf(
-                    1.toByte() to "Started speaking",
-                    2.toByte() to "Speaking",
-                    8.toByte() to "Stopped speaking",
-                    9.toByte() to "Not speaking"
-                )
-                val status = statusMap[airPodsService.conversationAwarenessNotification.status] ?:
-                    "Unknown (${airPodsService.conversationAwarenessNotification.status})"
-
-                PacketInfo(
-                    "Conversation Awareness",
-                    "Status: $status",
-                    rawData,
-                    mapOf("Status" to status)
-                )
-            }
-            isHeadTrackingData(bytes) -> {
-                val horizontal = if (bytes.size >= 53)
-                    "${bytes[51].toInt() and 0xFF or (bytes[52].toInt() shl 8)}" else "Unknown"
-                val vertical = if (bytes.size >= 55)
-                    "${bytes[53].toInt() and 0xFF or (bytes[54].toInt() shl 8)}" else "Unknown"
-
-                PacketInfo(
-                    "Head Tracking",
-                    "Position data",
-                    rawData,
-                    mapOf("Horizontal" to horizontal, "Vertical" to vertical)
-                )
-            }
-            else -> PacketInfo("Unknown", "Unknown packet format", rawData, emptyMap(), true)
-        }
-    } else {
-        return if (message.startsWith("Sent")) {
-            parseOutgoingPacket(bytes, rawData)
-        } else {
-            PacketInfo("Unknown", "Unknown packet format", rawData, emptyMap(), true)
-        }
-    }
-}
-
-fun parseOutgoingPacket(bytes: ByteArray, rawData: String): PacketInfo {
-    if (bytes.size < 7) {
-        return PacketInfo("Unknown", "Unknown outgoing packet", rawData, emptyMap(), true)
-    }
-
-    return when {
-        bytes.size >= 16 &&
-        bytes[0] == 0x00.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() -> {
-            PacketInfo("Handshake", "Initial handshake with AirPods", rawData)
-        }
-
-        bytes.size >= 11 &&
-        bytes[0] == 0x04.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() &&
-        bytes[4] == 0x09.toByte() &&
-        bytes[5] == 0x00.toByte() &&
-        bytes[6] == 0x0d.toByte() -> {
-            val mode = when (bytes[7].toInt()) {
-                1 -> "Off"
-                2 -> "Noise Cancellation"
-                3 -> "Transparency"
-                4 -> "Adaptive"
-                else -> "Unknown"
-            }
-            PacketInfo("Noise Control", "Set mode to $mode", rawData, mapOf("Mode" to mode))
-        }
-
-        bytes.size >= 11 &&
-        bytes[0] == 0x04.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() &&
-        bytes[4] == 0x09.toByte() &&
-        bytes[5] == 0x00.toByte() &&
-        bytes[6] == 0x28.toByte() -> {
-            val mode = if (bytes[7].toInt() == 1) "On" else "Off"
-            PacketInfo("Conversation Awareness", "Set mode to $mode", rawData, mapOf("Mode" to mode))
-        }
-
-        bytes.size > 10 &&
-        bytes[0] == 0x04.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() &&
-        bytes[4] == 0x17.toByte() -> {
-            val action = if (bytes.joinToString(" ") { "%02X".format(it) }.contains("A1 02")) "Start" else "Stop"
-            PacketInfo("Head Tracking", "$action head tracking", rawData)
-        }
-
-        bytes.size >= 11 &&
-        bytes[0] == 0x04.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() &&
-        bytes[4] == 0x09.toByte() &&
-        bytes[5] == 0x00.toByte() &&
-        bytes[6] == 0x1A.toByte() -> {
-            PacketInfo("Long Press Config", "Change long press modes", rawData)
-        }
-
-        bytes.size >= 9 &&
-        bytes[0] == 0x04.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() &&
-        bytes[4] == 0x4d.toByte() -> {
-            PacketInfo("Feature Request", "Set specific features", rawData)
-        }
-
-        bytes.size >= 9 &&
-        bytes[0] == 0x04.toByte() &&
-        bytes[1] == 0x00.toByte() &&
-        bytes[2] == 0x04.toByte() &&
-        bytes[3] == 0x00.toByte() &&
-        bytes[4] == 0x0f.toByte() -> {
-            PacketInfo("Notifications", "Request notifications", rawData)
-        }
-
-        else -> PacketInfo("Unknown", "Unknown outgoing packet", rawData, emptyMap(), true)
-    }
-}
-
-@RequiresApi(Build.VERSION_CODES.Q)
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class, ExperimentalFoundationApi::class)
-@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter", "UnspecifiedRegisterReceiverFlag")
-@Composable
-fun DebugScreen(navController: NavController) {
-    val context = LocalContext.current
-    val listState = rememberLazyListState()
-    val focusManager = LocalFocusManager.current
-    val coroutineScope = rememberCoroutineScope()
-
-    val airPodsService = remember { ServiceManager.getService() }
-    val packetLogs = airPodsService?.packetLogsFlow?.collectAsState(emptySet())?.value ?: emptySet()
-
-    val refreshTrigger = remember { mutableIntStateOf(0) }
-    LaunchedEffect(refreshTrigger.intValue) {
-        while(true) {
-            delay(1000)
-            refreshTrigger.intValue += 1
-        }
-    }
-
-    val expandedItems = remember { mutableStateOf(setOf<Int>()) }
-
-    fun copyToClipboard(text: String) {
-        val clipboard = context.getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
-        val clip = ClipData.newPlainText("Packet Data", text)
-        clipboard.setPrimaryClip(clip)
-        Toast.makeText(context, "Packet copied to clipboard", Toast.LENGTH_SHORT).show()
-    }
-
-    LaunchedEffect(packetLogs.size, refreshTrigger.intValue) {
-        if (packetLogs.isNotEmpty()) {
-            listState.animateScrollToItem(packetLogs.size - 1)
-        }
-    }
-
-    val isDarkTheme = isSystemInDarkTheme()
-    val backdrop = rememberLayerBackdrop()
-    StyledScaffold(
-        title = "Debug",
-        actionButtons = listOf(
-            {scaffoldBackdrop ->
-                StyledIconButton(
-                    onClick = {
-                        airPodsService?.clearLogs()
-                        expandedItems.value = emptySet()
-                    },
-                    icon = "􀈑",
-                    backdrop = scaffoldBackdrop
-                )
-            }
-        ),
-    ) { topPadding, hazeState, bottomPadding ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .hazeSource(hazeState)
-                .navigationBarsPadding()
-                .layerBackdrop(backdrop)
-                .padding(horizontal = 16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(topPadding))
-            LazyColumn(
-                state = listState,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .weight(1f),
-                content = {
-                    items(packetLogs.size) { index ->
-                        val message = packetLogs.elementAt(index)
-                        val isSent = message.startsWith("Sent")
-                        val isExpanded = expandedItems.value.contains(index)
-                        val packetInfo = parsePacket(message)
-
-                        Card(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(vertical = 2.dp)
-                                .combinedClickable(
-                                    onClick = {
-                                        expandedItems.value = if (isExpanded) {
-                                            expandedItems.value - index
-                                        } else {
-                                            expandedItems.value + index
-                                        }
-                                    },
-                                    onLongClick = {
-                                        copyToClipboard(packetInfo.rawData)
-                                    }
-                                ),
-                            elevation = CardDefaults.cardElevation(defaultElevation = 2.dp),
-                            shape = RoundedCornerShape(4.dp),
-                            colors = CardDefaults.cardColors(
-                                containerColor = if (isSystemInDarkTheme()) Color(0xFF1C1B20) else Color(0xFFF2F2F7),
-                            )
-                        ) {
-                            Row(verticalAlignment = Alignment.CenterVertically) {
-                                Text(
-                                    text = if (isSent) "􀆉" else "􀆊",
-                                    style = TextStyle(
-                                        fontSize = 16.sp,
-                                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                        color = if (isSent) Color(0xFF4CD964) else Color(0xFFFF3B30)
-                                    ),
-                                )
-                                Spacer(modifier = Modifier.width(4.dp))
-                                Column {
-                                    Text(
-                                        text = if (packetInfo.isUnknown) {
-                                            val shortenedData = packetInfo.rawData.take(60) +
-                                                (if (packetInfo.rawData.length > 60) "..." else "")
-                                            shortenedData
-                                        } else {
-                                            "${packetInfo.type}: ${packetInfo.description}"
-                                        },
-                                        style = TextStyle(
-                                            fontSize = 12.sp,
-                                            fontWeight = FontWeight.Medium,
-                                            fontFamily = FontFamily(Font(R.font.hack))
-                                        )
-                                    )
-                                    if (isExpanded) {
-                                        Spacer(modifier = Modifier.height(4.dp))
-
-                                        if (packetInfo.parsedData.isNotEmpty()) {
-                                            packetInfo.parsedData.forEach { (key, value) ->
-                                                Row {
-                                                    Text(
-                                                        text = "$key: ",
-                                                        style = TextStyle(
-                                                            fontSize = 12.sp,
-                                                            fontWeight = FontWeight.Bold,
-                                                            fontFamily = FontFamily(Font(R.font.hack))
-                                                        ),
-                                                        color = Color.Gray
-                                                    )
-                                                    Text(
-                                                        text = value,
-                                                        style = TextStyle(
-                                                            fontSize = 12.sp,
-                                                            fontFamily = FontFamily(Font(R.font.hack))
-                                                        ),
-                                                        color = Color.Gray
-                                                    )
-                                                }
-                                            }
-                                            Spacer(modifier = Modifier.height(4.dp))
-                                        }
-
-                                        Text(
-                                            text = "Raw: ${packetInfo.rawData}",
-                                            style = TextStyle(
-                                                fontSize = 12.sp,
-                                                fontFamily = FontFamily(Font(R.font.hack))
-                                            ),
-                                            color = Color.Gray
-                                        )
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            )
-            Spacer(modifier = Modifier.height(8.dp))
-            val airPodsService = ServiceManager.getService()?.let { mutableStateOf(it) }
-            HorizontalDivider()
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .background(if (isSystemInDarkTheme()) Color(0xFF1C1B20) else Color(0xFFF2F2F7)),
-                verticalAlignment = Alignment.CenterVertically
-            ) {
-                val packet = remember { mutableStateOf(TextFieldValue("")) }
-                TextField(
-                    value = packet.value,
-                    onValueChange = { packet.value = it },
-                    label = { Text("Packet") },
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 8.dp)
-                        .padding(bottom = 5.dp),
-                    trailingIcon = {
-                        IconButton(
-                            onClick = {
-                                if (packet.value.text.isNotBlank()) {
-                                    airPodsService?.value?.aacpManager?.sendPacket(
-                                        packet.value.text
-                                            .split(" ")
-                                            .map { it.toInt(16).toByte() }
-                                            .toByteArray()
-                                    )
-                                    packet.value = TextFieldValue("")
-                                    focusManager.clearFocus()
-
-                                    if (packetLogs.isNotEmpty()) {
-                                        coroutineScope.launch {
-                                            try {
-                                                delay(100)
-                                                listState.animateScrollToItem(
-                                                    index = (packetLogs.size - 1).coerceAtLeast(0),
-                                                    scrollOffset = 0
-                                                )
-                                            } catch (e: Exception) {
-                                                e.printStackTrace()
-                                                listState.scrollToItem(
-                                                    index = (packetLogs.size - 1).coerceAtLeast(0)
-                                                )
-                                            }
-                                        }
-                                    }
-                                }
-                            }
-                        ) {
-                            @Suppress("DEPRECATION")
-                            Icon(Icons.Filled.Send, contentDescription = "Send")
-                        }
-                    },
-                    colors = TextFieldDefaults.colors(
-                        focusedContainerColor = if (isSystemInDarkTheme()) Color(0xFF1C1B20) else Color(0xFFF2F2F7),
-                        unfocusedContainerColor = if (isSystemInDarkTheme()) Color(0xFF1C1B20) else Color(0xFFF2F2F7),
-                        focusedIndicatorColor = Color.Transparent,
-                        unfocusedIndicatorColor = Color.Transparent,
-                        focusedTextColor =  if (isSystemInDarkTheme()) Color.White else Color.Black,
-                        unfocusedTextColor =  if (isSystemInDarkTheme()) Color.White else Color.Black.copy(alpha = 0.6f),
-                        focusedLabelColor =  if (isSystemInDarkTheme()) Color.White.copy(alpha = 0.6f) else Color.Black,
-                        unfocusedLabelColor =  if (isSystemInDarkTheme()) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.6f),
-                    ),
-                    shape = RoundedCornerShape(12.dp)
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/HeadTrackingScreen.kt

@@ -1,759 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-
-// this is absolutely unnecessary, why did I make this. a simple toggle would've sufficed
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.graphics.Paint
-import android.graphics.RadialGradient
-import android.graphics.Shader
-import android.graphics.Typeface
-import android.util.Log
-import androidx.compose.animation.AnimatedContent
-import androidx.compose.animation.ExperimentalAnimationApi
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.togetherWith
-import androidx.compose.foundation.Canvas
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.aspectRatio
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.Card
-import androidx.compose.material3.CardDefaults
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableFloatStateOf
-import androidx.compose.runtime.mutableLongStateOf
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.geometry.CornerRadius
-import androidx.compose.ui.geometry.Offset
-import androidx.compose.ui.geometry.Size
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.Path
-import androidx.compose.ui.graphics.StrokeCap
-import androidx.compose.ui.graphics.asAndroidPath
-import androidx.compose.ui.graphics.drawscope.Stroke
-import androidx.compose.ui.graphics.nativeCanvas
-import androidx.compose.ui.graphics.toArgb
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.drawText
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.rememberTextMeasurer
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.hazeSource
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledIconButton
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledToggle
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-import me.kavishdevar.librepods.services.ServiceManager
-import me.kavishdevar.librepods.utils.HeadTracking
-import kotlin.io.encoding.ExperimentalEncodingApi
-import kotlin.math.abs
-import kotlin.math.cos
-import kotlin.math.sin
-import kotlin.random.Random
-
-@ExperimentalHazeMaterialsApi
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalAnimationApi::class)
-@Composable
-fun HeadTrackingScreen(viewModel: AirPodsViewModel, navController: NavController) {
-    val state by viewModel.uiState.collectAsState()
-    DisposableEffect(Unit) {
-        viewModel.startHeadTracking()
-        onDispose {
-            viewModel.stopHeadTracking()
-        }
-    }
-    val isDarkTheme = isSystemInDarkTheme()
-    if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    val scrollState = rememberScrollState()
-    val backdrop = rememberLayerBackdrop()
-    StyledScaffold(
-        title = stringResource(R.string.head_tracking),
-        actionButtons = listOf(
-            { scaffoldBackdrop ->
-                StyledIconButton(
-                    onClick = {
-                        if (!state.headTrackingActive) {
-                            viewModel.startHeadTracking()
-                            Log.d("HeadTrackingScreen", "Head tracking started")
-                        } else {
-                            viewModel.stopHeadTracking()
-                            Log.d("HeadTrackingScreen", "Head tracking stopped")
-                        }
-                    },
-                    icon = if (state.headTrackingActive) "􀊅" else "􀊃",
-                    backdrop = scaffoldBackdrop
-                )
-            }
-        ),
-    ) { topPadding, hazeState, _ ->
-
-        var gestureText by remember { mutableStateOf("") }
-        val coroutineScope = rememberCoroutineScope()
-
-        var lastClickTime by remember { mutableLongStateOf(0L) }
-        var shouldExplode by remember { mutableStateOf(false) }
-
-        val scrollState = rememberScrollState()
-
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .verticalScroll(scrollState),
-            horizontalAlignment = Alignment.CenterHorizontally
-        ) {
-            Column (
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .hazeSource(state = hazeState)
-                    .layerBackdrop(backdrop)
-                    .padding(top = 8.dp)
-                    .padding(horizontal = 16.dp)
-            ) {
-                Spacer(modifier = Modifier.height(topPadding))
-
-                if (!state.isPremium) {
-                    StyledButton(
-                        onClick = {
-                            navController.navigate("purchase_screen")
-                        },
-                        backdrop = rememberLayerBackdrop(),
-                        modifier = Modifier.fillMaxWidth(),
-                        maxScale = 0.05f,
-                        surfaceColor = if (isSystemInDarkTheme()) Color(0xFF916100) else Color(0xFFE59900)
-                    ) {
-                        Text(
-                            stringResource(R.string.unlock_advanced_features),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Medium,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = Color.White
-                            ),
-                        )
-                    }
-                    Spacer(modifier = Modifier.height(8.dp))
-                }
-
-                StyledToggle(
-                    label = "Head Gestures",
-                    checked = state.headGesturesEnabled,
-                    onCheckedChange = { viewModel.setHeadGesturesEnabled(it) },
-                    enabled = state.isPremium || state.headGesturesEnabled,
-                    description = stringResource(R.string.head_gestures_details)
-                )
-
-                Spacer(modifier = Modifier.height(16.dp))
-                Text(
-                    "Head Orientation",
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier.padding(start = 16.dp, bottom = 8.dp, top = 8.dp)
-                )
-                HeadVisualization()
-
-                Spacer(modifier = Modifier.height(16.dp))
-                Text(
-                    "Velocity",
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier.padding(start = 16.dp, bottom = 8.dp, top = 8.dp)
-                )
-                AccelerationPlot()
-
-                Spacer(modifier = Modifier.height(16.dp))
-
-                LaunchedEffect(gestureText) {
-                    if (gestureText.isNotEmpty()) {
-                        lastClickTime = System.currentTimeMillis()
-                        delay(3000)
-                        if (System.currentTimeMillis() - lastClickTime >= 3000) {
-                            shouldExplode = true
-                        }
-                    }
-                }
-            }
-            val gestureTextValue = stringResource(R.string.shake_your_head_or_nod)
-            StyledButton(
-                onClick = {
-                    gestureText = gestureTextValue
-                    coroutineScope.launch {
-                        val accepted = ServiceManager.getService()?.testHeadGestures() ?: false
-                        gestureText = if (accepted) "\"Yes\" gesture detected." else "\"No\" gesture detected."
-                    }
-                },
-                backdrop = backdrop,
-                modifier = Modifier.fillMaxWidth(0.75f),
-                maxScale = 0.05f
-            ) {
-                Text(
-                    "Test Head Gestures",
-                    style = TextStyle(
-                        fontSize = 16.sp,
-                        fontWeight = FontWeight.Medium,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = textColor
-                    ),
-                )
-            }
-            Box(
-                contentAlignment = Alignment.Center,
-                modifier = Modifier.padding(top = 12.dp, bottom = 24.dp)
-            ) {
-                AnimatedContent(
-                    targetState = gestureText,
-                    transitionSpec = {
-                        (fadeIn(
-                            animationSpec = tween(300)
-                        ) + slideInVertically(
-                            initialOffsetY = { 40 },
-                            animationSpec = tween(300)
-                        )).togetherWith(fadeOut(animationSpec = tween(150)))
-                    }
-                ) { text ->
-                    if (shouldExplode) {
-                        LaunchedEffect(Unit) {
-                            CoroutineScope(coroutineScope.coroutineContext).launch {
-                                delay(750)
-                                gestureText = ""
-                            }
-                        }
-                        ParticleText(
-                            text = text,
-                            style = TextStyle(
-                                fontSize = 20.sp,
-                                fontWeight = FontWeight.Medium,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor,
-                                textAlign = TextAlign.Center
-                            ),
-                            onAnimationComplete = {
-                                shouldExplode = false
-                            },
-                        )
-                    } else {
-                        Text(
-                            text = text,
-                            style = TextStyle(
-                                fontSize = 20.sp,
-                                fontWeight = FontWeight.Medium,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor,
-                                textAlign = TextAlign.Center
-                            ),
-                            modifier = Modifier
-                                .fillMaxWidth()
-                        )
-                    }
-                }
-            }
-        }
-    }
-}
-private data class Particle(
-    val initialPosition: Offset,
-    val velocity: Offset,
-    var alpha: Float = 1f
-)
-
-@Composable
-private fun ParticleText(
-    text: String,
-    style: TextStyle,
-    onAnimationComplete: () -> Unit,
-) {
-    val particles = remember { mutableStateListOf<Particle>() }
-    val textMeasurer = rememberTextMeasurer()
-    var isAnimating by remember { mutableStateOf(true) }
-    var textVisible by remember { mutableStateOf(true) }
-
-    Canvas(modifier = Modifier.fillMaxWidth()) {
-        val textLayoutResult = textMeasurer.measure(text, style)
-        val textBounds = textLayoutResult.size
-        val centerX = (size.width - textBounds.width) / 2
-        val centerY = size.height / 2
-
-        if (textVisible && particles.isEmpty()) {
-            drawText(
-                textMeasurer = textMeasurer,
-                text = text,
-                style = style,
-                topLeft = Offset(centerX, centerY - textBounds.height / 2)
-            )
-        }
-
-        if (particles.isEmpty()) {
-            val random = Random(System.currentTimeMillis())
-            for (@Suppress("Unused")i in 0..100) {
-                val x = centerX + random.nextFloat() * textBounds.width
-                val y = centerY - textBounds.height / 2 + random.nextFloat() * textBounds.height
-                val vx = (random.nextFloat() - 0.5f) * 20
-                val vy = (random.nextFloat() - 0.5f) * 20
-                particles.add(Particle(Offset(x, y), Offset(vx, vy)))
-            }
-        }
-
-        particles.forEach { particle ->
-            drawCircle(
-                color = style.color.copy(alpha = particle.alpha),
-                radius = 0.5.dp.toPx(),
-                center = particle.initialPosition
-            )
-        }
-    }
-
-    LaunchedEffect(text) {
-        while (isAnimating) {
-            delay(16)
-            particles.forEachIndexed { index, particle ->
-                particles[index] = particle.copy(
-                    initialPosition = particle.initialPosition + particle.velocity,
-                    alpha = (particle.alpha - 0.02f).coerceAtLeast(0f)
-                )
-            }
-
-            if (particles.all { it.alpha <= 0f }) {
-                isAnimating = false
-                onAnimationComplete()
-            }
-        }
-    }
-}
-
-@Composable
-private fun HeadVisualization() {
-    val orientation by HeadTracking.orientation.collectAsState()
-    val darkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (darkTheme) Color(0xFF1C1C1E) else Color.White
-    val strokeColor = if (darkTheme) Color.White else Color.Black
-
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .aspectRatio(2f),
-        colors = CardDefaults.cardColors(
-            containerColor = backgroundColor
-        ),
-        shape = RoundedCornerShape(28.dp)
-    ) {
-        Box(
-            modifier = Modifier.fillMaxSize(),
-            contentAlignment = Alignment.Center
-        ) {
-            Canvas(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .padding(16.dp)
-            ) {
-                val width = size.width
-                val height = size.height
-                val center = Offset(width / 2, height / 2)
-                val faceRadius = height * 0.35f
-
-                val pitch = Math.toRadians(orientation.pitch.toDouble())
-                val yaw = Math.toRadians(orientation.yaw.toDouble())
-
-                val cosY = cos(yaw).toFloat()
-                val sinY = sin(yaw).toFloat()
-                val cosP = cos(pitch).toFloat()
-                val sinP = sin(pitch).toFloat()
-
-                fun rotate3D(point: Triple<Float, Float, Float>): Triple<Float, Float, Float> {
-                    val (x, y, z) = point
-                    val x1 = x * cosY - z * sinY
-                    val z1 = x * sinY + z * cosY
-
-                    val y2 = y * cosP - z1 * sinP
-                    val z2 = y * sinP + z1 * cosP
-
-                    return Triple(x1, y2, z2)
-                }
-
-                fun project(point: Triple<Float, Float, Float>): Pair<Float, Float> {
-                    val (x, y, z) = point
-                    val scale = 1f + (z / width)
-                    return Pair(center.x + x * scale, center.y + y * scale)
-                }
-
-                val earWidth = height * 0.08f
-                val earHeight = height * 0.2f
-                val earOffsetX = height * 0.4f
-                val earOffsetY = 0f
-                val earZ = 0f
-
-                for (xSign in listOf(-1f, 1f)) {
-                    val rotated = rotate3D(Triple(earOffsetX * xSign, earOffsetY, earZ))
-                    val (earX, earY) = project(rotated)
-                    drawRoundRect(
-                        color = strokeColor,
-                        topLeft = Offset(earX - earWidth/2, earY - earHeight/2),
-                        size = Size(earWidth, earHeight),
-                        cornerRadius = CornerRadius(earWidth/2),
-                        style = Stroke(width = 4.dp.toPx())
-                    )
-                }
-
-                val spherePath = Path()
-                val firstPoint = project(rotate3D(Triple(faceRadius, 0f, 0f)))
-                spherePath.moveTo(firstPoint.first, firstPoint.second)
-
-                for (i in 1..32) {
-                    val angle = (i * 2 * Math.PI / 32).toFloat()
-                    val point = project(rotate3D(Triple(
-                        cos(angle) * faceRadius,
-                        sin(angle) * faceRadius,
-                        0f
-                    )))
-                    spherePath.lineTo(point.first, point.second)
-                }
-                spherePath.close()
-
-                drawContext.canvas.nativeCanvas.apply {
-                    val paint = Paint().apply {
-                        style = Paint.Style.FILL
-                        shader = RadialGradient(
-                            center.x + sinY * faceRadius * 0.3f,
-                            center.y - sinP * faceRadius * 0.3f,
-                            faceRadius * 1.4f,
-                            intArrayOf(
-                                backgroundColor.copy(alpha = 1f).toArgb(),
-                                backgroundColor.copy(alpha = 0.95f).toArgb(),
-                                backgroundColor.copy(alpha = 0.9f).toArgb(),
-                                backgroundColor.copy(alpha = 0.8f).toArgb(),
-                                backgroundColor.copy(alpha = 0.7f).toArgb()
-                            ),
-                            floatArrayOf(0.3f, 0.5f, 0.7f, 0.8f, 1f),
-                            Shader.TileMode.CLAMP
-                        )
-                    }
-                    drawPath(spherePath.asAndroidPath(), paint)
-
-                    val highlightPaint = Paint().apply {
-                        style = Paint.Style.FILL
-                        shader = RadialGradient(
-                            center.x - faceRadius * 0.4f - sinY * faceRadius * 0.5f,
-                            center.y - faceRadius * 0.4f - sinP * faceRadius * 0.5f,
-                            faceRadius * 0.9f,
-                            intArrayOf(
-                                android.graphics.Color.WHITE,
-                                android.graphics.Color.argb(100, 255, 255, 255),
-                                android.graphics.Color.TRANSPARENT
-                            ),
-                            floatArrayOf(0f, 0.3f, 1f),
-                            Shader.TileMode.CLAMP
-                        )
-                        alpha = if (darkTheme) 30 else 60
-                    }
-                    drawPath(spherePath.asAndroidPath(), highlightPaint)
-
-                    val secondaryHighlightPaint = Paint().apply {
-                        style = Paint.Style.FILL
-                        shader = RadialGradient(
-                            center.x + faceRadius * 0.3f + sinY * faceRadius * 0.3f,
-                            center.y + faceRadius * 0.3f - sinP * faceRadius * 0.3f,
-                            faceRadius * 0.7f,
-                            intArrayOf(
-                                android.graphics.Color.WHITE,
-                                android.graphics.Color.TRANSPARENT
-                            ),
-                            floatArrayOf(0f, 1f),
-                            Shader.TileMode.CLAMP
-                        )
-                        alpha = if (darkTheme) 15 else 30
-                    }
-                    drawPath(spherePath.asAndroidPath(), secondaryHighlightPaint)
-
-                    val shadowPaint = Paint().apply {
-                        style = Paint.Style.FILL
-                        shader = RadialGradient(
-                            center.x + sinY * faceRadius * 0.5f,
-                            center.y - sinP * faceRadius * 0.5f,
-                            faceRadius * 1.1f,
-                            intArrayOf(
-                                android.graphics.Color.TRANSPARENT,
-                                android.graphics.Color.BLACK
-                            ),
-                            floatArrayOf(0.7f, 1f),
-                            Shader.TileMode.CLAMP
-                        )
-                        alpha = if (darkTheme) 40 else 20
-                    }
-                    drawPath(spherePath.asAndroidPath(), shadowPaint)
-                }
-
-                drawPath(
-                    path = spherePath,
-                    color = strokeColor,
-                    style = Stroke(width = 4.dp.toPx())
-                )
-
-                val smileRadius = faceRadius * 0.5f
-                val smileStartAngle = -340f
-                val smileSweepAngle = 140f
-                val smileOffsetY = faceRadius * 0.1f
-
-                val smilePath = Path()
-                for (i in 0..32) {
-                    val angle = Math.toRadians(smileStartAngle + (smileSweepAngle * i / 32.0))
-                    val x = cos(angle.toFloat()) * smileRadius
-                    val y = sin(angle.toFloat()) * smileRadius + smileOffsetY
-
-                    val rotated = rotate3D(Triple(x, y, 0f))
-                    val projected = project(rotated)
-
-                    if (i == 0) {
-                        smilePath.moveTo(projected.first, projected.second)
-                    } else {
-                        smilePath.lineTo(projected.first, projected.second)
-                    }
-                }
-
-                drawPath(
-                    path = smilePath,
-                    color = strokeColor,
-                    style = Stroke(
-                        width = 4.dp.toPx(),
-                        cap = StrokeCap.Round
-                    )
-                )
-
-                val eyeOffsetX = height * 0.15f
-                val eyeOffsetY = height * 0.1f
-                val eyeLength = height * 0.08f
-
-                for (xSign in listOf(-1f, 1f)) {
-                    val rotated = rotate3D(Triple(eyeOffsetX * xSign, -eyeOffsetY, 0f))
-                    val (eyeX, eyeY) = project(rotated)
-                    drawLine(
-                        color = strokeColor,
-                        start = Offset(eyeX, eyeY - eyeLength/2),
-                        end = Offset(eyeX, eyeY + eyeLength/2),
-                        strokeWidth = 4.dp.toPx(),
-                        cap = StrokeCap.Round
-                    )
-                }
-
-                drawContext.canvas.nativeCanvas.apply {
-                    val paint = Paint().apply {
-                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
-                        textSize = 12.sp.toPx()
-                        textAlign = Paint.Align.RIGHT
-                        typeface = Typeface.create(
-                            "SF Pro",
-                            Typeface.NORMAL
-                        )
-                    }
-
-                    val pitch = orientation.pitch.toInt()
-                    val yaw = orientation.yaw.toInt()
-                    val text = "Pitch: ${pitch}° Yaw: ${yaw}°"
-
-                    drawText(
-                        text,
-                        width - 8.dp.toPx(),
-                        height - 8.dp.toPx(),
-                        paint
-                    )
-                }
-            }
-        }
-    }
-}
-
-@Composable
-private fun AccelerationPlot() {
-    val acceleration by HeadTracking.acceleration.collectAsState()
-    val maxPoints = 100
-    val points = remember { mutableStateListOf<Pair<Float, Float>>() }
-    val darkTheme = isSystemInDarkTheme()
-
-    var maxAbs by remember { mutableFloatStateOf(1000f) }
-
-    LaunchedEffect(acceleration) {
-        points.add(Pair(acceleration.horizontal, acceleration.vertical))
-        if (points.size > maxPoints) {
-            points.removeAt(0)
-        }
-
-        val currentMax = points.maxOf { maxOf(abs(it.first), abs(it.second)) }
-        maxAbs = maxOf(currentMax * 1.2f, 1000f)
-    }
-
-    Card(
-        modifier = Modifier
-            .fillMaxWidth()
-            .height(300.dp),
-        colors = CardDefaults.cardColors(
-            containerColor = if (darkTheme) Color(0xFF1C1C1E) else Color.White
-        ),
-        shape = RoundedCornerShape(28.dp)
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(16.dp)
-        ) {
-            Canvas(
-                modifier = Modifier.fillMaxSize()
-            ) {
-                val width = size.width
-                val height = size.height
-                val xScale = width / maxPoints
-                val yScale = (height - 40.dp.toPx()) / (maxAbs * 2)
-                val zeroY = height / 2
-
-                val gridColor = if (darkTheme) Color.White.copy(alpha = 0.1f) else Color.Black.copy(alpha = 0.1f)
-
-                for (i in 0..maxPoints step 10) {
-                    val x = i * xScale
-                    drawLine(
-                        color = gridColor,
-                        start = Offset(x, 0f),
-                        end = Offset(x, height),
-                        strokeWidth = 1.dp.toPx()
-                    )
-                }
-
-                val gridStep = maxAbs / 4
-                for (value in (-maxAbs.toInt()..maxAbs.toInt()) step gridStep.toInt()) {
-                    val y = zeroY - value * yScale
-                    drawLine(
-                        color = gridColor,
-                        start = Offset(0f, y),
-                        end = Offset(width, y),
-                        strokeWidth = 1.dp.toPx()
-                    )
-                }
-
-                drawLine(
-                    color = if (darkTheme) Color.White.copy(alpha = 0.3f) else Color.Black.copy(alpha = 0.3f),
-                    start = Offset(0f, zeroY),
-                    end = Offset(width, zeroY),
-                    strokeWidth = 1.5f.dp.toPx()
-                )
-
-                if (points.size > 1) {
-                    for (i in 0 until points.size - 1) {
-                        val x1 = i * xScale
-                        val x2 = (i + 1) * xScale
-
-                        drawLine(
-                            color = Color(0xFF007AFF),
-                            start = Offset(x1, zeroY - points[i].first * yScale),
-                            end = Offset(x2, zeroY - points[i + 1].first * yScale),
-                            strokeWidth = 2.dp.toPx()
-                        )
-
-                        drawLine(
-                            color = Color(0xFFFF3B30),
-                            start = Offset(x1, zeroY - points[i].second * yScale),
-                            end = Offset(x2, zeroY - points[i + 1].second * yScale),
-                            strokeWidth = 2.dp.toPx()
-                        )
-                    }
-                }
-
-                drawContext.canvas.nativeCanvas.apply {
-                    val paint = Paint().apply {
-                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
-                        textSize = 12.sp.toPx()
-                        textAlign = Paint.Align.RIGHT
-                    }
-
-                    drawText("${maxAbs.toInt()}", 30.dp.toPx(), 20.dp.toPx(), paint)
-                    drawText("0", 30.dp.toPx(), height/2, paint)
-                    drawText("-${maxAbs.toInt()}", 30.dp.toPx(), height - 10.dp.toPx(), paint)
-                }
-
-                val legendY = 15.dp.toPx()
-                val textOffsetY = legendY + 5.dp.toPx() / 2
-
-                drawCircle(Color(0xFF007AFF), 5.dp.toPx(), Offset(width - 150.dp.toPx(), legendY))
-                drawContext.canvas.nativeCanvas.apply {
-                    val paint = Paint().apply {
-                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
-                        textSize = 12.sp.toPx()
-                        textAlign = Paint.Align.LEFT
-                    }
-                    drawText("Horizontal", width - 140.dp.toPx(), textOffsetY, paint)
-                }
-
-                drawCircle(Color(0xFFFF3B30), 5.dp.toPx(), Offset(width - 70.dp.toPx(), legendY))
-                drawContext.canvas.nativeCanvas.apply {
-                    val paint = Paint().apply {
-                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
-                        textSize = 12.sp.toPx()
-                        textAlign = Paint.Align.LEFT
-                    }
-                    drawText("Vertical", width - 60.dp.toPx(), textOffsetY, paint)
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/OpenSourceLicensesScreen.kt

@@ -1,82 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.annotation.SuppressLint
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.unit.dp
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import com.mikepenz.aboutlibraries.ui.compose.m3.LibrariesContainer
-import com.mikepenz.aboutlibraries.ui.compose.produceLibraries
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.Job
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-private var debounceJob: Job? = null
-
-@SuppressLint("DefaultLocale")
-@ExperimentalHazeMaterialsApi
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalEncodingApi::class)
-@Composable
-fun OpenSourceLicensesScreen(navController: NavController) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val backdrop = rememberLayerBackdrop()
-
-    StyledScaffold(
-        title = stringResource(R.string.open_source_licenses)
-    ) { spacerHeight ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .layerBackdrop(backdrop)
-                .padding(horizontal = 16.dp),
-            verticalArrangement = Arrangement.spacedBy(16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(spacerHeight))
-            val context = LocalContext.current
-            val libraries by produceLibraries {
-                context.resources.openRawResource(R.raw.aboutlibraries)
-                    .bufferedReader()
-                    .use { it.readText() }
-            }
-            LibrariesContainer(
-                libraries = libraries,
-                modifier = Modifier
-                    .padding(0.dp)
-                    .fillMaxSize()
-            )
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/PressAndHoldSettingsScreen.kt

@@ -1,211 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalStdlibApi::class, ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.util.Log
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.data.StemAction
-import me.kavishdevar.librepods.presentation.components.SelectItem
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.components.StyledSelectList
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-import kotlin.experimental.and
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@ExperimentalHazeMaterialsApi
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun LongPress(viewModel: AirPodsViewModel, name: String, navController: NavController) {
-    val isDarkTheme = isSystemInDarkTheme()
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    val state by viewModel.uiState.collectAsState()
-
-    val modesByte = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS]?.get(0) ?: 0
-
-    Log.d("PressAndHoldSettingsScreen", "Current modes state: ${modesByte.toString(2)}")
-    Log.d("PressAndHoldSettingsScreen", "Off mode: ${(modesByte and 0x01) != 0.toByte()}")
-    Log.d("PressAndHoldSettingsScreen", "Transparency mode: ${(modesByte and 0x04) != 0.toByte()}")
-    Log.d("PressAndHoldSettingsScreen", "Noise Cancellation mode: ${(modesByte and 0x02) != 0.toByte()}")
-    Log.d("PressAndHoldSettingsScreen", "Adaptive mode: ${(modesByte and 0x08) != 0.toByte()}")
-
-    val longPressAction = if (name.lowercase() == "left") state.leftAction else state.rightAction
-    val backdrop = rememberLayerBackdrop()
-    StyledScaffold(
-        title = name
-    ) { spacerHeight ->
-        Column (
-            modifier = Modifier
-              .layerBackdrop(backdrop)
-              .fillMaxSize()
-              .padding(top = 8.dp)
-              .padding(horizontal = 16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(spacerHeight))
-            val actionItems = listOf(
-                SelectItem(
-                    name = stringResource(R.string.noise_control),
-                    selected = longPressAction == StemAction.CYCLE_NOISE_CONTROL_MODES,
-                    onClick = {
-                        viewModel.setLongPressAction(name, StemAction.CYCLE_NOISE_CONTROL_MODES)
-                    }
-                ),
-                SelectItem(
-                    name = stringResource(R.string.digital_assistant),
-                    selected = longPressAction == StemAction.DIGITAL_ASSISTANT,
-                    onClick = {
-                        viewModel.setLongPressAction(name, StemAction.DIGITAL_ASSISTANT)
-                    },
-                    enabled = state.isPremium
-                )
-            )
-            StyledSelectList(items = actionItems)
-
-            if (!state.isPremium) {
-                Spacer(modifier = Modifier.height(24.dp))
-                StyledButton(
-                    onClick = {
-                        navController.navigate("purchase_screen")
-                    },
-                    backdrop = rememberLayerBackdrop(),
-                    modifier = Modifier.fillMaxWidth(),
-                    maxScale = 0.05f,
-                    surfaceColor = if (isSystemInDarkTheme()) Color(0xFF916100) else Color(0xFFE59900)
-                ) {
-                    Text(
-                        stringResource(R.string.unlock_advanced_features),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = Color.White
-                        ),
-                    )
-                }
-                Spacer(modifier = Modifier.height(8.dp))
-            }
-
-            if (longPressAction == StemAction.CYCLE_NOISE_CONTROL_MODES) {
-                Spacer(modifier = Modifier.height(32.dp))
-                Text(
-                    text = stringResource(R.string.noise_control),
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                    modifier = Modifier
-                        .padding(horizontal = 18.dp)
-                )
-
-                Spacer(modifier = Modifier.height(8.dp))
-
-                val currentByte = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS]?.get(0)?.toInt() ?: 0
-
-                val listeningModeItems = mutableListOf<SelectItem>()
-                if (state.offListeningMode) {
-                    listeningModeItems.add(
-                        SelectItem(
-                            name = stringResource(R.string.off),
-                            description = stringResource(R.string.listening_mode_off_description),
-                            iconRes = R.drawable.noise_cancellation,
-                            selected = (currentByte and 0x01) != 0,
-                            onClick = {
-                                viewModel.toggleListeningMode(0x01)
-                            }
-                        )
-                    )
-                }
-                listeningModeItems.addAll(listOf(
-                    SelectItem(
-                        name = stringResource(R.string.transparency),
-                        description = stringResource(R.string.listening_mode_transparency_description),
-                        iconRes = R.drawable.transparency,
-                        selected = (currentByte and 0x04) != 0,
-                        onClick = {
-                            viewModel.toggleListeningMode(0x04)
-                        }
-                    ),
-                    SelectItem(
-                        name = stringResource(R.string.adaptive),
-                        description = stringResource(R.string.listening_mode_adaptive_description),
-                        iconRes = R.drawable.adaptive,
-                        selected = (currentByte and 0x08) != 0,
-                        onClick = {
-                            viewModel.toggleListeningMode(0x08)
-                        }
-                    ),
-                    SelectItem(
-                        name = stringResource(R.string.noise_cancellation),
-                        description = stringResource(R.string.listening_mode_noise_cancellation_description),
-                        iconRes = R.drawable.noise_cancellation,
-                        selected = (currentByte and 0x02) != 0,
-                        onClick = {
-                            viewModel.toggleListeningMode(0x02)
-                        }
-                    )
-                ))
-                StyledSelectList(items = listeningModeItems)
-                Spacer(modifier = Modifier.height(8.dp))
-                Text(
-                    text = stringResource(R.string.press_and_hold_noise_control_description),
-                    style = TextStyle(
-                        fontSize = 12.sp,
-                        fontWeight = FontWeight.Light,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier
-                        .padding(horizontal = 18.dp)
-                )
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/PurchaseScreen.kt

@@ -1,528 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.lifecycle.viewmodel.compose.viewModel
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.hazeSource
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.StyledButton
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.viewmodel.PurchaseViewModel
-import me.kavishdevar.librepods.utils.XposedState
-
-@Composable
-fun PurchaseScreen(
-    viewModel: PurchaseViewModel = viewModel(),
-    navController: NavController
-) {
-    val context = LocalContext.current
-    val scrollState = rememberScrollState()
-    val state by viewModel.uiState.collectAsState()
-
-    val backdrop = rememberLayerBackdrop()
-
-    StyledScaffold(
-        title = stringResource(R.string.unlock_advanced_features)
-    ) { topPadding, hazeState, bottomPadding ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .layerBackdrop(backdrop)
-                .hazeSource(state = hazeState)
-                .verticalScroll(scrollState)
-                .padding(horizontal = 16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(topPadding))
-
-            val isDarkTheme = isSystemInDarkTheme()
-            val backgroundColor = if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7)
-            val cardBackgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-            val textColor = if (isDarkTheme) Color.White else Color.Black
-            LaunchedEffect(state.isPremium) {
-                if (state.isPremium) {
-                    navController.popBackStack()
-                }
-            }
-            if (!state.isPremium) {
-                Box(
-                    modifier = Modifier
-                        .background(backgroundColor)
-                        .padding(horizontal = 16.dp, vertical = 4.dp)
-                ) {
-                    Text(
-                        text = stringResource(R.string.free_features),
-                        style = TextStyle(
-                            fontSize = 14.sp,
-                            fontWeight = FontWeight.Bold,
-                            color = textColor.copy(alpha = 0.6f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(cardBackgroundColor, RoundedCornerShape(28.dp))
-                        .padding(horizontal = 8.dp, vertical = 16.dp),
-                    verticalArrangement = Arrangement.spacedBy(8.dp)
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.ear_detection),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.ear_detection_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.battery),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.battery_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.noise_control),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.noise_control_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    if (XposedState.isAvailable) {
-                        HorizontalDivider(
-                            thickness = 1.dp,
-                            color = Color(0x40888888),
-                            modifier = Modifier
-                                .padding(horizontal = 12.dp)
-                        )
-                        Column(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(horizontal = 12.dp, vertical = 4.dp),
-                            verticalArrangement = Arrangement.spacedBy(2.dp)
-                        ) {
-                            Text(
-                                text = stringResource(R.string.hearing_aid) + " (" + stringResource(
-                                    R.string.requires_xposed
-                                ) + ")",
-                                style = TextStyle(
-                                    fontSize = 16.sp,
-                                    fontWeight = FontWeight.Normal,
-                                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                    color = textColor
-                                )
-                            )
-                            Text(
-                                text = stringResource(R.string.hearing_aid_description).split("\n\n")[0],
-                                style = TextStyle(
-                                    fontSize = 12.sp,
-                                    color = textColor.copy(0.6f),
-                                    fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                )
-                            )
-                        }
-                    }
-                }
-
-                Spacer(modifier = Modifier.height(24.dp))
-                Box(
-                    modifier = Modifier
-                        .background(backgroundColor)
-                        .padding(horizontal = 16.dp, vertical = 4.dp)
-                ) {
-                    Text(
-                        text = stringResource(R.string.advanced_features),
-                        style = TextStyle(
-                            fontSize = 14.sp,
-                            fontWeight = FontWeight.Bold,
-                            color = textColor.copy(alpha = 0.6f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .background(cardBackgroundColor, RoundedCornerShape(28.dp))
-                        .padding(horizontal = 8.dp, vertical = 16.dp),
-                    verticalArrangement = Arrangement.spacedBy(8.dp)
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.conversational_awareness),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.conversational_awareness_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.digital_assistant_on_long_press),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.digital_assistant_on_long_press_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.head_gestures),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.head_gestures_details),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.advanced_device_settings),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.advanced_device_settings_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.automatic_connection),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.automatic_connection_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.customizations),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.customizations_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                    HorizontalDivider(
-                        thickness = 1.dp,
-                        color = Color(0x40888888),
-                        modifier = Modifier
-                            .padding(horizontal = 12.dp)
-                    )
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(horizontal = 12.dp, vertical = 4.dp),
-                        verticalArrangement = Arrangement.spacedBy(2.dp)
-                    ) {
-                        Text(
-                            text = stringResource(R.string.support_the_development),
-                            style = TextStyle(
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Normal,
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                                color = textColor
-                            )
-                        )
-                        Text(
-                            text = stringResource(R.string.support_development_description),
-                            style = TextStyle(
-                                fontSize = 12.sp,
-                                color = textColor.copy(0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            )
-                        )
-                    }
-                }
-                Spacer(modifier = Modifier.height(8.dp))
-                Text(
-                    text = stringResource(R.string.feature_availability_disclaimer),
-                    modifier = Modifier.fillMaxWidth(),
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Light,
-                        fontFamily = FontFamily(Font(R.font.sf_pro)),
-                        color = textColor.copy(alpha = 0.6f),
-                        textAlign = TextAlign.Center
-                    ),
-                )
-
-
-                Spacer(modifier = Modifier.height(24.dp))
-
-                StyledButton(
-                    onClick = {
-                        viewModel.purchase(context)
-                    },
-                    backdrop = rememberLayerBackdrop(),
-                    modifier = Modifier.fillMaxWidth(),
-                    maxScale = 0.05f,
-                    surfaceColor = if (isSystemInDarkTheme()) Color(0xFF0091FF)
-                    else  Color(0xFF0088FF) // if (isSystemInDarkTheme()) Color(0xFF916100) else Color(0xFFE59900)
-                ) {
-                    Text(
-                        stringResource(R.string.buy_price, state.price),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = Color.White
-                        ),
-                    )
-                }
-
-                Spacer(modifier = Modifier.height(8.dp))
-
-                StyledButton(
-                    onClick = {
-                        viewModel.restorePurchases()
-                    },
-                    backdrop = rememberLayerBackdrop(),
-                    modifier = Modifier.fillMaxWidth(),
-                    maxScale = 0.05f,
-                    isInteractive = false
-                ) {
-                    Text(
-                        stringResource(R.string.restore_purchases),
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            fontWeight = FontWeight.Medium,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = textColor
-                        ),
-                    )
-                }
-            }
-            Spacer(modifier = Modifier.height(bottomPadding))
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/TroubleshootingScreen.kt

@@ -1,918 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import android.content.Intent
-import android.widget.Toast
-import androidx.activity.compose.rememberLauncherForActivityResult
-import androidx.activity.result.contract.ActivityResultContracts
-import androidx.compose.animation.AnimatedVisibility
-import androidx.compose.animation.core.animateFloatAsState
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.fadeIn
-import androidx.compose.animation.fadeOut
-import androidx.compose.animation.slideInVertically
-import androidx.compose.animation.slideOutVertically
-import androidx.compose.foundation.background
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.horizontalScroll
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.Delete
-import androidx.compose.material.icons.filled.Share
-import androidx.compose.material3.AlertDialog
-import androidx.compose.material3.Button
-import androidx.compose.material3.ButtonDefaults
-import androidx.compose.material3.CircularProgressIndicator
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.ModalBottomSheet
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextButton
-import androidx.compose.material3.rememberModalBottomSheetState
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.DisposableEffect
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.getValue
-import androidx.compose.runtime.mutableIntStateOf
-import androidx.compose.runtime.mutableStateListOf
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.runtime.rememberCoroutineScope
-import androidx.compose.runtime.setValue
-import androidx.compose.ui.Alignment
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.painterResource
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextOverflow
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.core.content.FileProvider
-import androidx.navigation.NavController
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import dev.chrisbanes.haze.hazeSource
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.withContext
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.utils.LogCollector
-import java.io.File
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-
-@Composable
-fun CustomIconButton(
-    onClick: () -> Unit,
-    content: @Composable () -> Unit
-) {
-    Box(
-        modifier = Modifier
-            .clickable(onClick = onClick)
-            .padding(8.dp),
-        contentAlignment = Alignment.Center
-    ) {
-        content()
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalHazeMaterialsApi::class)
-@Composable
-fun TroubleshootingScreen(navController: NavController) {
-    val context = LocalContext.current
-    val scrollState = rememberScrollState()
-    val coroutineScope = rememberCoroutineScope()
-
-    val logCollector = remember { LogCollector(context) }
-    val savedLogs = remember { mutableStateListOf<File>() }
-
-    var isCollectingLogs by remember { mutableStateOf(false) }
-    var showTroubleshootingSteps by remember { mutableStateOf(false) }
-    var currentStep by remember { mutableIntStateOf(0) }
-    var logContent by remember { mutableStateOf("") }
-    var selectedLogFile by remember { mutableStateOf<File?>(null) }
-    var showDeleteDialog by remember { mutableStateOf(false) }
-    var showDeleteAllDialog by remember { mutableStateOf(false) }
-    var isLoadingLogContent by remember { mutableStateOf(false) }
-    var logContentLoaded by remember { mutableStateOf(false) }
-
-    LaunchedEffect(isCollectingLogs) {
-        while (isCollectingLogs) {
-            delay(250)
-            delay(250)
-        }
-    }
-
-    val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = false)
-    var showBottomSheet by remember { mutableStateOf(false) }
-
-    val backgroundColor = if (isSystemInDarkTheme()) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val textColor = if (isSystemInDarkTheme()) Color.White else Color.Black
-    val accentColor = if (isSystemInDarkTheme()) Color(0xFF007AFF) else Color(0xFF3C6DF5)
-    val buttonBgColor = if (isSystemInDarkTheme()) Color(0xFF333333) else Color(0xFFDDDDDD)
-
-    var instructionText by remember { mutableStateOf("") }
-    val isDarkTheme = isSystemInDarkTheme()
-
-    LaunchedEffect(Unit) {
-        withContext(Dispatchers.IO) {
-            val logsDir = File(context.filesDir, "logs")
-            if (logsDir.exists()) {
-                savedLogs.clear()
-                savedLogs.addAll(logsDir.listFiles()?.filter { it.name.endsWith(".txt") }
-                    ?.sortedByDescending { it.lastModified() } ?: emptyList())
-            }
-        }
-    }
-
-    val saveLauncher = rememberLauncherForActivityResult(
-        contract = ActivityResultContracts.CreateDocument("text/plain")
-    ) { uri ->
-        if (uri != null) {
-            coroutineScope.launch(Dispatchers.IO) {
-                try {
-                    context.contentResolver.openOutputStream(uri)?.use { outputStream ->
-                        outputStream.write(logContent.toByteArray())
-                    }
-                    withContext(Dispatchers.Main) {
-                        Toast.makeText(context, "Log saved successfully", Toast.LENGTH_SHORT).show()
-                    }
-                } catch (e: Exception) {
-                    withContext(Dispatchers.Main) {
-                        Toast.makeText(
-                            context,
-                            "Failed to save log: ${e.localizedMessage}",
-                            Toast.LENGTH_SHORT
-                        ).show()
-                    }
-                }
-            }
-        }
-    }
-
-    LaunchedEffect(currentStep) {
-        instructionText = when (currentStep) {
-            0 -> "First, let's ensure Xposed module is properly configured. Tap the button below to check Xposed scope settings."
-            1 -> "Please put your AirPods in the case and close it, so they disconnect completely."
-            2 -> "Preparing to collect logs... Please wait."
-            3 -> "Now, open the AirPods case and connect your AirPods. Logs are being collected. Connection will be detected automatically, or you can manually stop logging when you're done."
-            4 -> "Log collection complete! You can now save or share the logs."
-            else -> ""
-        }
-    }
-
-    fun openLogBottomSheet(file: File) {
-        selectedLogFile = file
-        logContent = ""
-        isLoadingLogContent = false
-        logContentLoaded = false
-        showBottomSheet = true
-    }
-
-    val backdrop = rememberLayerBackdrop()
-
-    Box(
-        modifier = Modifier.fillMaxSize()
-    ) {
-        StyledScaffold(
-            title = stringResource(R.string.troubleshooting)
-        ){ topPadding, hazeState, bottomPadding ->
-            Column(
-                modifier = Modifier
-                    .fillMaxSize()
-                    .layerBackdrop(backdrop)
-                    .hazeSource(state = hazeState)
-                    .verticalScroll(scrollState)
-                    .padding(horizontal = 16.dp)
-            ) {
-                Spacer(modifier = Modifier.height(topPadding))
-
-                Text(
-                    text = stringResource(R.string.saved_logs),
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    ),
-                    modifier = Modifier.padding(16.dp, bottom = 4.dp, top = 8.dp)
-                )
-
-                Spacer(modifier = Modifier.height(2.dp))
-
-                if (savedLogs.isEmpty()) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .background(
-                                backgroundColor,
-                                RoundedCornerShape(28.dp)
-                            )
-                            .padding(16.dp),
-                        horizontalAlignment = Alignment.CenterHorizontally
-                    ) {
-                        Text(
-                            text = stringResource(R.string.no_logs_found),
-                            fontSize = 16.sp,
-                            color = textColor
-                        )
-                    }
-                } else {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .background(
-                                backgroundColor,
-                                RoundedCornerShape(28.dp)
-                            )
-                            .padding(horizontal = 16.dp, vertical = 8.dp)
-                    ) {
-                        Row(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(vertical = 8.dp),
-                            horizontalArrangement = Arrangement.SpaceBetween,
-                            verticalAlignment = Alignment.CenterVertically
-                        ) {
-                            Text(
-                                text = "Total Logs: ${savedLogs.size}",
-                                fontSize = 16.sp,
-                                fontWeight = FontWeight.Medium,
-                                color = textColor
-                            )
-
-                            if (savedLogs.size > 1) {
-                                TextButton(
-                                    onClick = { showDeleteAllDialog = true },
-                                    colors = ButtonDefaults.textButtonColors(
-                                        contentColor = MaterialTheme.colorScheme.error
-                                    )
-                                ) {
-                                    Text("Delete All")
-                                }
-                            }
-                        }
-
-                        savedLogs.forEach { logFile ->
-                            Row(
-                                modifier = Modifier
-                                    .fillMaxWidth()
-                                    .padding(vertical = 8.dp)
-                                    .clickable {
-                                        openLogBottomSheet(logFile)
-                                    },
-                                verticalAlignment = Alignment.CenterVertically
-                            ) {
-                                Column(modifier = Modifier.weight(1f)) {
-                                    Text(
-                                        text = logFile.name,
-                                        fontSize = 16.sp,
-                                        color = textColor,
-                                        maxLines = 1,
-                                        overflow = TextOverflow.Ellipsis
-                                    )
-
-                                    Text(
-                                        text = SimpleDateFormat("MMM dd, yyyy HH:mm", Locale.US)
-                                            .format(Date(logFile.lastModified())),
-                                        fontSize = 14.sp,
-                                        color = textColor.copy(alpha = 0.6f)
-                                    )
-                                }
-
-                                CustomIconButton(
-                                    onClick = {
-                                        selectedLogFile = logFile
-                                        showDeleteDialog = true
-                                    }
-                                ) {
-                                    Icon(
-                                        Icons.Default.Delete,
-                                        contentDescription = "Delete",
-                                        tint = MaterialTheme.colorScheme.error
-                                    )
-                                }
-                            }
-                        }
-                    }
-                }
-
-                Spacer(modifier = Modifier.height(16.dp))
-
-                AnimatedVisibility(
-                    visible = !showTroubleshootingSteps,
-                    enter = fadeIn(animationSpec = tween(300)),
-                    exit = fadeOut(animationSpec = tween(300))
-                ) {
-                    Button(
-                        onClick = { showTroubleshootingSteps = true },
-                        modifier = Modifier.fillMaxWidth(),
-                        shape = RoundedCornerShape(10.dp),
-                        colors = ButtonDefaults.buttonColors(
-                            containerColor = buttonBgColor,
-                            contentColor = textColor
-                        ),
-                        enabled = !isCollectingLogs
-                    ) {
-                        Text(stringResource(R.string.collect_logs))
-                    }
-                }
-
-                AnimatedVisibility(
-                    visible = showTroubleshootingSteps,
-                    enter = fadeIn(animationSpec = tween(300)) +
-                        slideInVertically(animationSpec = tween(300)) { it / 2 },
-                    exit = fadeOut(animationSpec = tween(300)) +
-                        slideOutVertically(animationSpec = tween(300)) { it / 2 }
-                ) {
-                    Column {
-                        Spacer(modifier = Modifier.height(16.dp))
-
-                        Text(
-                            text = stringResource(R.string.troubleshooting_steps),
-                            style = TextStyle(
-                                fontSize = 14.sp,
-                                fontWeight = FontWeight.Light,
-                                color = textColor.copy(alpha = 0.6f),
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            modifier = Modifier.padding(16.dp, bottom = 2.dp, top = 8.dp)
-                        )
-
-                        Spacer(modifier = Modifier.height(2.dp))
-
-                        Column(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .background(
-                                    backgroundColor,
-                                    RoundedCornerShape(28.dp)
-                                )
-                                .padding(16.dp)
-                        ) {
-                            val textAlpha = animateFloatAsState(
-                                targetValue = 1f,
-                                animationSpec = tween(durationMillis = 300),
-                                label = "textAlpha"
-                            )
-
-                            Text(
-                                text = instructionText,
-                                fontSize = 16.sp,
-                                color = textColor.copy(alpha = textAlpha.value),
-                                lineHeight = 22.sp
-                            )
-
-                            Spacer(modifier = Modifier.height(16.dp))
-
-                            when (currentStep) {
-                                0 -> {
-                                    Button(
-                                        onClick = {
-                                            coroutineScope.launch {
-                                                logCollector.openXposedSettings(context)
-                                                delay(2000)
-                                                currentStep = 1
-                                            }
-                                        },
-                                        modifier = Modifier.fillMaxWidth(),
-                                        shape = RoundedCornerShape(10.dp),
-                                        colors = ButtonDefaults.buttonColors(
-                                            containerColor = buttonBgColor,
-                                            contentColor = textColor
-                                        )
-                                    ) {
-                                        Text("Open Xposed Settings")
-                                    }
-                                }
-
-                                1 -> {
-                                    Button(
-                                        onClick = {
-                                            currentStep = 2
-                                            isCollectingLogs = true
-
-                                            coroutineScope.launch {
-                                                try {
-                                                    logCollector.clearLogs()
-
-                                                    logCollector.addLogMarker(LogCollector.LogMarkerType.START)
-
-                                                    logCollector.killBluetoothService()
-
-                                                    withContext(Dispatchers.Main) {
-                                                        delay(500)
-                                                        currentStep = 3
-                                                    }
-
-                                                    val timestamp = SimpleDateFormat(
-                                                        "yyyyMMdd_HHmmss",
-                                                        Locale.US
-                                                    ).format(Date())
-
-                                                    logContent =
-                                                        logCollector.startLogCollection(
-                                                            listener = { /* Removed live log display */ },
-                                                            connectionDetectedCallback = {
-                                                                launch {
-                                                                    delay(5000)
-                                                                    withContext(Dispatchers.Main) {
-                                                                        if (isCollectingLogs) {
-                                                                            logCollector.stopLogCollection()
-                                                                            currentStep = 4
-                                                                            isCollectingLogs =
-                                                                                false
-                                                                        }
-                                                                    }
-                                                                }
-                                                            }
-                                                        )
-
-                                                    val logFile =
-                                                        logCollector.saveLogToInternalStorage(
-                                                            "airpods_log_$timestamp.txt",
-                                                            logContent
-                                                        )
-                                                    logFile?.let {
-                                                        withContext(Dispatchers.Main) {
-                                                            savedLogs.add(0, it)
-                                                            selectedLogFile = it
-                                                            Toast.makeText(
-                                                                context,
-                                                                "Log saved: ${it.name}",
-                                                                Toast.LENGTH_SHORT
-                                                            ).show()
-                                                        }
-                                                    }
-                                                } catch (e: Exception) {
-                                                    withContext(Dispatchers.Main) {
-                                                        Toast.makeText(
-                                                            context,
-                                                            "Error collecting logs: ${e.message}",
-                                                            Toast.LENGTH_SHORT
-                                                        ).show()
-                                                        isCollectingLogs = false
-                                                        currentStep = 0
-                                                    }
-                                                }
-                                            }
-                                        },
-                                        modifier = Modifier.fillMaxWidth(),
-                                        shape = RoundedCornerShape(10.dp),
-                                        colors = ButtonDefaults.buttonColors(
-                                            containerColor = buttonBgColor,
-                                            contentColor = textColor
-                                        )
-                                    ) {
-                                        Text("Continue")
-                                    }
-                                }
-
-                                2, 3 -> {
-                                    Column(
-                                        modifier = Modifier.fillMaxWidth(),
-                                        horizontalAlignment = Alignment.CenterHorizontally
-                                    ) {
-                                        CircularProgressIndicator(
-                                            color = accentColor
-                                        )
-
-                                        Spacer(modifier = Modifier.height(8.dp))
-
-                                        Text(
-                                            text = if (currentStep == 2) "Preparing..." else "Collecting logs...",
-                                            fontSize = 14.sp,
-                                            color = textColor
-                                        )
-
-                                        if (currentStep == 3) {
-                                            Spacer(modifier = Modifier.height(16.dp))
-
-                                            Button(
-                                                onClick = {
-                                                    coroutineScope.launch {
-                                                        logCollector.addLogMarker(
-                                                            LogCollector.LogMarkerType.CUSTOM,
-                                                            "Manual stop requested by user"
-                                                        )
-                                                        delay(1000)
-                                                        logCollector.stopLogCollection()
-                                                        delay(500)
-
-                                                        withContext(Dispatchers.Main) {
-                                                            currentStep = 4
-                                                            isCollectingLogs = false
-                                                            Toast.makeText(
-                                                                context,
-                                                                "Log collection stopped",
-                                                                Toast.LENGTH_SHORT
-                                                            ).show()
-                                                        }
-                                                    }
-                                                },
-                                                shape = RoundedCornerShape(10.dp),
-                                                colors = ButtonDefaults.buttonColors(
-                                                    containerColor = buttonBgColor,
-                                                    contentColor = textColor
-                                                ),
-                                                modifier = Modifier
-                                                    .fillMaxWidth()
-                                            ) {
-                                                Text("Stop Collection")
-                                            }
-                                        }
-                                    }
-                                }
-
-                                4 -> {
-                                    Row(
-                                        modifier = Modifier.fillMaxWidth(),
-                                        horizontalArrangement = Arrangement.Center
-                                    ) {
-                                        Button(
-                                            onClick = {
-                                                selectedLogFile?.let { file ->
-                                                    val fileUri = FileProvider.getUriForFile(
-                                                        context,
-                                                        "${context.packageName}.provider",
-                                                        file
-                                                    )
-                                                    val shareIntent =
-                                                        Intent(Intent.ACTION_SEND).apply {
-                                                            type = "text/plain"
-                                                            putExtra(
-                                                                Intent.EXTRA_STREAM,
-                                                                fileUri
-                                                            )
-                                                            addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                                                        }
-                                                    context.startActivity(
-                                                        Intent.createChooser(
-                                                            shareIntent,
-                                                            "Share log file"
-                                                        )
-                                                    )
-                                                }
-                                            },
-                                            shape = RoundedCornerShape(10.dp),
-                                            colors = ButtonDefaults.buttonColors(
-                                                containerColor = buttonBgColor,
-                                                contentColor = textColor
-                                            ),
-                                            modifier = Modifier.width(150.dp)
-                                        ) {
-                                            Icon(
-                                                imageVector = Icons.Default.Share,
-                                                contentDescription = "Share"
-                                            )
-                                            Spacer(modifier = Modifier.width(8.dp))
-                                            Text("Share")
-                                        }
-
-                                        Spacer(modifier = Modifier.width(16.dp))
-
-                                        Button(
-                                            onClick = {
-                                                selectedLogFile?.let { file ->
-                                                    saveLauncher.launch(
-                                                        file.absolutePath
-                                                    )
-                                                }
-                                            },
-                                            shape = RoundedCornerShape(10.dp),
-                                            colors = ButtonDefaults.buttonColors(
-                                                containerColor = buttonBgColor,
-                                                contentColor = textColor
-                                            ),
-                                            modifier = Modifier.width(150.dp)
-                                        ) {
-                                            Icon(
-                                                painter = painterResource(id = R.drawable.ic_save),
-                                                contentDescription = "Save"
-                                            )
-                                            Spacer(modifier = Modifier.width(8.dp))
-                                            Text("Save")
-                                        }
-                                    }
-
-                                    Spacer(modifier = Modifier.height(16.dp))
-
-                                    Button(
-                                        onClick = {
-                                            currentStep = 0
-                                            showTroubleshootingSteps = false
-                                        },
-                                        modifier = Modifier.fillMaxWidth(),
-                                        shape = RoundedCornerShape(10.dp),
-                                        colors = ButtonDefaults.buttonColors(
-                                            containerColor = buttonBgColor,
-                                            contentColor = textColor
-                                        )
-                                    ) {
-                                        Text("Done")
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-
-                if (showDeleteDialog && selectedLogFile != null) {
-                    AlertDialog(
-                        onDismissRequest = { showDeleteDialog = false },
-                        title = { Text("Delete Log File") },
-                        text = {
-                            Text("Are you sure you want to delete this log file? This action cannot be undone.")
-                        },
-                        confirmButton = {
-                            TextButton(
-                                onClick = {
-                                    selectedLogFile?.let { file ->
-                                        if (file.delete()) {
-                                            savedLogs.remove(file)
-                                            Toast.makeText(
-                                                context,
-                                                "Log file deleted",
-                                                Toast.LENGTH_SHORT
-                                            )
-                                                .show()
-                                        } else {
-                                            Toast.makeText(
-                                                context,
-                                                "Failed to delete log file",
-                                                Toast.LENGTH_SHORT
-                                            ).show()
-                                        }
-                                    }
-                                    showDeleteDialog = false
-                                }
-                            ) {
-                                Text("Delete", color = MaterialTheme.colorScheme.error)
-                            }
-                        },
-                        dismissButton = {
-                            TextButton(onClick = { showDeleteDialog = false }) {
-                                Text("Cancel")
-                            }
-                        }
-                    )
-                }
-
-                if (showDeleteAllDialog) {
-                    AlertDialog(
-                        onDismissRequest = { showDeleteAllDialog = false },
-                        title = { Text("Delete All Logs") },
-                        text = {
-                            Text("Are you sure you want to delete all log files? This action cannot be undone and will remove ${savedLogs.size} log files.")
-                        },
-                        confirmButton = {
-                            TextButton(
-                                onClick = {
-                                    coroutineScope.launch(Dispatchers.IO) {
-                                        var deletedCount = 0
-                                        savedLogs.forEach { file ->
-                                            if (file.delete()) {
-                                                deletedCount++
-                                            }
-                                        }
-                                        withContext(Dispatchers.Main) {
-                                            if (deletedCount > 0) {
-                                                savedLogs.clear()
-                                                Toast.makeText(
-                                                    context,
-                                                    "Deleted $deletedCount log files",
-                                                    Toast.LENGTH_SHORT
-                                                ).show()
-                                            } else {
-                                                Toast.makeText(
-                                                    context,
-                                                    "Failed to delete log files",
-                                                    Toast.LENGTH_SHORT
-                                                ).show()
-                                            }
-                                        }
-                                    }
-                                    showDeleteAllDialog = false
-                                }
-                            ) {
-                                Text("Delete All", color = MaterialTheme.colorScheme.error)
-                            }
-                        },
-                        dismissButton = {
-                            TextButton(onClick = { showDeleteAllDialog = false }) {
-                                Text("Cancel")
-                            }
-                        }
-                    )
-                }
-            }
-        }
-
-        if (showBottomSheet) {
-            ModalBottomSheet(
-                onDismissRequest = { showBottomSheet = false },
-                sheetState = sheetState,
-                containerColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFF2F2F7),
-                shape = RoundedCornerShape(topStart = 28.dp, topEnd = 28.dp),
-                tonalElevation = 8.dp
-            ) {
-                LaunchedEffect(selectedLogFile) {
-                    if (!logContentLoaded) {
-                        delay(300)
-                        withContext(Dispatchers.IO) {
-                            isLoadingLogContent = true
-                            logContent = try {
-                                selectedLogFile?.readText() ?: ""
-                            } catch (e: Exception) {
-                                "Error loading log content: ${e.message}"
-                            }
-                            isLoadingLogContent = false
-                            logContentLoaded = true
-                        }
-                    }
-                }
-
-                Column(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(horizontal = 16.dp, vertical = 12.dp)
-                        .padding(bottom = 32.dp)
-                ) {
-                    Column(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(bottom = 12.dp),
-                    ) {
-                        Text(
-                            text = selectedLogFile?.name ?: "Log Content",
-                            style = TextStyle(
-                                fontWeight = FontWeight.Bold,
-                                fontSize = 20.sp,
-                                fontFamily = FontFamily(Font(R.font.sf_pro))
-                            ),
-                            color = textColor
-                        )
-                        Text(
-                            text = SimpleDateFormat("MMM dd, yyyy HH:mm", Locale.US)
-                                .format(Date(selectedLogFile?.lastModified() ?: 0)),
-                            fontSize = 14.sp,
-                            color = textColor.copy(alpha = 0.7f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    }
-
-                    if (isLoadingLogContent) {
-                        Box(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .height(300.dp),
-                            contentAlignment = Alignment.Center
-                        ) {
-                            CircularProgressIndicator(color = accentColor)
-                        }
-                    } else {
-                        Box(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .height(300.dp)
-                                .background(
-                                    color = Color.Black,
-                                    shape = RoundedCornerShape(8.dp)
-                                )
-                        ) {
-                            val horizontalScrollState = rememberScrollState()
-                            val verticalScrollState = rememberScrollState()
-
-                            Box(
-                                modifier = Modifier
-                                    .fillMaxSize()
-                                    .padding(8.dp)
-                                    .horizontalScroll(horizontalScrollState)
-                                    .verticalScroll(verticalScrollState)
-                            ) {
-                                Text(
-                                    text = logContent,
-                                    fontSize = 14.sp,
-                                    color = Color.LightGray,
-                                    lineHeight = 20.sp,
-                                    fontFamily = FontFamily.Monospace,
-                                    softWrap = false
-                                )
-                            }
-                        }
-                    }
-
-                    Row(
-                        modifier = Modifier
-                            .fillMaxWidth()
-                            .padding(top = 16.dp),
-                        horizontalArrangement = Arrangement.spacedBy(12.dp)
-                    ) {
-                        Button(
-                            onClick = {
-                                selectedLogFile?.let { file ->
-                                    val fileUri = FileProvider.getUriForFile(
-                                        context,
-                                        "${context.packageName}.provider",
-                                        file
-                                    )
-                                    val shareIntent = Intent(Intent.ACTION_SEND).apply {
-                                        type = "text/plain"
-                                        putExtra(Intent.EXTRA_STREAM, fileUri)
-                                        addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
-                                    }
-                                    context.startActivity(
-                                        Intent.createChooser(
-                                            shareIntent,
-                                            "Share log file"
-                                        )
-                                    )
-                                }
-                            },
-                            shape = RoundedCornerShape(10.dp),
-                            colors = ButtonDefaults.buttonColors(
-                                containerColor = buttonBgColor,
-                                contentColor = textColor
-                            ),
-                            modifier = Modifier.weight(1f)
-                        ) {
-                            Icon(
-                                imageVector = Icons.Default.Share,
-                                contentDescription = "Share"
-                            )
-                            Spacer(modifier = Modifier.width(8.dp))
-                            Text("Share")
-                        }
-
-                        Button(
-                            onClick = {
-                                selectedLogFile?.let { file ->
-                                    saveLauncher.launch(file.absolutePath)
-                                }
-                            },
-                            shape = RoundedCornerShape(10.dp),
-                            colors = ButtonDefaults.buttonColors(
-                                containerColor = buttonBgColor,
-                                contentColor = textColor
-                            ),
-                            modifier = Modifier.weight(1f)
-                        ) {
-                            Icon(
-                                painter = painterResource(id = R.drawable.ic_save),
-                                contentDescription = "Save"
-                            )
-                            Spacer(modifier = Modifier.width(8.dp))
-                            Text("Save")
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    DisposableEffect(Unit) {
-        onDispose {
-            logCollector.stopLogCollection()
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/screens/VersionInfoScreen.kt

@@ -1,180 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.screens
-
-import androidx.compose.foundation.background
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-import androidx.compose.foundation.layout.padding
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Text
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.collectAsState
-import androidx.compose.runtime.getValue
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.res.stringResource
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import com.kyant.backdrop.backdrops.layerBackdrop
-import com.kyant.backdrop.backdrops.rememberLayerBackdrop
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.presentation.components.StyledScaffold
-import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
-
-@Composable
-fun VersionScreen(viewModel: AirPodsViewModel) {
-    val state by viewModel.uiState.collectAsState()
-    val isDarkTheme = isSystemInDarkTheme()
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    val backdrop = rememberLayerBackdrop()
-
-    StyledScaffold(
-        title = stringResource(R.string.version)
-    ) { spacerHeight ->
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .layerBackdrop(backdrop)
-                .padding(horizontal = 16.dp)
-        ) {
-            Spacer(modifier = Modifier.height(spacerHeight))
-            Box(
-                modifier = Modifier
-                    .background(if (isDarkTheme) Color(0xFF000000) else Color(0xFFF2F2F7))
-                    .padding(horizontal = 16.dp, vertical = 4.dp)
-            ){
-                Text(
-                    text = stringResource(R.string.version),
-                    style = TextStyle(
-                        fontSize = 14.sp,
-                        fontWeight = FontWeight.Bold,
-                        color = textColor.copy(alpha = 0.6f),
-                        fontFamily = FontFamily(Font(R.font.sf_pro))
-                    )
-                )
-            }
-
-            Column(
-                modifier = Modifier
-                    .clip(RoundedCornerShape(28.dp))
-                    .fillMaxWidth()
-                    .background(backgroundColor, RoundedCornerShape(28.dp))
-                    .padding(top = 2.dp)
-            ) {
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(16.dp),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                ) {
-                    Text(
-                        text = stringResource(R.string.version) + " 1",
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor,
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                    Text(
-                        text = state.version1,
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor.copy(0.8f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-                HorizontalDivider(
-                    thickness = 1.dp,
-                    color = Color(0x40888888),
-                    modifier = Modifier
-                        .padding(horizontal = 12.dp)
-                )
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(16.dp),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                ) {
-                    Text(
-                        text = stringResource(R.string.version) + " 2",
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor,
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                    Text(
-                        text = state.version2,
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor.copy(0.8f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-                HorizontalDivider(
-                    thickness = 1.dp,
-                    color = Color(0x40888888),
-                    modifier = Modifier
-                        .padding(horizontal = 12.dp)
-                )
-                Row(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .padding(16.dp),
-                    horizontalArrangement = Arrangement.SpaceBetween,
-                ) {
-                    Text(
-                        text = stringResource(R.string.version) + " 3",
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor,
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                    Text(
-                        text = state.version3,
-                        style = TextStyle(
-                            fontSize = 16.sp,
-                            color = textColor.copy(0.8f),
-                            fontFamily = FontFamily(Font(R.font.sf_pro))
-                        )
-                    )
-                }
-            }
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/theme/Theme.kt

@@ -1,64 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.theme
-
-import android.os.Build
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.darkColorScheme
-import androidx.compose.material3.dynamicDarkColorScheme
-import androidx.compose.material3.dynamicLightColorScheme
-import androidx.compose.material3.lightColorScheme
-import androidx.compose.runtime.Composable
-import androidx.compose.ui.platform.LocalContext
-
-private val DarkColorScheme = darkColorScheme(
-    primary = Purple80,
-    secondary = PurpleGrey80,
-    tertiary = Pink80
-)
-
-private val LightColorScheme = lightColorScheme(
-    primary = Purple40,
-    secondary = PurpleGrey40,
-    tertiary = Pink40
-)
-
-@Composable
-fun LibrePodsTheme(
-    darkTheme: Boolean = isSystemInDarkTheme(),
-    dynamicColor: Boolean = true,
-    content: @Composable () -> Unit
-) {
-    val colorScheme = when {
-        dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
-            val context = LocalContext.current
-            if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
-        }
-
-        darkTheme -> DarkColorScheme
-        else -> LightColorScheme
-    }
-
-    MaterialTheme(
-        colorScheme = colorScheme,
-        typography = Typography,
-        content = content
-    )
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/theme/Type.kt

@@ -1,52 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.theme
-
-import androidx.compose.material3.Typography
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.sp
-
-// Set of Material typography styles to start with
-val Typography = Typography(
-    bodyLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 16.sp,
-        lineHeight = 24.sp,
-        letterSpacing = 0.5.sp
-    )
-    /* Other default text styles to override
-    titleLarge = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Normal,
-        fontSize = 22.sp,
-        lineHeight = 28.sp,
-        letterSpacing = 0.sp
-    ),
-    labelSmall = TextStyle(
-        fontFamily = FontFamily.Default,
-        fontWeight = FontWeight.Medium,
-        fontSize = 11.sp,
-        lineHeight = 16.sp,
-        letterSpacing = 0.5.sp
-    )
-    */
-)

android/app/src/main/java/me/kavishdevar/librepods/presentation/viewmodel/AirPodsViewModel.kt

@@ -1,694 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.presentation.viewmodel
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.SharedPreferences
-import android.content.pm.PackageManager
-import android.widget.Toast
-import androidx.core.content.edit
-import androidx.lifecycle.ViewModel
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableSharedFlow
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.BuildConfig
-import me.kavishdevar.librepods.billing.BillingManager
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.bluetooth.AACPManager.Companion.ControlCommandIdentifiers
-import me.kavishdevar.librepods.bluetooth.ATTCCCDHandles
-import me.kavishdevar.librepods.bluetooth.ATTHandles
-import me.kavishdevar.librepods.data.AirPodsInstance
-import me.kavishdevar.librepods.data.AirPodsModels
-import me.kavishdevar.librepods.data.AirPodsNotifications
-import me.kavishdevar.librepods.data.Battery
-import me.kavishdevar.librepods.data.BatteryComponent
-import me.kavishdevar.librepods.data.BatteryStatus
-import me.kavishdevar.librepods.data.Capability
-import me.kavishdevar.librepods.data.ControlCommandRepository
-import me.kavishdevar.librepods.data.StemAction
-import me.kavishdevar.librepods.data.XposedRemotePrefProvider
-import me.kavishdevar.librepods.services.AirPodsService
-
-@Suppress("ArrayInDataClass")
-data class AirPodsUiState(
-    val deviceName: String,
-
-    val isLocallyConnected: Boolean = false,
-
-    val instance: AirPodsInstance? = null,
-    val capabilities: Set<Capability> = emptySet(),
-
-    val controlStates: Map<ControlCommandIdentifiers, ByteArray> = emptyMap(),
-    val offListeningMode: Boolean = true,
-
-    val battery: List<Battery> = emptyList(),
-    val ancMode: Int = 3,
-
-    val modelName: String = "",
-    val actualModel: String = "",
-    val serialNumbers: List<String> = emptyList(),
-    val version1: String = "",
-    val version2: String = "",
-    val version3: String = "",
-
-    val headTrackingActive: Boolean = false,
-    val headGesturesEnabled: Boolean = true,
-
-    val eqData: FloatArray = floatArrayOf(),
-
-    val automaticEarDetectionEnabled: Boolean = true,
-    val automaticConnectionEnabled: Boolean = true,
-
-    val leftAction: StemAction = StemAction.CYCLE_NOISE_CONTROL_MODES,
-    val rightAction: StemAction = StemAction.CYCLE_NOISE_CONTROL_MODES,
-
-    val loudSoundReductionEnabled: Boolean = false,
-    val transparencyData: ByteArray = byteArrayOf(),
-    val hearingAidData: ByteArray = byteArrayOf(),
-
-    val isPremium: Boolean = false,
-    val vendorIdHook: Boolean = false,
-
-    val dynamicEndOfCharge: Boolean = false,
-
-    val connectionSuccessful: Boolean = false,
-    val timeUntilFOSSPremiumExpiry: Long = 0L
-)
-
-class AirPodsViewModel(
-    private val service: AirPodsService,
-    private val sharedPreferences: SharedPreferences,
-    private val controlRepo: ControlCommandRepository,
-    private val appContext: Context
-) : ViewModel() {
-    private val _uiState = MutableStateFlow(
-        AirPodsUiState(
-            deviceName = sharedPreferences.getString(
-                "name",
-                "AirPods Pro"
-            ) ?: "AirPods Pro"
-        )
-    )
-    val uiState: StateFlow<AirPodsUiState> = _uiState
-
-    private var isDemoMode = false
-    val demoActivated = MutableSharedFlow<Unit>()
-
-    private val listeners =
-        mutableMapOf<ControlCommandIdentifiers, AACPManager.ControlCommandListener>()
-
-    private val xposedRemotePref = XposedRemotePrefProvider.create()
-
-    private lateinit var broadcastReceiver: BroadcastReceiver
-
-    private val _cameraAction = MutableStateFlow(
-        sharedPreferences.getString("camera_action", null)
-            ?.let { value -> AACPManager.Companion.StemPressType.entries.find { it.name == value } })
-
-    val cameraAction: StateFlow<AACPManager.Companion.StemPressType?> = _cameraAction
-
-    fun setCameraAction(action: AACPManager.Companion.StemPressType?) {
-        sharedPreferences.edit {
-            if (action == null) remove("camera_action")
-            else putString("camera_action", action.name)
-        }
-        _cameraAction.value = action
-    }
-
-    init {
-        observeBroadcasts()
-        loadName()
-        loadInstance()
-        loadSharedPreferences()
-        setupControlObservers()
-        loadControlList()
-        loadATT()
-        observeATT()
-        observeSharedPreferences()
-        observeBilling()
-        if (isDemoMode) activateDemoMode()
-    }
-
-    override fun onCleared() {
-        listeners.forEach { (id, listener) ->
-            controlRepo.remove(id, listener)
-        }
-
-        appContext.unregisterReceiver(broadcastReceiver)
-
-        super.onCleared()
-    }
-
-    private fun loadName() {
-        val name = sharedPreferences.getString("name", "AirPods Pro")!!
-        _uiState.update { it.copy(deviceName = name) }
-    }
-
-    private fun observeBilling() {
-        if (isDemoMode) return
-        viewModelScope.launch {
-//            if (!BuildConfig.PLAY_BUILD) billingFirstCollectDone = true // FOSS doesn't send multiple events
-            BillingManager.provider.isPremium.collect { premium ->
-//                if (!billingFirstCollectDone) {
-//                    billingFirstCollectDone = true
-//                    return@collect
-//                }
-                if (premium) {
-                    sharedPreferences.edit {
-                        remove("premium_expiry_time")
-                        remove("foss_upgraded")
-                    }
-                    _uiState.update { it.copy(isPremium = true, timeUntilFOSSPremiumExpiry = 0L) }
-                } else {
-                    if (_uiState.value.timeUntilFOSSPremiumExpiry <= 0L) {
-                        setControlCommandBoolean(
-                            ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG,
-                            false
-                        )
-                        setHeadGesturesEnabled(false)
-                        _uiState.update { it.copy(isPremium = false) }
-                    }
-                }
-            }
-        }
-    }
-
-    private fun observeSharedPreferences() {
-        val listener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
-            when (key) {
-                "name" -> loadName()
-                "off_listening_mode", "automatic_ear_detection", "automatic_connection_ctrl_cmd",
-                "head_gestures", "left_long_press_action", "right_long_press_action",
-                "dynamic_end_of_charge", "foss_upgraded", "premium_expiry_time" -> loadSharedPreferences()
-            }
-        }
-        sharedPreferences.registerOnSharedPreferenceChangeListener(listener)
-    }
-
-    private fun observeBroadcasts() {
-        broadcastReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context?, intent: Intent?) {
-                val action = intent?.action ?: return
-                if (!isDemoMode) when (action) {
-                    AirPodsNotifications.AIRPODS_L2CAP_CONNECTED -> {
-                        _uiState.update {
-                            it.copy(isLocallyConnected = true)
-                        }
-                    }
-
-                    AirPodsNotifications.AIRPODS_DISCONNECTED -> {
-                        _uiState.update {
-                            it.copy(isLocallyConnected = false)
-                        }
-                    }
-
-                    AirPodsNotifications.BATTERY_DATA -> {
-                        _uiState.update {
-                            it.copy(battery = service.getBattery())
-                        }
-                    }
-
-                    AirPodsNotifications.EQ_DATA -> {
-                        val data = intent.getFloatArrayExtra("eqData") ?: floatArrayOf()
-
-                        _uiState.update {
-                            it.copy(eqData = data)
-                        }
-                    }
-
-                    AirPodsNotifications.AIRPODS_INFORMATION_UPDATED -> {
-                        loadInstance()
-                    }
-                }
-            }
-        }
-
-        val filter = IntentFilter().apply {
-            addAction(AirPodsNotifications.AIRPODS_CONNECTED)
-            addAction(AirPodsNotifications.AIRPODS_DISCONNECTED)
-            addAction(AirPodsNotifications.BATTERY_DATA)
-            addAction(AirPodsNotifications.EQ_DATA)
-            addAction(AirPodsNotifications.AIRPODS_INFORMATION_UPDATED)
-        }
-
-        appContext.registerReceiver(
-            broadcastReceiver, filter, Context.RECEIVER_NOT_EXPORTED
-        )
-    }
-
-    fun setControlCommandValue(
-        identifier: ControlCommandIdentifiers, value: ByteArray
-    ) {
-        if (!isDemoMode) controlRepo.setValue(identifier, value)
-        _uiState.update {
-            it.copy(
-                controlStates = it.controlStates + (identifier to value)
-            )
-        }
-    }
-
-    fun setControlCommandBoolean(
-        identifier: ControlCommandIdentifiers, enabled: Boolean
-    ) {
-        setControlCommandValue(
-            identifier, if (enabled) byteArrayOf(0x01) else byteArrayOf(0x02)
-        )
-    }
-
-    fun setControlCommandInt(
-        identifier: ControlCommandIdentifiers, value: Int
-    ) {
-        setControlCommandValue(identifier, byteArrayOf(value.toByte()))
-    }
-
-    fun setControlCommandByte(
-        identifier: ControlCommandIdentifiers, value: Byte
-    ) {
-        setControlCommandValue(identifier, byteArrayOf(value))
-    }
-
-    fun observeControl(identifier: ControlCommandIdentifiers) {
-        val listener = controlRepo.observe(identifier) { value ->
-            _uiState.update { state ->
-                val current = state.controlStates[identifier]
-                if (current?.contentEquals(value) == true) return@update state
-
-                if (identifier == ControlCommandIdentifiers.DYNAMIC_END_OF_CHARGE) {
-                    state.copy(
-                        dynamicEndOfCharge = value[0] == 0x01.toByte(),
-                        controlStates = state.controlStates + (identifier to value)
-                    )
-                } else {
-                    state.copy(
-                        controlStates = state.controlStates + (identifier to value)
-                    )
-                }
-            }
-        }
-
-        listeners[identifier] = listener
-    }
-
-    // I'm lazy, sorry.
-    fun setupControlObservers() {
-        val identifiersList = listOf(
-            ControlCommandIdentifiers.MIC_MODE,
-            ControlCommandIdentifiers.DOUBLE_CLICK_INTERVAL,
-            ControlCommandIdentifiers.CLICK_HOLD_INTERVAL,
-            ControlCommandIdentifiers.LISTENING_MODE_CONFIGS,
-            ControlCommandIdentifiers.ONE_BUD_ANC_MODE,
-            ControlCommandIdentifiers.LISTENING_MODE,
-            ControlCommandIdentifiers.AUTO_ANSWER_MODE,
-            ControlCommandIdentifiers.CHIME_VOLUME,
-            ControlCommandIdentifiers.VOLUME_SWIPE_INTERVAL,
-            ControlCommandIdentifiers.CALL_MANAGEMENT_CONFIG,
-            ControlCommandIdentifiers.VOLUME_SWIPE_MODE,
-            ControlCommandIdentifiers.ADAPTIVE_VOLUME_CONFIG,
-            ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG,
-            ControlCommandIdentifiers.HEARING_AID,
-            ControlCommandIdentifiers.AUTO_ANC_STRENGTH,
-            ControlCommandIdentifiers.HPS_GAIN_SWIPE,
-            ControlCommandIdentifiers.HEARING_ASSIST_CONFIG,
-            ControlCommandIdentifiers.ALLOW_OFF_OPTION,
-            ControlCommandIdentifiers.STEM_CONFIG,
-            ControlCommandIdentifiers.SLEEP_DETECTION_CONFIG,
-            ControlCommandIdentifiers.ALLOW_AUTO_CONNECT,
-            ControlCommandIdentifiers.EAR_DETECTION_CONFIG,
-            ControlCommandIdentifiers.AUTOMATIC_CONNECTION_CONFIG,
-            ControlCommandIdentifiers.OWNS_CONNECTION,
-            ControlCommandIdentifiers.PPE_TOGGLE_CONFIG,
-            ControlCommandIdentifiers.DYNAMIC_END_OF_CHARGE
-        )
-        for (identifier in identifiersList) {
-            observeControl(identifier)
-        }
-    }
-
-    fun refreshInitialData() {
-        if (isDemoMode) return
-        service.let { service ->
-            _uiState.update {
-                it.copy(
-                    isLocallyConnected = service.isConnected(), battery = service.getBattery()
-                )
-            }
-        }
-    }
-
-    private fun loadSharedPreferences() {
-        val offListeningModeEnabled = sharedPreferences.getBoolean("off_listening_mode", true)
-        val automaticEarDetectionEnabled =
-            sharedPreferences.getBoolean("automatic_ear_detection", true)
-        val automaticConnectionEnabled =
-            sharedPreferences.getBoolean("automatic_connection_ctrl_cmd", true)
-        val headGesturesEnabled = sharedPreferences.getBoolean("head_gestures", true)
-        val leftAction = StemAction.valueOf(
-            sharedPreferences.getString(
-                "left_long_press_action",
-                "CYCLE_NOISE_CONTROL_MODES"
-            ) ?: "CYCLE_NOISE_CONTROL_MODES"
-        )
-        val rightAction = StemAction.valueOf(
-            sharedPreferences.getString(
-                "right_long_press_action",
-                "CYCLE_NOISE_CONTROL_MODES"
-            ) ?: "CYCLE_NOISE_CONTROL_MODES"
-        )
-        val vendorIdHook = xposedRemotePref.getBoolean("vendor_id_hook", false)
-        val dynamicEndOfCharge = sharedPreferences.getBoolean("dynamic_end_of_charge", false)
-
-        val connectionSuccessful = sharedPreferences.getBoolean("connection_successful", false)
-
-        val fossUpgraded = sharedPreferences.getBoolean("foss_upgraded", false)
-        _uiState.update {
-            it.copy(
-                offListeningMode = offListeningModeEnabled,
-                automaticEarDetectionEnabled = automaticEarDetectionEnabled,
-                automaticConnectionEnabled = automaticConnectionEnabled,
-                headGesturesEnabled = headGesturesEnabled,
-                leftAction = leftAction,
-                rightAction = rightAction,
-                vendorIdHook = vendorIdHook,
-                dynamicEndOfCharge = dynamicEndOfCharge,
-                connectionSuccessful = connectionSuccessful,
-            )
-        }
-
-        // faulty update on Play caused PLAY_BUILD to be false and resulted in use of FOSS billing in Play. since FOSS is not verified, we need to give 2 weeks to verify the purchase
-
-        val expiryTime = sharedPreferences.getLong("premium_expiry_time", 0L)
-        val now = System.currentTimeMillis()
-
-        when {
-            // existing temporary premium
-            expiryTime > 0L -> {
-                if (expiryTime <= now) {
-                    sharedPreferences.edit {
-                        remove("premium_expiry_time")
-                        remove("foss_upgraded")
-                    }
-
-                    _uiState.update {
-                        it.copy(
-                            timeUntilFOSSPremiumExpiry = 0L,
-                            isPremium = false
-                        )
-                    }
-                } else {
-                    _uiState.update {
-                        it.copy(
-                            timeUntilFOSSPremiumExpiry = expiryTime - now,
-                            isPremium = true
-                        )
-                    }
-                }
-            }
-
-            // First migration from accidental FOSS Play build
-            fossUpgraded && !_uiState.value.isPremium && BuildConfig.PLAY_BUILD -> {
-                val newExpiry = now + 28L * 24 * 60 * 60 * 1000
-
-                sharedPreferences.edit {
-                    putLong("premium_expiry_time", newExpiry)
-                }
-
-                _uiState.update {
-                    it.copy(
-                        timeUntilFOSSPremiumExpiry = newExpiry - now,
-                        isPremium = true
-                    )
-                }
-            }
-        }
-    }
-
-    fun setOffListeningMode(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("off_listening_mode", enabled) }
-        setControlCommandBoolean(ControlCommandIdentifiers.ALLOW_OFF_OPTION, enabled)
-        _uiState.update {
-            it.copy(offListeningMode = enabled)
-        }
-    }
-
-    fun setHeadGesturesEnabled(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("head_gestures", enabled) }
-        _uiState.update {
-            it.copy(headGesturesEnabled = enabled)
-        }
-    }
-
-    fun setDynamicEndOfCharge(enabled: Boolean) {
-        service.aacpManager.sendControlCommand(ControlCommandIdentifiers.DYNAMIC_END_OF_CHARGE.value, enabled)
-        sharedPreferences.edit { putBoolean("dynamic_end_of_charge", enabled) }
-        _uiState.update {
-            it.copy(dynamicEndOfCharge = enabled)
-        }
-    }
-
-    private fun loadControlList() {
-        _uiState.update {
-            it.copy(
-                controlStates = controlRepo.getMap()
-            )
-        }
-    }
-
-    private fun loadInstance() {
-        val instance = service.airpodsInstance ?: AirPodsInstance(
-            name = "AirPods",
-            model = AirPodsModels.getModelByModelNumber("A3049")!!,
-            actualModelNumber = "A3049",
-            serialNumber = null,
-            leftSerialNumber = null,
-            rightSerialNumber = null,
-            version1 = null,
-            version2 = null,
-            version3 = null,
-        )
-
-        _uiState.update {
-            it.copy(
-                capabilities = instance.model.capabilities,
-                instance = instance,
-                modelName = instance.model.displayName,
-                actualModel = instance.actualModelNumber,
-                serialNumbers = listOf(
-                    instance.serialNumber ?: "",
-                    instance.leftSerialNumber ?: "",
-                    instance.rightSerialNumber ?: ""
-                ),
-                version1 = instance.version1 ?: "",
-                version2 = instance.version2 ?: "",
-                version3 = instance.version3 ?: ""
-            )
-        }
-    }
-
-    fun reconnectFromSavedMac() {
-        service.reconnectFromSavedMac()
-    }
-
-    fun setName(name: String) {
-        service.setName(name)
-    }
-
-    fun startHeadTracking() {
-        service.startHeadTracking()
-        _uiState.update { it.copy(headTrackingActive = true) }
-    }
-
-    fun stopHeadTracking() {
-        service.stopHeadTracking()
-        _uiState.update { it.copy(headTrackingActive = false) }
-    }
-
-    fun setATTCharacteristicValue(handle: ATTHandles, value: ByteArray) {
-        when (handle) {
-            // ideally should be using a different viewmodel for ATT based things because there are a lot of values, and I am not going to add all to this state, but there's loudsoundreduction.
-            ATTHandles.LOUD_SOUND_REDUCTION -> {
-                _uiState.value = _uiState.value.copy(loudSoundReductionEnabled = value[0].toInt() == 0x01)
-            }
-            ATTHandles.HEARING_AID -> {
-                _uiState.value = _uiState.value.copy(hearingAidData = value)
-            }
-            ATTHandles.TRANSPARENCY -> {
-                _uiState.value = _uiState.value.copy(transparencyData = value)
-            }
-        }
-        viewModelScope.launch(Dispatchers.IO) {
-            try {
-                service.attManager.writeCharacteristic(handle, value)
-            } catch (e: Exception) {
-                e.printStackTrace()
-            }
-        }
-    }
-
-    fun loadATT() {
-        val loudSoundReduction = service.attManager.getCharacteristic(ATTHandles.LOUD_SOUND_REDUCTION) ?: byteArrayOf()
-        val loudSoundReductionEnabled = if (loudSoundReduction.isNotEmpty()) {
-            loudSoundReduction[0].toInt() == 1
-        } else false
-        val hearingAidData = service.attManager.getCharacteristic(ATTHandles.HEARING_AID) ?: byteArrayOf()
-        val transparencyData = service.attManager.getCharacteristic(ATTHandles.TRANSPARENCY) ?: byteArrayOf()
-        _uiState.update {
-            it.copy(
-                loudSoundReductionEnabled = loudSoundReductionEnabled,
-                transparencyData = transparencyData,
-                hearingAidData = hearingAidData
-            )
-        }
-    }
-
-    fun observeATT() {
-        viewModelScope.launch(Dispatchers.IO) {
-            service.attManager.enableNotification(ATTCCCDHandles.HEARING_AID)
-            service.attManager.enableNotification(ATTCCCDHandles.TRANSPARENCY)
-//            service.attManager.enableNotification(ATTCCCDHandles.LOUD_SOUND_REDUCTION)
-        }
-        service.attManager.setOnNotificationReceived { handle, value ->
-            when (handle) {
-                ATTHandles.LOUD_SOUND_REDUCTION.value.toByte() -> {
-                    val loudSoundReductionEnabled = if (value.isNotEmpty()) {
-                        value[0].toInt() == 1
-                    } else false
-                    _uiState.update {
-                        it.copy(loudSoundReductionEnabled = loudSoundReductionEnabled)
-                    }
-                }
-                ATTHandles.HEARING_AID.value.toByte() -> {
-                    _uiState.update {
-                        it.copy(hearingAidData = value)
-                    }
-                }
-                ATTHandles.TRANSPARENCY.value.toByte() -> {
-                    _uiState.update {
-                        it.copy(transparencyData = value)
-                    }
-                }
-            }
-        }
-    }
-
-    fun setAutomaticEarDetectionEnabled(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("automatic_ear_detection", enabled) }
-        setControlCommandBoolean(ControlCommandIdentifiers.EAR_DETECTION_CONFIG, enabled)
-        _uiState.update {
-            it.copy(
-                automaticEarDetectionEnabled = enabled
-            )
-        }
-    }
-
-    fun setAutomaticConnectionEnabled(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("automatic_connection_ctrl_cmd", enabled) }
-        setControlCommandBoolean(ControlCommandIdentifiers.AUTOMATIC_CONNECTION_CONFIG, enabled)
-        _uiState.update {
-            it.copy(
-                automaticConnectionEnabled = enabled
-            )
-        }
-    }
-
-    fun activateDemoMode() {
-        isDemoMode = true
-        viewModelScope.launch {
-            demoActivated.emit(Unit)
-        }
-        val fakeInstance = AirPodsInstance(
-            name = "AirPods Pro (Demo)",
-            model = AirPodsModels.getModelByModelNumber("A3049")!!,
-            actualModelNumber = "A3049",
-            serialNumber = "DEMO123",
-            leftSerialNumber = "L-DEMO",
-            rightSerialNumber = "R-DEMO",
-            version1 = "1.0",
-            version2 = "1.0",
-            version3 = "1.0",
-        )
-
-        _uiState.update {
-            it.copy(
-                isLocallyConnected = true,
-                instance = fakeInstance,
-                capabilities = fakeInstance.model.capabilities,
-
-                battery = listOf(
-                    Battery(BatteryComponent.LEFT, 85, BatteryStatus.CHARGING),
-                    Battery(BatteryComponent.RIGHT, 25, BatteryStatus.NOT_CHARGING),
-                    Battery(BatteryComponent.CASE, 85, BatteryStatus.CHARGING),
-                ),
-
-                modelName = fakeInstance.model.displayName,
-                actualModel = fakeInstance.actualModelNumber,
-                serialNumbers = listOf("DEMO", "DEMO", "DEMO"),
-                version3 = "Demo Firmware",
-                isPremium = true
-            )
-        }
-    }
-
-    fun sendPhoneMediaEQ(eq: FloatArray, phoneByte: Byte, mediaByte: Byte) {
-        service.aacpManager.sendPhoneMediaEQ(eq, phoneByte, mediaByte)
-    }
-
-    fun setLongPressAction(side: String, action: StemAction) {
-        val prefKey = if (side.lowercase() == "left") "left_long_press_action" else "right_long_press_action"
-        sharedPreferences.edit { putString(prefKey, action.name) }
-        _uiState.update {
-            if (side.lowercase() == "left") it.copy(leftAction = action) else it.copy(rightAction = action)
-        }
-    }
-
-    private fun countEnabledModes(byteValue: Int): Int {
-        var count = 0
-        if ((byteValue and 0x01) != 0) count++
-        if ((byteValue and 0x02) != 0) count++
-        if ((byteValue and 0x04) != 0) count++
-        if ((byteValue and 0x08) != 0) count++
-        return count
-    }
-
-    fun toggleListeningMode(modeBit: Int) {
-        val currentByte = uiState.value.controlStates[ControlCommandIdentifiers.LISTENING_MODE_CONFIGS]?.get(0)?.toInt() ?: 0
-        val newValue = if ((currentByte and modeBit) != 0) {
-            val temp = currentByte and modeBit.inv()
-            if (countEnabledModes(temp) >= 2) temp else currentByte
-        } else {
-            currentByte or modeBit
-        }
-        setControlCommandByte(ControlCommandIdentifiers.LISTENING_MODE_CONFIGS, newValue.toByte())
-        sharedPreferences.edit { putInt("long_press_byte", newValue) }
-    }
-
-    fun disconnect() {
-        service.disconnectAirPods()
-        if (appContext.checkSelfPermission("android.permission.BLUETOOTH_PRIVILEGED") != PackageManager.PERMISSION_GRANTED) {
-            Toast.makeText(appContext, "App has disconnected, disconnect from Android Settings.",
-                Toast.LENGTH_LONG).show()
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/viewmodel/AppSettingsViewModel.kt

@@ -1,254 +0,0 @@
-package me.kavishdevar.librepods.presentation.viewmodel
-
-import android.app.Application
-import android.content.Context
-import android.content.SharedPreferences
-import androidx.core.content.edit
-import androidx.lifecycle.AndroidViewModel
-import androidx.lifecycle.viewModelScope
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlinx.coroutines.flow.update
-import kotlinx.coroutines.launch
-import me.kavishdevar.librepods.BuildConfig
-import me.kavishdevar.librepods.billing.BillingManager
-import me.kavishdevar.librepods.data.XposedRemotePrefProvider
-import kotlin.math.roundToInt
-
-data class AppSettingsUiState(
-    val showPhoneBatteryInWidget: Boolean = false,
-    val conversationalAwarenessPauseMusicEnabled: Boolean = false,
-    val relativeConversationalAwarenessVolumeEnabled: Boolean = true,
-    val disconnectWhenNotWearing: Boolean = false,
-    val takeoverWhenDisconnected: Boolean = false,
-    val takeoverWhenIdle: Boolean = false,
-    val takeoverWhenMusic: Boolean = false,
-    val takeoverWhenCall: Boolean = false,
-    val takeoverWhenRingingCall: Boolean = false,
-    val takeoverWhenMediaStart: Boolean = false,
-    val useAlternateHeadTrackingPackets: Boolean = true,
-    val conversationalAwarenessVolume: Float = 43f,
-    val showCameraDialog: Boolean = false,
-    val cameraPackageValue: String = "",
-    val cameraPackageError: String? = null,
-    val vendorIdHook: Boolean = false,
-    val isPremium: Boolean = false,
-    val connectionSuccessful: Boolean = false,
-    val showBottomSheetPopup: Boolean = true,
-    val showIslandPopup: Boolean = true,
-    val timeUntilFOSSPremiumExpiry: Long = 0L
-)
-
-class AppSettingsViewModel(application: Application) : AndroidViewModel(application) {
-    private val sharedPreferences = application.getSharedPreferences("settings", Context.MODE_PRIVATE)
-
-    private val _uiState = MutableStateFlow(AppSettingsUiState())
-    val uiState = _uiState.asStateFlow()
-
-    private val xposedRemotePref = XposedRemotePrefProvider.create()
-
-    val sharedPrefListener = SharedPreferences.OnSharedPreferenceChangeListener { sharedPref, key ->
-        if (key == "connection_successful") {
-            _uiState.update { it.copy(connectionSuccessful = sharedPref.getBoolean(key, false)) }
-        }
-    }
-
-
-    init {
-        loadSettings()
-        observeBilling()
-        sharedPreferences.registerOnSharedPreferenceChangeListener(sharedPrefListener)
-    }
-
-    override fun onCleared() {
-        sharedPreferences.unregisterOnSharedPreferenceChangeListener(sharedPrefListener)
-        super.onCleared()
-    }
-
-    private fun observeBilling() {
-        viewModelScope.launch {
-            BillingManager.provider.isPremium.collect { premium ->
-                if (premium) {
-                    sharedPreferences.edit {
-                        remove("premium_expiry_time")
-                        remove("foss_upgraded")
-                    }
-                    _uiState.update { it.copy(isPremium = true, timeUntilFOSSPremiumExpiry = 0L) }
-                } else {
-                    // No billing premium, only update if no temporary premium is active
-                    if (_uiState.value.timeUntilFOSSPremiumExpiry <= 0L) {
-                        _uiState.update { it.copy(isPremium = false) }
-                    }
-                }
-            }
-        }
-    }
-
-    private fun loadSettings() {
-        // faulty update on Play caused PLAY_BUILD to be false and resulted in use of FOSS billing in Play. since FOSS is not verified, we need to give 2 weeks to verify the purchase
-
-        val fossUpgraded = sharedPreferences.getBoolean("foss_upgraded", false)
-        val expiryTime = sharedPreferences.getLong("premium_expiry_time", 0L)
-        val now = System.currentTimeMillis()
-
-        when {
-            // existing temporary premium
-            expiryTime > 0L -> {
-                if (expiryTime <= now) {
-                    sharedPreferences.edit {
-                        remove("premium_expiry_time")
-                        remove("foss_upgraded")
-                    }
-
-                    _uiState.update {
-                        it.copy(
-                            timeUntilFOSSPremiumExpiry = 0L,
-                            isPremium = false
-                        )
-                    }
-                } else {
-                    _uiState.update {
-                        it.copy(
-                            timeUntilFOSSPremiumExpiry = expiryTime - now,
-                            isPremium = true
-                        )
-                    }
-                }
-            }
-
-            // First migration from accidental FOSS Play build
-            fossUpgraded && !_uiState.value.isPremium && BuildConfig.PLAY_BUILD -> {
-                val newExpiry = now + 28L * 24 * 60 * 60 * 1000
-
-                sharedPreferences.edit {
-                    putLong("premium_expiry_time", newExpiry)
-                }
-
-                _uiState.update {
-                    it.copy(
-                        timeUntilFOSSPremiumExpiry = newExpiry - now,
-                        isPremium = true
-                    )
-                }
-            }
-        }
-
-        _uiState.update { currentState ->
-            currentState.copy(
-                showPhoneBatteryInWidget = sharedPreferences.getBoolean("show_phone_battery_in_widget", false),
-                conversationalAwarenessPauseMusicEnabled = sharedPreferences.getBoolean("conversational_awareness_pause_music", false),
-                relativeConversationalAwarenessVolumeEnabled = sharedPreferences.getBoolean("relative_conversational_awareness_volume", true),
-                disconnectWhenNotWearing = sharedPreferences.getBoolean("disconnect_when_not_wearing", false),
-                takeoverWhenDisconnected = sharedPreferences.getBoolean("takeover_when_disconnected", false),
-                takeoverWhenIdle = sharedPreferences.getBoolean("takeover_when_idle", false),
-                takeoverWhenMusic = sharedPreferences.getBoolean("takeover_when_music", false),
-                takeoverWhenCall = sharedPreferences.getBoolean("takeover_when_call", false),
-                takeoverWhenRingingCall = sharedPreferences.getBoolean("takeover_when_ringing_call", false),
-                takeoverWhenMediaStart = sharedPreferences.getBoolean("takeover_when_media_start", false),
-                useAlternateHeadTrackingPackets = sharedPreferences.getBoolean("use_alternate_head_tracking_packets", true),
-                conversationalAwarenessVolume = sharedPreferences.getInt("conversational_awareness_volume", 43).toFloat(),
-                cameraPackageValue = sharedPreferences.getString("custom_camera_package", "") ?: "",
-                vendorIdHook = xposedRemotePref.getBoolean("vendor_id_hook", false),
-                connectionSuccessful = sharedPreferences.getBoolean("connection_successful", false),
-                showBottomSheetPopup = sharedPreferences.getBoolean("show_bottom_sheet_popup", true),
-                showIslandPopup = sharedPreferences.getBoolean("show_island_popup", true)
-            )
-        }
-    }
-
-    fun setShowPhoneBatteryInWidget(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("show_phone_battery_in_widget", enabled) }
-        _uiState.update { it.copy(showPhoneBatteryInWidget = enabled) }
-    }
-
-    fun setConversationalAwarenessPauseMusicEnabled(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("conversational_awareness_pause_music", enabled) }
-        _uiState.update { it.copy(conversationalAwarenessPauseMusicEnabled = enabled) }
-    }
-
-    fun setRelativeConversationalAwarenessVolumeEnabled(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("relative_conversational_awareness_volume", enabled) }
-        _uiState.update { it.copy(relativeConversationalAwarenessVolumeEnabled = enabled) }
-    }
-
-    fun setDisconnectWhenNotWearing(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("disconnect_when_not_wearing", enabled) }
-        _uiState.update { it.copy(disconnectWhenNotWearing = enabled) }
-    }
-
-    fun setTakeoverWhenDisconnected(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("takeover_when_disconnected", enabled) }
-        _uiState.update { it.copy(takeoverWhenDisconnected = enabled) }
-    }
-
-    fun setTakeoverWhenIdle(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("takeover_when_idle", enabled) }
-        _uiState.update { it.copy(takeoverWhenIdle = enabled) }
-    }
-
-    fun setTakeoverWhenMusic(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("takeover_when_music", enabled) }
-        _uiState.update { it.copy(takeoverWhenMusic = enabled) }
-    }
-
-    fun setTakeoverWhenCall(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("takeover_when_call", enabled) }
-        _uiState.update { it.copy(takeoverWhenCall = enabled) }
-    }
-
-    fun setTakeoverWhenRingingCall(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("takeover_when_ringing_call", enabled) }
-        _uiState.update { it.copy(takeoverWhenRingingCall = enabled) }
-    }
-
-    fun setTakeoverWhenMediaStart(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("takeover_when_media_start", enabled) }
-        _uiState.update { it.copy(takeoverWhenMediaStart = enabled) }
-    }
-
-    fun setUseAlternateHeadTrackingPackets(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("use_alternate_head_tracking_packets", enabled) }
-        _uiState.update { it.copy(useAlternateHeadTrackingPackets = enabled) }
-    }
-
-    fun setConversationalAwarenessVolume(volume: Float) {
-        sharedPreferences.edit { putInt("conversational_awareness_volume", volume.roundToInt()) }
-        _uiState.update { it.copy(conversationalAwarenessVolume = volume) }
-    }
-
-    fun setShowCameraDialog(show: Boolean) {
-        _uiState.update { it.copy(showCameraDialog = show) }
-    }
-
-    fun setCameraPackageValue(value: String) {
-        _uiState.update { it.copy(cameraPackageValue = value) }
-    }
-
-    fun setCameraPackageError(error: String?) {
-        _uiState.update { it.copy(cameraPackageError = error) }
-    }
-
-    fun saveCameraPackage() {
-        if (_uiState.value.cameraPackageValue.isBlank()) {
-            sharedPreferences.edit { remove("custom_camera_package") }
-        } else {
-            sharedPreferences.edit { putString("custom_camera_package", _uiState.value.cameraPackageValue) }
-        }
-        setShowCameraDialog(false)
-    }
-
-    fun setVendorIdHook(enabled: Boolean) {
-        xposedRemotePref.putBoolean("vendor_id_hook", enabled)
-        _uiState.update { it.copy(vendorIdHook = enabled) }
-    }
-
-    fun setShowBottomSheetPopup(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("show_bottom_sheet_popup", enabled) }
-        _uiState.update { it.copy(showBottomSheetPopup = enabled) }
-    }
-
-    fun setShowIslandPopup(enabled: Boolean) {
-        sharedPreferences.edit { putBoolean("show_island_popup", enabled) }
-        _uiState.update { it.copy(showIslandPopup = enabled) }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/presentation/widgets/NoiseControlWidget.kt

@@ -1,99 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.presentation.widgets
-
-import android.app.PendingIntent
-import android.appwidget.AppWidgetManager
-import android.appwidget.AppWidgetProvider
-import android.content.Context
-import android.content.Intent
-import android.util.Log
-import android.widget.RemoteViews
-import me.kavishdevar.librepods.R
-import me.kavishdevar.librepods.bluetooth.AACPManager
-import me.kavishdevar.librepods.services.ServiceManager
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-class NoiseControlWidget : AppWidgetProvider() {
-    override fun onUpdate(
-        context: Context,
-        appWidgetManager: AppWidgetManager,
-        appWidgetIds: IntArray
-    ) {
-        val views = RemoteViews(context.packageName, R.layout.noise_control_widget)
-
-        val offIntent = Intent(context, NoiseControlWidget::class.java).apply {
-            action = "ACTION_SET_ANC_MODE"
-            putExtra("ANC_MODE", 1)
-        }
-        val transparencyIntent = Intent(context, NoiseControlWidget::class.java).apply {
-            action = "ACTION_SET_ANC_MODE"
-            putExtra("ANC_MODE", 3)
-        }
-        val adaptiveIntent = Intent(context, NoiseControlWidget::class.java).apply {
-            action = "ACTION_SET_ANC_MODE"
-            putExtra("ANC_MODE", 4)
-        }
-        val ancIntent = Intent(context, NoiseControlWidget::class.java).apply {
-            action = "ACTION_SET_ANC_MODE"
-            putExtra("ANC_MODE", 2)
-        }
-
-        views.setOnClickPendingIntent(
-            R.id.widget_off_button,
-            PendingIntent.getBroadcast(context, 0, offIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        )
-        views.setOnClickPendingIntent(
-            R.id.widget_transparency_button,
-            PendingIntent.getBroadcast(context, 1, transparencyIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        )
-        views.setOnClickPendingIntent(
-            R.id.widget_adaptive_button,
-            PendingIntent.getBroadcast(context, 2, adaptiveIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        )
-        views.setOnClickPendingIntent(
-            R.id.widget_anc_button,
-            PendingIntent.getBroadcast(context, 3, ancIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-        )
-        ServiceManager.getService()?.updateNoiseControlWidget()
-        appWidgetManager.updateAppWidget(appWidgetIds, views)
-    }
-
-    override fun onReceive(context: Context, intent: Intent) {
-        super.onReceive(context, intent)
-        if (intent.action == "ACTION_SET_ANC_MODE") {
-            val mode = intent.getIntExtra("ANC_MODE", 1)
-            Log.d("NoiseControlWidget", "Setting ANC mode to $mode")
-            val service = ServiceManager.getService()
-
-            if (service == null) {
-                Log.w("NoiseControlWidget", "Service unavailable")
-                return
-            }
-
-             service.aacpManager
-                .sendControlCommand(
-                    AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE.value,
-                    mode.toByte()
-                )
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/utils/BluetoothCryptography.kt

@@ -1,76 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.utils
-
-import android.annotation.SuppressLint
-import javax.crypto.Cipher
-import javax.crypto.spec.SecretKeySpec
-
-/**
- * Utilities for Bluetooth cryptography operations, particularly for
- * verifying Resolvable Private Addresses (RPA) used by AirPods.
- */
-object BluetoothCryptography {
-
-    /**
-     * Verifies if the provided Bluetooth address is an RPA that matches the given Identity Resolving Key (IRK)
-     *
-     * @param addr The Bluetooth address to verify
-     * @param irk The Identity Resolving Key to use for verification
-     * @return true if the address is verified as an RPA matching the IRK
-     */
-    fun verifyRPA(addr: String, irk: ByteArray): Boolean {
-        val rpa = addr.split(":").map { it.toInt(16).toByte() }.reversed().toByteArray()
-        val prand = rpa.copyOfRange(3, 6)
-        val hash = rpa.copyOfRange(0, 3)
-        val computedHash = ah(irk, prand)
-        return hash.contentEquals(computedHash)
-    }
-
-    /**
-     * Performs E function (AES-128) as specified in Bluetooth Core Specification
-     *
-     * @param key The key for encryption
-     * @param data The data to encrypt
-     * @return The encrypted data
-     */
-    @SuppressLint("GetInstance")
-    fun e(key: ByteArray, data: ByteArray): ByteArray {
-        val swappedKey = key.reversedArray()
-        val swappedData = data.reversedArray()
-        val cipher = Cipher.getInstance("AES/ECB/NoPadding")
-        val secretKey = SecretKeySpec(swappedKey, "AES")
-        cipher.init(Cipher.ENCRYPT_MODE, secretKey)
-        return cipher.doFinal(swappedData).reversedArray()
-    }
-
-    /**
-     * Performs the ah function as specified in Bluetooth Core Specification
-     *
-     * @param k The IRK key
-     * @param r The random part of the address
-     * @return The hash part of the address
-     */
-    fun ah(k: ByteArray, r: ByteArray): ByteArray {
-        val rPadded = ByteArray(16)
-        r.copyInto(rPadded, 0, 0, 3)
-        val encrypted = e(k, rPadded)
-        return encrypted.copyOfRange(0, 3)
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/utils/HeadOrientation.kt

@@ -1,101 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-package me.kavishdevar.librepods.utils
-
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.asStateFlow
-import kotlin.math.roundToInt
-
-data class Orientation(val pitch: Float = 0f, val yaw: Float = 0f)
-data class Acceleration(val vertical: Float = 0f, val horizontal: Float = 0f)
-
-object HeadTracking {
-    private val _orientation = MutableStateFlow(Orientation())
-    val orientation = _orientation.asStateFlow()
-
-    private val _acceleration = MutableStateFlow(Acceleration())
-    val acceleration = _acceleration.asStateFlow()
-
-    private val calibrationSamples = mutableListOf<Triple<Int, Int, Int>>()
-    private var isCalibrated = false
-    private var o1Neutral = 19000
-    private var o2Neutral = 0
-    private var o3Neutral = 0
-
-    private const val CALIBRATION_SAMPLE_COUNT = 10
-    private const val ORIENTATION_OFFSET = 5500
-
-    fun processPacket(packet: ByteArray) {
-        val o1 = bytesToInt(packet[43], packet[44])
-        val o2 = bytesToInt(packet[45], packet[46])
-        val o3 = bytesToInt(packet[47], packet[48])
-
-        val horizontalAccel = bytesToInt(packet[51], packet[52]).toFloat()
-        val verticalAccel = bytesToInt(packet[53], packet[54]).toFloat()
-
-        if (!isCalibrated) {
-            calibrationSamples.add(Triple(o1, o2, o3))
-            if (calibrationSamples.size >= CALIBRATION_SAMPLE_COUNT) {
-                calibrate()
-            }
-            return
-        }
-
-        val orientation = calculateOrientation(o1, o2, o3)
-        _orientation.value = orientation
-
-        _acceleration.value = Acceleration(verticalAccel, horizontalAccel)
-    }
-
-    private fun calibrate() {
-        if (calibrationSamples.size < 3) return
-
-        // Add offset during calibration
-        o1Neutral = calibrationSamples.map { it.first + ORIENTATION_OFFSET }.average().roundToInt()
-        o2Neutral = calibrationSamples.map { it.second + ORIENTATION_OFFSET }.average().roundToInt()
-        o3Neutral = calibrationSamples.map { it.third + ORIENTATION_OFFSET }.average().roundToInt()
-
-        isCalibrated = true
-    }
-
-    @Suppress("UnusedVariable")
-    private fun calculateOrientation(o1: Int, o2: Int, o3: Int): Orientation {
-        if (!isCalibrated) return Orientation()
-
-        val o1Norm = (o1 + ORIENTATION_OFFSET) - o1Neutral
-        val o2Norm = (o2 + ORIENTATION_OFFSET) - o2Neutral
-        val o3Norm = (o3 + ORIENTATION_OFFSET) - o3Neutral
-
-        val pitch = (o2Norm + o3Norm) / 2f / 32000f * 180f
-        val yaw = (o2Norm - o3Norm) / 2f / 32000f * 180f
-
-        return Orientation(pitch, yaw)
-    }
-
-    private fun bytesToInt(b1: Byte, b2: Byte): Int {
-        return (b2.toInt() shl 8) or (b1.toInt() and 0xFF)
-    }
-
-    fun reset() {
-        calibrationSamples.clear()
-        isCalibrated = false
-        _orientation.value = Orientation()
-        _acceleration.value = Acceleration()
-    }
-}

android/app/src/main/java/me/kavishdevar/librepods/utils/RadareOffsetFinder.kt

@@ -1,761 +0,0 @@
-/*
-    LibrePods - AirPods liberated from Apple’s ecosystem
-    Copyright (C) 2025 LibrePods contributors
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-*/
-
-@file:OptIn(ExperimentalEncodingApi::class)
-
-package me.kavishdevar.librepods.utils
-
-import android.content.Context
-import android.util.Log
-import androidx.compose.runtime.NoLiveLiterals
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.flow.MutableStateFlow
-import kotlinx.coroutines.flow.StateFlow
-import kotlinx.coroutines.withContext
-import me.kavishdevar.librepods.services.ServiceManager
-import java.io.BufferedReader
-import java.io.File
-import java.io.FileOutputStream
-import java.io.InputStreamReader
-import java.net.HttpURLConnection
-import java.net.URL
-import kotlin.io.encoding.ExperimentalEncodingApi
-
-@NoLiveLiterals
-class RadareOffsetFinder(context: Context) {
-    companion object {
-        private const val TAG = "RadareOffsetFinder"
-        private const val RADARE2_URL = "https://github.com/devnoname120/radare2/releases/download/5.9.8-android-aln/radare2-5.9.9-android-aarch64-aln.tar.gz"
-        private const val HOOK_OFFSET_PROP = "persist.librepods.hook_offset"
-        private const val CFG_REQ_OFFSET_PROP = "persist.librepods.cfg_req_offset"
-        private const val CSM_CONFIG_OFFSET_PROP = "persist.librepods.csm_config_offset"
-        private const val PEER_INFO_REQ_OFFSET_PROP = "persist.librepods.peer_info_req_offset"
-        private const val SDP_OFFSET_PROP = "persist.librepods.sdp_offset"
-        private const val EXTRACT_DIR = "/"
-
-        private const val RADARE2_BIN_PATH = "$EXTRACT_DIR/data/local/tmp/aln_unzip/org.radare.radare2installer/radare2/bin"
-        private const val RADARE2_LIB_PATH = "$EXTRACT_DIR/data/local/tmp/aln_unzip/org.radare.radare2installer/radare2/lib"
-        private const val BUSYBOX_PATH = "$EXTRACT_DIR/data/local/tmp/aln_unzip/busybox"
-
-        private val LIBRARY_PATHS = listOf(
-            "/apex/com.android.bt/lib64/libbluetooth_jni.so",
-            "/apex/com.android.btservices/lib64/libbluetooth_jni.so",
-            "/system/lib64/libbluetooth_jni.so",
-            "/system/lib64/libbluetooth_qti.so",
-            "/system_ext/lib64/libbluetooth_qti.so"
-        )
-
-        fun findBluetoothLibraryPath(): String? {
-            for (path in LIBRARY_PATHS) {
-                if (File(path).exists()) {
-                    Log.d(TAG, "Found Bluetooth library at $path")
-                    return path
-                }
-            }
-            Log.e(TAG, "Could not find Bluetooth library")
-            return null
-        }
-
-        fun clearHookOffsets(): Boolean {
-            try {
-                val process = Runtime.getRuntime().exec(arrayOf(
-                    "su", "-c",
-                    "/system/bin/setprop $HOOK_OFFSET_PROP '' && " +
-                    "/system/bin/setprop $CFG_REQ_OFFSET_PROP '' && " +
-                    "/system/bin/setprop $CSM_CONFIG_OFFSET_PROP '' && " +
-                    "/system/bin/setprop $PEER_INFO_REQ_OFFSET_PROP '' &&" +
-                    "/system/bin/setprop $SDP_OFFSET_PROP ''"
-                ))
-                val exitCode = process.waitFor()
-
-                if (exitCode == 0) {
-                    Log.d(TAG, "Successfully cleared hook offset properties")
-                    return true
-                } else {
-                    Log.e(TAG, "Failed to clear hook offset properties, exit code: $exitCode")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Error clearing hook offset properties", e)
-            }
-            return false
-        }
-
-        fun clearSdpOffset(): Boolean {
-            try {
-                val process = Runtime.getRuntime().exec(arrayOf(
-                    "su", "-c", "/system/bin/setprop $SDP_OFFSET_PROP ''"
-                ))
-                val exitCode = process.waitFor()
-
-                if (exitCode == 0) {
-                    Log.d(TAG, "Successfully cleared SDP offset property")
-                    return true
-                } else {
-                    Log.e(TAG, "Failed to clear SDP offset property, exit code: $exitCode")
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Error clearing SDP offset property", e)
-            }
-            return false
-        }
-
-        fun isSdpOffsetAvailable(): Boolean {
-            val sharedPreferences = ServiceManager.getService()?.applicationContext?.getSharedPreferences("settings", Context.MODE_PRIVATE) // ik not good practice- too lazy
-            if (sharedPreferences?.getBoolean("skip_setup", false) == true) {
-                Log.d(TAG, "Setup skipped, returning true for SDP offset.")
-                return true
-            }
-            try {
-                val process = Runtime.getRuntime().exec(arrayOf("/system/bin/getprop", SDP_OFFSET_PROP))
-                val reader = BufferedReader(InputStreamReader(process.inputStream))
-                val propValue = reader.readLine()
-                process.waitFor()
-
-                if (propValue != null && propValue.isNotEmpty()) {
-                    Log.d(TAG, "SDP offset property exists: $propValue")
-                    return true
-                }
-            } catch (e: Exception) {
-                Log.e(TAG, "Error checking if SDP offset property exists", e)
-            }
-
-            Log.d(TAG, "No SDP offset available")
-            return false
-        }
-    }
-
-    private val radare2TarballFile = File(context.cacheDir, "radare2.tar.gz")
-
-    private val _progressState = MutableStateFlow<ProgressState>(ProgressState.Idle)
-    val progressState: StateFlow<ProgressState> = _progressState
-
-    sealed class ProgressState {
-        object Idle : ProgressState()
-        object CheckingExisting : ProgressState()
-        object Downloading : ProgressState()
-        data class DownloadProgress(val progress: Float) : ProgressState()
-        object Extracting : ProgressState()
-        object MakingExecutable : ProgressState()
-        object FindingOffset : ProgressState()
-        object SavingOffset : ProgressState()
-        object Cleaning : ProgressState()
-        data class Error(val message: String) : ProgressState()
-        data class Success(val offset: Long) : ProgressState()
-    }
-
-
-    fun isHookOffsetAvailable(): Boolean {
-        Log.d(TAG, "Setup Skipped? " + ServiceManager.getService()?.applicationContext?.getSharedPreferences("settings", Context.MODE_PRIVATE)?.getBoolean("skip_setup", false).toString())
-        if (ServiceManager.getService()?.applicationContext?.getSharedPreferences("settings", Context.MODE_PRIVATE)?.getBoolean("skip_setup", false) == true) {
-            Log.d(TAG, "Setup skipped, returning true.")
-            return true
-        }
-        _progressState.value = ProgressState.CheckingExisting
-        try {
-            val process = Runtime.getRuntime().exec(arrayOf("/system/bin/getprop", HOOK_OFFSET_PROP))
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val propValue = reader.readLine()
-            process.waitFor()
-
-            if (propValue != null && propValue.isNotEmpty()) {
-                Log.d(TAG, "Hook offset property exists: $propValue")
-                _progressState.value = ProgressState.Idle
-                return true
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error checking if offset property exists", e)
-            _progressState.value = ProgressState.Error("Failed to check if offset property exists: ${e.message}")
-        }
-
-        Log.d(TAG, "No hook offset available")
-        _progressState.value = ProgressState.Idle
-        return false
-    }
-
-    suspend fun setupAndFindOffset(): Boolean {
-        val offset = findOffset()
-        return offset > 0
-    }
-
-    suspend fun findOffset(): Long = withContext(Dispatchers.IO) {
-        try {
-            _progressState.value = ProgressState.Downloading
-            if (!downloadRadare2TarballIfNeeded()) {
-                _progressState.value = ProgressState.Error("Failed to download radare2 tarball")
-                Log.e(TAG, "Failed to download radare2 tarball")
-                return@withContext 0L
-            }
-
-            _progressState.value = ProgressState.Extracting
-            if (!extractRadare2Tarball()) {
-                _progressState.value = ProgressState.Error("Failed to extract radare2 tarball")
-                Log.e(TAG, "Failed to extract radare2 tarball")
-                return@withContext 0L
-            }
-
-            _progressState.value = ProgressState.MakingExecutable
-            if (!makeExecutable()) {
-                _progressState.value = ProgressState.Error("Failed to make binaries executable")
-                Log.e(TAG, "Failed to make binaries executable")
-                return@withContext 0L
-            }
-
-            _progressState.value = ProgressState.FindingOffset
-            val offset = findFunctionOffset()
-            if (offset == 0L) {
-                _progressState.value = ProgressState.Error("Failed to find function offset")
-                Log.e(TAG, "Failed to find function offset")
-                return@withContext 0L
-            }
-
-            _progressState.value = ProgressState.SavingOffset
-            if (!saveOffset(offset)) {
-                _progressState.value = ProgressState.Error("Failed to save offset")
-                Log.e(TAG, "Failed to save offset")
-                return@withContext 0L
-            }
-
-            _progressState.value = ProgressState.Cleaning
-            cleanupExtractedFiles()
-
-            _progressState.value = ProgressState.Success(offset)
-            return@withContext offset
-
-        } catch (e: Exception) {
-            _progressState.value = ProgressState.Error("Error: ${e.message}")
-            Log.e(TAG, "Error in findOffset", e)
-            return@withContext 0L
-        }
-    }
-
-    private suspend fun downloadRadare2TarballIfNeeded(): Boolean = withContext(Dispatchers.IO) {
-        if (radare2TarballFile.exists() && radare2TarballFile.length() > 0) {
-            Log.d(TAG, "Radare2 tarball already downloaded to ${radare2TarballFile.absolutePath}")
-            return@withContext true
-        }
-
-        try {
-            val url = URL(RADARE2_URL)
-            val connection = url.openConnection() as HttpURLConnection
-            connection.connectTimeout = 60000
-            connection.readTimeout = 60000
-
-            val contentLength = connection.contentLength.toFloat()
-            val inputStream = connection.inputStream
-            val outputStream = FileOutputStream(radare2TarballFile)
-
-            val buffer = ByteArray(4096)
-            var bytesRead: Int
-            var totalBytesRead = 0L
-
-            while (inputStream.read(buffer).also { bytesRead = it } != -1) {
-                outputStream.write(buffer, 0, bytesRead)
-                totalBytesRead += bytesRead
-                if (contentLength > 0) {
-                    val progress = totalBytesRead.toFloat() / contentLength
-                    _progressState.value = ProgressState.DownloadProgress(progress)
-                }
-            }
-
-            outputStream.close()
-            inputStream.close()
-
-            Log.d(TAG, "Download successful to ${radare2TarballFile.absolutePath}")
-            return@withContext true
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to download radare2 tarball", e)
-            return@withContext false
-        }
-    }
-
-    private suspend fun extractRadare2Tarball(): Boolean = withContext(Dispatchers.IO) {
-        try {
-            val isAlreadyExtracted = checkIfAlreadyExtracted()
-
-            if (isAlreadyExtracted) {
-                Log.d(TAG, "Radare2 files already extracted correctly, skipping extraction")
-                return@withContext true
-            }
-
-            Log.d(TAG, "Removing existing extract directory")
-            Runtime.getRuntime().exec(arrayOf("su", "-c", "rm -rf $EXTRACT_DIR/data/local/tmp/aln_unzip")).waitFor()
-
-            Runtime.getRuntime().exec(arrayOf("su", "-c", "mkdir -p $EXTRACT_DIR/data/local/tmp/aln_unzip")).waitFor()
-
-            Log.d(TAG, "Extracting ${radare2TarballFile.absolutePath} to $EXTRACT_DIR")
-
-            val process = Runtime.getRuntime().exec(
-                arrayOf("su", "-c", "tar xvf ${radare2TarballFile.absolutePath} -C $EXTRACT_DIR")
-            )
-
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
-
-            var line: String?
-            while (reader.readLine().also { line = it } != null) {
-                Log.d(TAG, "Extract output: $line")
-            }
-
-            while (errorReader.readLine().also { line = it } != null) {
-                Log.e(TAG, "Extract error: $line")
-            }
-
-            val exitCode = process.waitFor()
-            if (exitCode == 0) {
-                Log.d(TAG, "Extraction completed successfully")
-                return@withContext true
-            } else {
-                Log.e(TAG, "Extraction failed with exit code $exitCode")
-                return@withContext false
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to extract radare2", e)
-            return@withContext false
-        }
-    }
-
-    private suspend fun checkIfAlreadyExtracted(): Boolean = withContext(Dispatchers.IO) {
-        try {
-            val checkDirProcess = Runtime.getRuntime().exec(
-                arrayOf("su", "-c", "[ -d $EXTRACT_DIR/data/local/tmp/aln_unzip ] && echo 'exists'")
-            )
-            val dirExists = BufferedReader(InputStreamReader(checkDirProcess.inputStream)).readLine() == "exists"
-            checkDirProcess.waitFor()
-
-            if (!dirExists) {
-                Log.d(TAG, "Extract directory doesn't exist, need to extract")
-                return@withContext false
-            }
-
-            val tarProcess = Runtime.getRuntime().exec(
-                arrayOf("su", "-c", "tar tf ${radare2TarballFile.absolutePath}")
-            )
-            val tarFiles = BufferedReader(InputStreamReader(tarProcess.inputStream)).readLines()
-                .filter { it.isNotEmpty() }
-                .map { it.trim() }
-                .toSet()
-            tarProcess.waitFor()
-
-            if (tarFiles.isEmpty()) {
-                Log.e(TAG, "Failed to get file list from tarball")
-                return@withContext false
-            }
-
-            val findProcess = Runtime.getRuntime().exec(
-                arrayOf("su", "-c", "find $EXTRACT_DIR/data/local/tmp/aln_unzip -type f | sort")
-            )
-            val extractedFiles = BufferedReader(InputStreamReader(findProcess.inputStream)).readLines()
-                .filter { it.isNotEmpty() }
-                .map { it.trim() }
-                .toSet()
-            findProcess.waitFor()
-
-            if (extractedFiles.isEmpty()) {
-                Log.d(TAG, "No files found in extract directory, need to extract")
-                return@withContext false
-            }
-
-            for (tarFile in tarFiles) {
-                if (tarFile.endsWith("/")) continue
-
-                val filePathInExtractDir = "$EXTRACT_DIR/$tarFile"
-                val fileCheckProcess = Runtime.getRuntime().exec(
-                    arrayOf("su", "-c", "[ -f $filePathInExtractDir ] && echo 'exists'")
-                )
-                val fileExists = BufferedReader(InputStreamReader(fileCheckProcess.inputStream)).readLine() == "exists"
-                fileCheckProcess.waitFor()
-
-                if (!fileExists) {
-                    Log.d(TAG, "File $filePathInExtractDir from tarball missing in extract directory")
-                    Runtime.getRuntime().exec(arrayOf("su", "-c", "rm -rf $EXTRACT_DIR/data/local/tmp/aln_unzip")).waitFor()
-                    return@withContext false
-                }
-            }
-
-            Log.d(TAG, "All ${tarFiles.size} files from tarball exist in extract directory")
-            return@withContext true
-        } catch (e: Exception) {
-            Log.e(TAG, "Error checking extraction status", e)
-            return@withContext false
-        }
-    }
-
-    private suspend fun makeExecutable(): Boolean = withContext(Dispatchers.IO) {
-        try {
-            Log.d(TAG, "Making binaries executable in $RADARE2_BIN_PATH")
-            val chmod1Result = Runtime.getRuntime().exec(
-                arrayOf("su", "-c", "chmod -R 755 $RADARE2_BIN_PATH")
-            ).waitFor()
-
-            Log.d(TAG, "Making binaries executable in $BUSYBOX_PATH")
-
-            val chmod2Result = Runtime.getRuntime().exec(
-                arrayOf("su", "-c", "chmod -R 755 $BUSYBOX_PATH")
-            ).waitFor()
-
-            if (chmod1Result == 0 && chmod2Result == 0) {
-                Log.d(TAG, "Successfully made binaries executable")
-                return@withContext true
-            } else {
-                Log.e(TAG, "Failed to make binaries executable, exit codes: $chmod1Result, $chmod2Result")
-                return@withContext false
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Error making binaries executable", e)
-            return@withContext false
-        }
-    }
-
-    private suspend fun findFunctionOffset(): Long = withContext(Dispatchers.IO) {
-        val libraryPath = findBluetoothLibraryPath() ?: return@withContext 0L
-        var offset = 0L
-
-        try {
-            @Suppress("LocalVariableName") val currentLD_LIBRARY_PATH = ProcessBuilder().command("su", "-c", "printenv LD_LIBRARY_PATH").start().inputStream.bufferedReader().readText().trim()
-            val currentPATH = ProcessBuilder().command("su", "-c", "printenv PATH").start().inputStream.bufferedReader().readText().trim()
-            val envSetup = """
-                export LD_LIBRARY_PATH="$RADARE2_LIB_PATH:$currentLD_LIBRARY_PATH"
-                export PATH="$BUSYBOX_PATH:$RADARE2_BIN_PATH:$currentPATH"
-            """.trimIndent()
-
-            val command = "$envSetup && $RADARE2_BIN_PATH/rabin2 -q -E $libraryPath | grep fcr_chk_chan"
-            Log.d(TAG, "Running command: $command")
-
-            val process = Runtime.getRuntime().exec(arrayOf("su", "-c", command))
-
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
-
-            var line: String?
-
-            while (reader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 output: $line")
-                if (line?.contains("fcr_chk_chan") == true) {
-                    val parts = line.split(" ")
-                    if (parts.isNotEmpty() && parts[0].startsWith("0x")) {
-                        offset = parts[0].substring(2).toLong(16)
-                        Log.d(TAG, "Found offset at ${parts[0]}")
-                        break
-                    }
-                }
-            }
-
-            while (errorReader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 error: $line")
-            }
-
-            val exitCode = process.waitFor()
-            if (exitCode != 0) {
-                Log.e(TAG, "rabin2 command failed with exit code $exitCode")
-            }
-
-//            findAndSaveL2cuProcessCfgReqOffset(libraryPath, envSetup)
-//            findAndSaveL2cCsmConfigOffset(libraryPath, envSetup)
-//            findAndSaveL2cuSendPeerInfoReqOffset(libraryPath, envSetup)
-
-            // findAndSaveSdpOffset(libraryPath, envSetup) Should not be run by default, only when user asks for it.
-
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to find function offset", e)
-            return@withContext 0L
-        }
-
-        if (offset == 0L) {
-            Log.e(TAG, "Failed to extract function offset from output, aborting")
-            return@withContext 0L
-        }
-
-        Log.d(TAG, "Successfully found offset: 0x${offset.toString(16)}")
-        return@withContext offset
-    }
-
-    private suspend fun findAndSaveL2cuProcessCfgReqOffset(libraryPath: String, envSetup: String) = withContext(Dispatchers.IO) {
-        try {
-            val command = "$envSetup && $RADARE2_BIN_PATH/rabin2 -q -E $libraryPath | grep l2cu_process_our_cfg_req"
-            Log.d(TAG, "Running command: $command")
-
-            val process = Runtime.getRuntime().exec(arrayOf("su", "-c", command))
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
-
-            var line: String?
-            var offset = 0L
-
-            while (reader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 output: $line")
-                if (line?.contains("l2cu_process_our_cfg_req") == true) {
-                    val parts = line.split(" ")
-                    if (parts.isNotEmpty() && parts[0].startsWith("0x")) {
-                        offset = parts[0].substring(2).toLong(16)
-                        Log.d(TAG, "Found l2cu_process_our_cfg_req offset at ${parts[0]}")
-                        break
-                    }
-                }
-            }
-
-            while (errorReader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 error: $line")
-            }
-
-            val exitCode = process.waitFor()
-            if (exitCode != 0) {
-                Log.e(TAG, "rabin2 command failed with exit code $exitCode")
-            }
-
-            if (offset > 0L) {
-                val hexString = "0x${offset.toString(16)}"
-                Runtime.getRuntime().exec(arrayOf(
-                    "su", "-c", "/system/bin/setprop $CFG_REQ_OFFSET_PROP $hexString"
-                )).waitFor()
-                Log.d(TAG, "Saved l2cu_process_our_cfg_req offset: $hexString")
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to find or save l2cu_process_our_cfg_req offset", e)
-        }
-    }
-
-    private suspend fun findAndSaveL2cCsmConfigOffset(libraryPath: String, envSetup: String) = withContext(Dispatchers.IO) {
-        try {
-            val command = "$envSetup && $RADARE2_BIN_PATH/rabin2 -q -E $libraryPath | grep l2c_csm_config"
-            Log.d(TAG, "Running command: $command")
-
-            val process = Runtime.getRuntime().exec(arrayOf("su", "-c", command))
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
-
-            var line: String?
-            var offset = 0L
-
-            while (reader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 output: $line")
-                if (line?.contains("l2c_csm_config") == true) {
-                    val parts = line.split(" ")
-                    if (parts.isNotEmpty() && parts[0].startsWith("0x")) {
-                        offset = parts[0].substring(2).toLong(16)
-                        Log.d(TAG, "Found l2c_csm_config offset at ${parts[0]}")
-                        break
-                    }
-                }
-            }
-
-            while (errorReader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 error: $line")
-            }
-
-            val exitCode = process.waitFor()
-            if (exitCode != 0) {
-                Log.e(TAG, "rabin2 command failed with exit code $exitCode")
-            }
-
-            if (offset > 0L) {
-                val hexString = "0x${offset.toString(16)}"
-                Runtime.getRuntime().exec(arrayOf(
-                    "su", "-c", "/system/bin/setprop $CSM_CONFIG_OFFSET_PROP $hexString"
-                )).waitFor()
-                Log.d(TAG, "Saved l2c_csm_config offset: $hexString")
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to find or save l2c_csm_config offset", e)
-        }
-    }
-
-    private suspend fun findAndSaveL2cuSendPeerInfoReqOffset(libraryPath: String, envSetup: String) = withContext(Dispatchers.IO) {
-        try {
-            val command = "$envSetup && $RADARE2_BIN_PATH/rabin2 -q -E $libraryPath | grep l2cu_send_peer_info_req"
-            Log.d(TAG, "Running command: $command")
-
-            val process = Runtime.getRuntime().exec(arrayOf("su", "-c", command))
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
-
-            var line: String?
-            var offset = 0L
-
-            while (reader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 output: $line")
-                if (line?.contains("l2cu_send_peer_info_req") == true) {
-                    val parts = line.split(" ")
-                    if (parts.isNotEmpty() && parts[0].startsWith("0x")) {
-                        offset = parts[0].substring(2).toLong(16)
-                        Log.d(TAG, "Found l2cu_send_peer_info_req offset at ${parts[0]}")
-                        break
-                    }
-                }
-            }
-
-            while (errorReader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 error: $line")
-            }
-
-            val exitCode = process.waitFor()
-            if (exitCode != 0) {
-                Log.e(TAG, "rabin2 command failed with exit code $exitCode")
-            }
-
-            if (offset > 0L) {
-                val hexString = "0x${offset.toString(16)}"
-                Runtime.getRuntime().exec(arrayOf(
-                    "su", "-c", "/system/bin/setprop $PEER_INFO_REQ_OFFSET_PROP $hexString"
-                )).waitFor()
-                Log.d(TAG, "Saved l2cu_send_peer_info_req offset: $hexString")
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to find or save l2cu_send_peer_info_req offset", e)
-        }
-    }
-
-    private suspend fun findAndSaveSdpOffset(libraryPath: String, envSetup: String) = withContext(Dispatchers.IO) {
-        try {
-            val command = "$envSetup && $RADARE2_BIN_PATH/rabin2 -q -E $libraryPath | grep DmSetLocalDiRecord"
-            Log.d(TAG, "Running command: $command")
-
-            val process = Runtime.getRuntime().exec(arrayOf("su", "-c", command))
-            val reader = BufferedReader(InputStreamReader(process.inputStream))
-            val errorReader = BufferedReader(InputStreamReader(process.errorStream))
-
-            var line: String?
-            var offset = 0L
-
-            while (reader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 output: $line")
-                if (line?.contains("DmSetLocalDiRecord") == true) {
-                    val parts = line.split(" ")
-                    if (parts.isNotEmpty() && parts[0].startsWith("0x")) {
-                        offset = parts[0].substring(2).toLong(16)
-                        Log.d(TAG, "Found DmSetLocalDiRecord offset at ${parts[0]}")
-                        break
-                    }
-                }
-            }
-
-            while (errorReader.readLine().also { line = it } != null) {
-                Log.d(TAG, "rabin2 error: $line")
-            }
-
-            val exitCode = process.waitFor()
-            if (exitCode != 0) {
-                Log.e(TAG, "rabin2 command failed with exit code $exitCode")
-            }
-
-            if (offset > 0L) {
-                val hexString = "0x${offset.toString(16)}"
-                Runtime.getRuntime().exec(arrayOf(
-                    "su", "-c", "/system/bin/setprop $SDP_OFFSET_PROP $hexString"
-                )).waitFor()
-                Log.d(TAG, "Saved DmSetLocalDiRecord offset: $hexString")
-            }
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to find or save DmSetLocalDiRecord offset", e)
-        }
-    }
-
-    private suspend fun saveOffset(offset: Long): Boolean = withContext(Dispatchers.IO) {
-        try {
-            val hexString = "0x${offset.toString(16)}"
-            Log.d(TAG, "Saving offset to system property: $hexString")
-
-            val process = Runtime.getRuntime().exec(arrayOf(
-                "su", "-c", "/system/bin/setprop $HOOK_OFFSET_PROP $hexString"
-            ))
-
-            val exitCode = process.waitFor()
-            if (exitCode == 0) {
-                val verifyProcess = Runtime.getRuntime().exec(arrayOf(
-                    "/system/bin/getprop", HOOK_OFFSET_PROP
-                ))
-                val propValue = BufferedReader(InputStreamReader(verifyProcess.inputStream)).readLine()
-                verifyProcess.waitFor()
-
-                if (propValue != null && propValue.isNotEmpty()) {
-                    Log.d(TAG, "Successfully saved offset to system property: $propValue")
-                    return@withContext true
-                } else {
-                    Log.e(TAG, "Property was set but couldn't be verified")
-                }
-            } else {
-                Log.e(TAG, "Failed to set property, exit code: $exitCode")
-            }
-            return@withContext false
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to save offset", e)
-            return@withContext false
-        }
-    }
-
-    private fun cleanupExtractedFiles() {
-        try {
-            Runtime.getRuntime().exec(arrayOf("su", "-c", "rm -rf $EXTRACT_DIR/data/local/tmp/aln_unzip")).waitFor()
-            Log.d(TAG, "Cleaned up extracted files at $EXTRACT_DIR/data/local/tmp/aln_unzip")
-        } catch (e: Exception) {
-            Log.e(TAG, "Failed to cleanup extracted files", e)
-        }
-    }
-
-    suspend fun findSdpOffset(): Boolean = withContext(Dispatchers.IO) {
-        try {
-            _progressState.value = ProgressState.Downloading
-            if (!downloadRadare2TarballIfNeeded()) {
-                _progressState.value = ProgressState.Error("Failed to download radare2 tarball")
-                Log.e(TAG, "Failed to download radare2 tarball")
-                return@withContext false
-            }
-
-            _progressState.value = ProgressState.Extracting
-            if (!extractRadare2Tarball()) {
-                _progressState.value = ProgressState.Error("Failed to extract radare2 tarball")
-                Log.e(TAG, "Failed to extract radare2 tarball")
-                return@withContext false
-            }
-
-            _progressState.value = ProgressState.MakingExecutable
-            if (!makeExecutable()) {
-                _progressState.value = ProgressState.Error("Failed to make binaries executable")
-                Log.e(TAG, "Failed to make binaries executable")
-                return@withContext false
-            }
-
-            _progressState.value = ProgressState.FindingOffset
-            val libraryPath = findBluetoothLibraryPath()
-            if (libraryPath == null) {
-                _progressState.value = ProgressState.Error("Failed to find Bluetooth library")
-                Log.e(TAG, "Failed to find Bluetooth library")
-                return@withContext false
-            }
-
-            @Suppress("LocalVariableName") val currentLD_LIBRARY_PATH = ProcessBuilder().command("su", "-c", "printenv LD_LIBRARY_PATH").start().inputStream.bufferedReader().readText().trim()
-            val currentPATH = ProcessBuilder().command("su", "-c", "printenv PATH").start().inputStream.bufferedReader().readText().trim()
-            val envSetup = """
-                export LD_LIBRARY_PATH="$RADARE2_LIB_PATH:$currentLD_LIBRARY_PATH"
-                export PATH="$BUSYBOX_PATH:$RADARE2_BIN_PATH:$currentPATH"
-            """.trimIndent()
-
-            findAndSaveSdpOffset(libraryPath, envSetup)
-
-            _progressState.value = ProgressState.Cleaning
-            cleanupExtractedFiles()
-
-            _progressState.value = ProgressState.Success(0L)
-            return@withContext true
-
-        } catch (e: Exception) {
-            _progressState.value = ProgressState.Error("Error: ${e.message}")
-            Log.e(TAG, "Error in findSdpOffset", e)
-            return@withContext false
-        }
-    }
-}

android/app/src/main/kotlin/me/kavishdevar/librepods/LibrePodsApplication.kt

@@ -1,23 +1,67 @@
 package me.kavishdevar.librepods
 
 import android.app.Application
+import androidx.health.connect.client.HealthConnectClient
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
 import androidx.lifecycle.ProcessLifecycleOwner
+import androidx.room3.Room
 import io.github.libxposed.service.XposedService
 import io.github.libxposed.service.XposedServiceHelper
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 import me.kavishdevar.librepods.billing.BillingManager
 import me.kavishdevar.librepods.billing.BillingProviderFactory
+import me.kavishdevar.librepods.database.LibrePodsDatabase
+import me.kavishdevar.librepods.repository.AppDataRepository
+import me.kavishdevar.librepods.repository.AppleRepository
+import me.kavishdevar.librepods.repository.HeartRateRepository
+import me.kavishdevar.librepods.repository.RecordingRepository
+import me.kavishdevar.librepods.repository.WidgetConfigRepository
+import me.kavishdevar.librepods.utils.GestureFeedback
 import me.kavishdevar.librepods.utils.XposedServiceHolder
 import me.kavishdevar.librepods.utils.XposedState
 
 class LibrePodsApplication: Application(), XposedServiceHelper.OnServiceListener, DefaultLifecycleObserver {
+    lateinit var database: LibrePodsDatabase
+        private set
+
+    val appleRepository by lazy { AppleRepository(database.appleDao()) }
+    val appDataRepository by lazy { AppDataRepository(database.appSettingsDao(), database.appStateDao()) }
+    val widgetConfigRepository by lazy { WidgetConfigRepository(database.widgetConfigDao()) }
+
+    val recordingRepository by lazy { RecordingRepository(applicationContext) }
+    val heartRateRepository by lazy { HeartRateRepository(database.heartRateDao()) }
+
+    val healthConnectClient: HealthConnectClient? by lazy {
+        val status = HealthConnectClient.getSdkStatus(this)
+        if (status == HealthConnectClient.SDK_AVAILABLE) {
+            HealthConnectClient.getOrCreate(this)
+        } else {
+            null
+        }
+    }
 
     override fun onCreate() {
+        System.loadLibrary("hiddenapi")
+
+        database = Room.databaseBuilder(
+            applicationContext,
+            LibrePodsDatabase::class.java,
+            "librepods.db"
+        ).build()
+
         XposedServiceHelper.registerListener(this)
+
+        runBlocking(Dispatchers.IO) {
+            appDataRepository.awaitInitialized()
+        }
+
         BillingManager.provider = BillingProviderFactory.create(this)
         ProcessLifecycleOwner.get().lifecycle.addObserver(this)
 
+        GestureFeedback.init(this)
+
         super<Application>.onCreate()
 
     }

android/app/src/main/kotlin/me/kavishdevar/librepods/audio/EldDecoder.kt

@@ -0,0 +1,105 @@
+package me.kavishdevar.librepods.audio
+
+import android.media.MediaCodec
+import android.media.MediaCodec.BufferInfo
+import android.media.MediaCodecInfo
+import android.media.MediaFormat
+import java.nio.ByteBuffer
+
+class EldDecoder {
+
+    companion object {
+        private val ASC = byteArrayOf(
+            0xF8.toByte(),
+            0xE6.toByte(),
+            0x30,
+            0x00
+        )
+    }
+
+    private val codec = MediaCodec.createDecoderByType(
+        MediaFormat.MIMETYPE_AUDIO_AAC
+    )
+
+    private val info = BufferInfo()
+
+    init {
+        val format = MediaFormat.createAudioFormat(
+            MediaFormat.MIMETYPE_AUDIO_AAC,
+            64_000,
+            1
+        )
+
+        format.setInteger(
+            MediaFormat.KEY_AAC_PROFILE,
+            MediaCodecInfo.CodecProfileLevel.AACObjectELD
+        )
+
+        format.setByteBuffer(
+            "csd-0",
+            ByteBuffer.wrap(ASC)
+        )
+
+        codec.configure(format, null, null, 0)
+        codec.start()
+    }
+
+    fun decode(
+        accessUnit: ByteArray,
+        onPcm: (ByteArray) -> Unit
+    ) {
+        val input = codec.dequeueInputBuffer(10_000)
+
+        if (input >= 0) {
+            codec.getInputBuffer(input)?.apply {
+                clear()
+                put(accessUnit)
+            }
+
+            codec.queueInputBuffer(
+                input,
+                0,
+                accessUnit.size,
+                0,
+                0
+            )
+        }
+
+        while (true) {
+            val output = codec.dequeueOutputBuffer(info, 0)
+
+            when {
+                output >= 0 -> {
+                    val buffer = codec.getOutputBuffer(output)!!
+
+                    val pcm = ByteArray(info.size)
+
+                    buffer.position(info.offset)
+                    buffer.limit(info.offset + info.size)
+                    buffer.get(pcm)
+
+                    codec.releaseOutputBuffer(output, false)
+
+                    onPcm(pcm)
+                }
+
+                output == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
+                    // ignore
+                }
+
+                output == MediaCodec.INFO_TRY_AGAIN_LATER -> {
+                    break
+                }
+
+                else -> {
+                    break
+                }
+            }
+        }
+    }
+
+    fun close() {
+        codec.stop()
+        codec.release()
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/audio/WavWriter.kt

@@ -0,0 +1,72 @@
+package me.kavishdevar.librepods.audio
+
+import java.io.File
+import java.io.RandomAccessFile
+
+class WavWriter(
+    file: File,
+    private val sampleRate: Int = 64_000,
+    private val channels: Int = 1,
+    private val bitsPerSample: Int = 16
+) : AutoCloseable {
+
+    private val raf = RandomAccessFile(file, "rw")
+    private var dataSize = 0L
+
+    init {
+        writeHeader()
+    }
+
+    fun write(pcm: ByteArray) {
+        raf.write(pcm)
+        dataSize += pcm.size
+    }
+
+    override fun close() {
+        raf.seek(4)
+        raf.writeIntLE((36 + dataSize).toInt())
+
+        raf.seek(40)
+        raf.writeIntLE(dataSize.toInt())
+
+        raf.close()
+    }
+
+    private fun writeHeader() {
+        raf.writeBytes("RIFF")
+        raf.writeIntLE(0)
+
+        raf.writeBytes("WAVE")
+
+        raf.writeBytes("fmt ")
+        raf.writeIntLE(16)
+        raf.writeShortLE(1)
+
+        raf.writeShortLE(channels.toShort())
+
+        raf.writeIntLE(sampleRate)
+
+        val byteRate = sampleRate * channels * bitsPerSample / 8
+        raf.writeIntLE(byteRate)
+
+        val blockAlign = channels * bitsPerSample / 8
+        raf.writeShortLE(blockAlign.toShort())
+
+        raf.writeShortLE(bitsPerSample.toShort())
+
+        raf.writeBytes("data")
+        raf.writeIntLE(0)
+    }
+}
+
+private fun RandomAccessFile.writeIntLE(value: Int) {
+    write(value and 0xff)
+    write((value ushr 8) and 0xff)
+    write((value ushr 16) and 0xff)
+    write((value ushr 24) and 0xff)
+}
+
+private fun RandomAccessFile.writeShortLE(value: Short) {
+    write(value.toInt() and 0xff)
+    write((value.toInt() ushr 8) and 0xff)
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/billing/FOSSBillingProvider.kt

@@ -21,7 +21,6 @@ package me.kavishdevar.librepods.billing
 import android.app.Activity
 import android.content.Context
 import android.content.Intent
-import androidx.core.content.edit
 import androidx.core.net.toUri
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
@@ -31,17 +30,19 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.LibrePodsApplication
 import me.kavishdevar.librepods.R
+import kotlin.time.Duration.Companion.seconds
 
 class FOSSBillingProvider(context: Context): BillingProvider {
-    private val _isPremium = MutableStateFlow(false)
+    private val appDataRepository = (context.applicationContext as LibrePodsApplication).appDataRepository
+
+    private val _isPremium = MutableStateFlow(appDataRepository.state.value.isPremium)
     override val isPremium: StateFlow<Boolean> = _isPremium
 
     private val _price = MutableStateFlow(context.getString(R.string.name_your_own_price))
     override val price: StateFlow<String> = _price
 
-    private val sharedPreferences = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
-
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
     private var purchaseJob: Job? = null
 
@@ -57,21 +58,18 @@ class FOSSBillingProvider(context: Context): BillingProvider {
         purchaseJob?.cancel()
 
         purchaseJob = scope.launch {
-            delay(5_000)
+            delay(5.seconds)
             _isPremium.value = true
-            sharedPreferences.edit { putBoolean("foss_upgraded", true) }
+            appDataRepository.updateState { it.copy(isPremium = true) }
         }
     }
 
     override fun queryPurchases() {
-        val stored = sharedPreferences.getBoolean("foss_upgraded", false)
-        if (stored != _isPremium.value) {
-            _isPremium.value = stored
-        }
+        _isPremium.value = appDataRepository.state.value.isPremium
     }
 
     override fun restorePurchases() {
         _isPremium.value = true
-        sharedPreferences.edit { putBoolean("foss_upgraded", true) }
+        appDataRepository.updateState { it.copy(isPremium = true) }
     }
 }

android/app/src/main/kotlin/me/kavishdevar/librepods/billing/PlayBillingProvider.kt

@@ -41,6 +41,7 @@ import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.StateFlow
 import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.LibrePodsApplication
 
 const val TAG = "PlayBillingProvider"
 
@@ -49,10 +50,11 @@ private const val PREMIUM_PRODUCT_ID = "librepods.advanced_features.v2"
 class PlayBillingProvider(
     context: Context
 ) : BillingProvider, PurchasesUpdatedListener {
+    private val appDataRepository = (context.applicationContext as LibrePodsApplication).appDataRepository
 
     private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
 
-    private val _isPremium = MutableStateFlow(false)
+    private val _isPremium = MutableStateFlow(appDataRepository.state.value.isPremium)
     override val isPremium: StateFlow<Boolean> = _isPremium
 
     private val _price = MutableStateFlow("unknown")
@@ -177,6 +179,8 @@ class PlayBillingProvider(
 
         _isPremium.value = hasPremium
 
+        appDataRepository.updateState { it.copy(isPremium = hasPremium) }
+
         scope.launch {
             purchases
                 .filter { it.purchaseState == Purchase.PurchaseState.PURCHASED && !it.isAcknowledged }

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/Utils.kt

@@ -0,0 +1,149 @@
+/*
+    LibrePods - AirPods liberated from Apple’s ecosystem
+    Copyright (C) 2025 LibrePods contributors
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+package me.kavishdevar.librepods.bluetooth
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothSocket
+import android.os.ParcelUuid
+import android.util.Log
+import kotlinx.serialization.Serializable
+import me.kavishdevar.librepods.utils.redactMac
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+
+fun createBluetoothSocket(
+    adapter: BluetoothAdapter, device: BluetoothDevice, uuid: ParcelUuid, psm: Int
+): BluetoothSocket {
+    val type = 3 // L2CAP
+    val constructorSpecs = listOf(
+        arrayOf(adapter, device, type, true, true, psm, uuid), // A16QPR3
+        arrayOf(device, type, true, true, psm, uuid),
+        arrayOf(device, type, 1, true, true, psm, uuid),
+        arrayOf(type, 1, true, true, device, psm, uuid),
+        arrayOf(type, true, true, device, psm, uuid)
+    )
+
+    val constructors = BluetoothSocket::class.java.declaredConstructors
+    Log.d("createSocket<$psm>", "BluetoothSocket has ${constructors.size} constructors:")
+
+    constructors.forEachIndexed { index, constructor ->
+        val params = constructor.parameterTypes.joinToString(", ") { it.simpleName }
+        Log.d("createSocket<$psm>", "Constructor $index: ($params)")
+    }
+
+    var lastException: Exception? = null
+    var attemptedConstructors = 0
+
+    for ((index, params) in constructorSpecs.withIndex()) {
+        try {
+            Log.d("createSocket<$psm>", "Trying constructor signature #${index + 1}")
+            attemptedConstructors++
+
+            val paramTypes =
+                params.map { it::class.javaPrimitiveType ?: it::class.java }.toTypedArray()
+            val constructor = BluetoothSocket::class.java.getDeclaredConstructor(*paramTypes)
+            constructor.isAccessible = true
+            return constructor.newInstance(*params) as BluetoothSocket
+
+        } catch (e: Exception) {
+            Log.e("createSocket<$psm>", "Constructor signature #${index + 1} failed: ${e.message}")
+            lastException = e
+        }
+    }
+
+    val errorMessage =
+        "Failed to create BluetoothSocket after trying $attemptedConstructors constructor signatures"
+    Log.e("createSocket<$psm>", errorMessage)
+    throw lastException ?: IllegalStateException(errorMessage)
+}
+
+/**
+ * Verifies if the provided Bluetooth address is an RPA that matches the given Identity Resolving Key (IRK)
+ *
+ * @param addr The Bluetooth address to verify
+ * @param irk The Identity Resolving Key to use for verification
+ * @return true if the address is verified as an RPA matching the IRK
+ */
+fun verifyRPA(addr: String, irk: ByteArray): Boolean {
+    val rpa = addr.split(":").map { it.toInt(16).toByte() }.reversed().toByteArray()
+    val prand = rpa.copyOfRange(3, 6)
+    val hash = rpa.copyOfRange(0, 3)
+    val computedHash = ah(irk, prand)
+    return hash.contentEquals(computedHash)
+}
+
+/**
+ * Performs E function (AES-128) as specified in Bluetooth Core Specification
+ *
+ * @param key The key for encryption
+ * @param data The data to encrypt
+ * @return The encrypted data
+ */
+@SuppressLint("GetInstance")
+fun e(key: ByteArray, data: ByteArray): ByteArray {
+    val swappedKey = key.reversedArray()
+    val swappedData = data.reversedArray()
+    val cipher = Cipher.getInstance("AES/ECB/NoPadding")
+    val secretKey = SecretKeySpec(swappedKey, "AES")
+    cipher.init(Cipher.ENCRYPT_MODE, secretKey)
+    return cipher.doFinal(swappedData).reversedArray()
+}
+
+/**
+ * Performs the ah function as specified in Bluetooth Core Specification
+ *
+ * @param k The IRK key
+ * @param r The random part of the address
+ * @return The hash part of the address
+ */
+fun ah(k: ByteArray, r: ByteArray): ByteArray {
+    val rPadded = ByteArray(16)
+    r.copyInto(rPadded, 0, 0, 3)
+    val encrypted = e(k, rPadded)
+    return encrypted.copyOfRange(0, 3)
+}
+
+@JvmInline
+@Serializable
+value class MacAddress(val value: String) {
+    init {
+        require(value.matches(Regex("([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}"))) {
+            "Invalid MAC address format: $value"
+        }
+    }
+
+    override fun toString(): String {
+        return value
+    }
+
+    fun toRedactedString(): String {
+        return value.redactMac()
+    }
+
+    fun toNotificationId(): Int {
+        return value
+            .replace(":", "")
+            .takeLast(8)
+            .toUInt(16)
+            .toInt()
+
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/RTBuddyManager.kt

@@ -0,0 +1,122 @@
+package me.kavishdevar.librepods.bluetooth.aacp
+
+import android.util.Log
+import com.google.protobuf.ByteString
+import me.kavishdevar.librepods.bluetooth.aacp.packet.AACPPacket
+import me.kavishdevar.librepods.bluetooth.aacp.packet.RTBuddyPacket
+import me.kavishdevar.librepods.bluetooth.aacp.rtbuddy.proto.SensorDataWX
+import me.kavishdevar.librepods.bluetooth.aacp.rtbuddy.proto.SensorServiceSetting
+import me.kavishdevar.librepods.bluetooth.aacp.rtbuddy.proto.SensorServiceType
+import me.kavishdevar.librepods.bluetooth.aacp.types.SensorDataWxBuddyPayload
+import me.kavishdevar.librepods.devices.PacketDestination
+import kotlin.time.Duration
+
+class RTBuddyManager(
+    private val sendPacket: (AACPPacket) -> Boolean,
+) {
+    companion object {
+        private const val TAG = "RTBuddyManager"
+    }
+
+    private var sequence = 0
+
+    private fun nextSequence(): Int {
+        val next = sequence
+        sequence = (sequence + 1) and 0x7FFFFFFF
+        return next
+    }
+
+    private fun observeSequence(data: SensorDataWX) {
+        Log.d(TAG, "Received SensorDataWX seq=${data.seq}")
+    }
+
+    fun handlePacket(packet: RTBuddyPacket) {
+        when (val payload = packet.rtBuddyPayload) {
+            is SensorDataWxBuddyPayload -> {
+                val data = payload.data
+                observeSequence(data)
+
+//                handleSensorData(data)
+            }
+
+            else -> {
+                Log.d(
+                    TAG,
+                    "Unhandled RTBuddy payload: ${payload.descriptor}"
+                )
+            }
+        }
+    }
+
+//    private fun handleSensorData(data: SensorDataWX) {
+//        if (data.hasServiceSettings()) {
+//            when (data.serviceSettings.service) {
+//                SensorServiceType.ACTIVITY,
+//                SensorServiceType.DEVMOTION6 -> {
+//                    // Head tracking data/configuration
+//                }
+//
+//                SensorServiceType.HEARTRATE -> {
+//                    // Heart rate
+//                }
+//
+//                else -> {
+//                    Log.d(
+//                        TAG,
+//                        "Unhandled sensor service: ${data.serviceSettings.service}"
+//                    )
+//                }
+//            }
+//        }
+//    }
+
+    fun sendSensorData(
+        data: SensorDataWX,
+    ): Boolean {
+        val dataWithSequence = data.toBuilder()
+            .setSeq(nextSequence())
+            .build()
+
+        val packet = RTBuddyPacket.create(
+            rtBuddyPayload = SensorDataWxBuddyPayload(
+                data = dataWithSequence,
+            ),
+            destination = PacketDestination.DEVICE,
+        )
+
+        return sendPacket(packet)
+    }
+
+    private fun sendSensorServiceSetting(
+        service: SensorServiceType,
+        configuration: ByteArray,
+    ): Boolean {
+        val data = SensorDataWX.newBuilder()
+            .setServiceSettings(
+                SensorServiceSetting.newBuilder()
+                    .setService(service)
+                    .setSetting(2)
+                    .setConfiguration(
+                        ByteString.copyFrom(configuration)
+                    )
+            )
+            .build()
+
+        return sendSensorData(data)
+    }
+
+    fun setSensorServiceReportInterval(sensorServiceType: SensorServiceType, interval: Duration): Boolean = sendSensorServiceSetting(
+        service = sensorServiceType,
+        configuration = byteArrayOf(0x01) + interval.toMicrosUINT32LE()
+    )
+}
+
+private fun Duration.toMicrosUINT32LE(): ByteArray {
+    val microseconds = this.inWholeMicroseconds
+    return byteArrayOf(
+        microseconds.toByte(),
+        (microseconds shr 8).toByte(),
+        (microseconds shr 16).toByte(),
+        (microseconds shr 24).toByte()
+    )
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/AACPPacket.kt

@@ -0,0 +1,69 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.types.Opcode
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class AACPPacketType(val value: Byte) {
+    companion object {
+        val CONNECT = AACPPacketType(0x00)
+        val CONNECT_RESPONSE = AACPPacketType(0x01)
+        val DISCONNECT = AACPPacketType(0x02)
+        val DISCONNECT_RESPONSE = AACPPacketType(0x03)
+        val MESSAGE = AACPPacketType(0x04)
+
+        fun fromByte(value: Byte): AACPPacketType {
+            return when (value) {
+                0x00.toByte() -> CONNECT
+                0x01.toByte() -> CONNECT_RESPONSE
+                0x02.toByte() -> DISCONNECT
+                0x03.toByte() -> DISCONNECT_RESPONSE
+                0x04.toByte() -> MESSAGE
+                else -> AACPPacketType(value)
+            }
+        }
+    }
+}
+
+sealed interface AACPPacket {
+    /**
+    * The entire packet; contains the opcode and header
+    */
+    val rawPacket: ByteArray
+        get() = byteArrayOf(type.value, 0x00, service, 0x00, opcode.value, 0x00) + payload
+
+    val destination: PacketDestination
+
+    val type: AACPPacketType
+
+    val service: Byte
+
+    val opcode: Opcode
+
+    val payload: ByteArray
+
+    companion object {
+        fun createUnknownPacket(
+            opcode: Opcode,
+            payload: ByteArray,
+            destination: PacketDestination = PacketDestination.DEVICE,
+            type: AACPPacketType = AACPPacketType.MESSAGE,
+            service: Byte = 0x04,
+        ): AACPPacket {
+            return UnknownAACPPacket(
+                service = service,
+                type = type,
+                opcode = opcode,
+                payload = payload,
+                destination = destination
+            )
+        }
+    }
+}
+
+data class UnknownAACPPacket (
+    override val service: Byte = 0x04,
+    override val type: AACPPacketType = AACPPacketType.MESSAGE,
+    override val opcode: Opcode,
+    override val payload: ByteArray,
+    override val destination: PacketDestination
+): AACPPacket

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/AudioSourcePacket.kt

@@ -0,0 +1,39 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.types.AudioSource
+import me.kavishdevar.librepods.bluetooth.aacp.types.AudioSourceType
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.bluetooth.MacAddress
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class AudioSourcePacket(
+    val audioSource: AudioSource,
+    override val payload: ByteArray,
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.STEM_PRESS
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+        ): AudioSourcePacket {
+            if (packet.size < 9) {
+                throw IllegalArgumentException("Data array too short to parse Audio Source Response")
+            }
+
+            val payload = packet.copyOfRange(6, packet.size)
+            val macAddress = MacAddress(payload.sliceArray(0..5).toHexString(HexFormat{ upperCase = true }).chunked(2).joinToString(":"))
+
+            val typeByte = payload[6]
+            val type = AudioSourceType.fromByte(typeByte)
+
+            val audioSource = AudioSource(macAddress, type)
+
+            return AudioSourcePacket(audioSource, payload)
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/BatteryInfoPacket.kt

@@ -0,0 +1,52 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import android.util.Log
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.bluetooth.aacp.types.Opcode
+import me.kavishdevar.librepods.devices.Battery
+import me.kavishdevar.librepods.devices.BatteryComponent
+import me.kavishdevar.librepods.devices.BatteryStatus
+import me.kavishdevar.librepods.devices.PacketDestination
+
+private const val TAG = "BatteryInfoPacket"
+
+data class BatteryInfoPacket(
+    val batteries: Set<Battery>,
+    override val payload: ByteArray,
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode: Opcode = MessageOpcode.BATTERY_INFO
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+        ): BatteryInfoPacket {
+            val payload = packet.sliceArray(6 until packet.size)
+
+            var offset = 0
+            val batteryCount = payload[offset].toInt()
+            val batteries = mutableSetOf<Battery>()
+            offset += 1
+            for (i in 0 until batteryCount) {
+                val componentByte = payload[offset]
+                val component = BatteryComponent.fromAirPodsByte(componentByte)
+                val levelByte = payload[offset + 2]
+                val level = levelByte.toInt()
+                val statusByte = payload[offset + 3]
+                val status = BatteryStatus.fromAirPodsByte(statusByte)
+
+                Log.i(TAG, "parsed battery#$i: component=${component.name}, level=$level, status=${status.name}")
+
+                batteries.add(Battery(component, level, status))
+                offset += 5
+            }
+            Log.i(TAG, "parsed Battery Info: $batteries")
+
+            return BatteryInfoPacket(batteries, payload)
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/ConnectedDevicesPacket.kt

@@ -0,0 +1,59 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import android.util.Log
+import me.kavishdevar.librepods.bluetooth.aacp.types.ConnectedDevice
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.bluetooth.MacAddress
+import me.kavishdevar.librepods.devices.PacketDestination
+
+private const val TAG = "ConnectedDevicesPacket"
+
+data class ConnectedDevicesPacket(
+    val connectedDevices: List<ConnectedDevice>,
+    override val payload: ByteArray,
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.CONNECTED_DEVICES
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+        ): ConnectedDevicesPacket {
+            if (packet.size < 8) {
+                throw IllegalArgumentException("Data array too short to parse Connected Devices Response")
+            }
+
+            val payload = packet.copyOfRange(6, packet.size)
+
+            val deviceCount = payload[2].toInt()
+            val devices = mutableListOf<ConnectedDevice>()
+
+            var offset = 3
+
+            for (i in 0 until deviceCount) {
+                if (offset + 8 > payload.size) {
+                    Log.w(
+                        TAG,
+                        "Data array too short to parse all connected devices, returning what we have"
+                    )
+                    break
+                }
+
+                val macAddress = MacAddress(payload.sliceArray(offset until offset + 6).toHexString(HexFormat{ upperCase = true }).chunked(2).joinToString(":"))
+
+                val info1 = payload[offset + 6]
+                val info2 = payload[offset + 7]
+
+                val existingDevice = devices.find { it.macAddress == macAddress }
+                devices.add(ConnectedDevice(macAddress, info1, info2, existingDevice?.type))
+                offset += 8
+            }
+
+            return ConnectedDevicesPacket(devices, payload)
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/ControlCommandPacket.kt

@@ -0,0 +1,62 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.types.ControlCommand
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class ControlCommandPacket(
+    val controlCommand: ControlCommand,
+    override val destination: PacketDestination,
+): AACPPacket {
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.CONTROL_COMMAND
+
+    override val payload: ByteArray = controlCommand.toAACPPayload()
+
+    companion object {
+        fun parse(
+            data: ByteArray,
+            destination: PacketDestination = PacketDestination.HOST
+        ): ControlCommandPacket {
+            val payload = if (data.toHexString().startsWith("040004000900")) {
+                data.copyOfRange(6, data.size)
+            } else data
+
+            val controlCommand = ControlCommand.fromAACPPayload(payload)
+
+            return ControlCommandPacket(controlCommand, destination)
+        }
+
+        fun create(
+            controlCommand: ControlCommand,
+            destination: PacketDestination = PacketDestination.DEVICE
+        ): ControlCommandPacket {
+            return ControlCommandPacket(
+                controlCommand = controlCommand,
+                destination = destination,
+            )
+        }
+    }
+
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as ControlCommandPacket
+
+        if (controlCommand != other.controlCommand) return false
+        if (destination != other.destination) return false
+        if (!rawPacket.contentEquals(other.rawPacket)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = controlCommand.hashCode()
+        result = 31 * result + destination.hashCode()
+        result = 31 * result + rawPacket.contentHashCode()
+        return result
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/CustomEqPacket.kt

@@ -0,0 +1,50 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.types.CustomEq
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class CustomEqPacket(
+    val customEq: CustomEq,
+    override val destination: PacketDestination
+): AACPPacket {
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.CONTROL_COMMAND
+
+    override val payload: ByteArray = customEq.toAACPPayload()
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+            destination: PacketDestination = PacketDestination.HOST
+        ): CustomEqPacket {
+            val payload = packet.copyOfRange(6, packet.size)
+
+            val length = payload[0].toInt()
+            require(length == 5) { "Invalid length for CustomEqPacket: $length" }
+
+            val state = payload[3].toInt()
+            val low = payload[4].toInt()
+            val mid = payload[5].toInt()
+            val high = payload[6].toInt()
+
+            val customEq = CustomEq(state, low, mid, high)
+
+            return CustomEqPacket(customEq, destination)
+        }
+
+        // TODO: not all customeq messages are sending custom eq. there is one to request the current custom eq settings.
+        //  this AACPPacket class only supports sending/receiving the custom eq settings, not other messages.
+        fun create(
+            customEq: CustomEq,
+            destination: PacketDestination = PacketDestination.DEVICE
+        ): CustomEqPacket {
+            return CustomEqPacket(
+                customEq = customEq,
+                destination = destination,
+            )
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/EarDetectionResponsePacket.kt

@@ -0,0 +1,79 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import android.util.Log
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.devices.ComponentStatus
+import me.kavishdevar.librepods.devices.DeviceComponent
+import me.kavishdevar.librepods.devices.DeviceComponentState
+import me.kavishdevar.librepods.devices.PacketDestination
+
+private const val TAG = "EarDetectionResponsePacket"
+
+data class EarDetectionResponsePacket(
+    val componentStates: Set<DeviceComponentState>,
+    val isLeftPrimary: Boolean
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.EAR_DETECTION
+
+    override val payload: ByteArray = byteArrayOf(
+        componentStates.first { it.component == DeviceComponent.LEFT }.status.toAirPodsByte(),
+        componentStates.first { it.component == DeviceComponent.RIGHT }.status.toAirPodsByte()
+    ).let {
+        if (isLeftPrimary) it else it.reversedArray()
+    }
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+            isLeftPrimary: Boolean
+        ): EarDetectionResponsePacket {
+            val payload = packet.copyOfRange(6, packet.size)
+            Log.d(
+                TAG,
+                "parsing Ear Detection Response: ${packet.joinToString(" ") { "%02X".format(it) }}"
+            )
+
+            val primaryStatus = payload[0]
+            val secondaryStatus = payload[1]
+
+            val componentStates = mutableSetOf<DeviceComponentState>()
+
+            if (isLeftPrimary) {
+                componentStates.addAll(
+                    listOf(
+                        DeviceComponentState(
+                            DeviceComponent.LEFT,
+                            ComponentStatus.fromAirPodsByte(primaryStatus)
+                        ),
+                        DeviceComponentState(
+                            DeviceComponent.RIGHT,
+                            ComponentStatus.fromAirPodsByte(secondaryStatus)
+                        )
+                    )
+                )
+            } else {
+                componentStates.addAll(
+                    listOf(
+                        DeviceComponentState(
+                            DeviceComponent.LEFT,
+                            ComponentStatus.fromAirPodsByte(secondaryStatus)
+                        ),
+                        DeviceComponentState(
+                            DeviceComponent.RIGHT,
+                            ComponentStatus.fromAirPodsByte(primaryStatus)
+                        )
+                    )
+                )
+            }
+
+            Log.i(TAG, "parsed Ear Detection Response: $componentStates")
+
+            return EarDetectionResponsePacket(componentStates, isLeftPrimary)
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/InformationPacket.kt

@@ -0,0 +1,71 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import android.util.Log
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.devices.AirPodsModel
+import me.kavishdevar.librepods.devices.AirPodsSpecs
+import me.kavishdevar.librepods.devices.AppleMetadata
+import me.kavishdevar.librepods.devices.PacketDestination
+
+private const val TAG = "InformationPacket"
+
+data class InformationPacket(
+    val metadata: AppleMetadata,
+    override val payload: ByteArray
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.INFORMATION
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+        ): InformationPacket {
+            val payload = packet.copyOfRange(6, packet.size)
+
+            var index = 0
+            while (index < payload.size && payload[index] != 0x00.toByte()) index++
+
+            val strings = mutableListOf<String>()
+            while (index < payload.size) {
+                // skip 0x00 bytes
+                while (index < payload.size && payload[index] == 0x00.toByte()) index++
+                if (index >= payload.size) break
+                val start = index
+                // find next 0x00 byte
+                while (index < payload.size && payload[index] != 0x00.toByte()) index++
+                val str = payload.sliceArray(start until index).decodeToString()
+                strings.add(str)
+            }
+
+            Log.i(TAG, "parse: strings: $strings")
+
+            strings.removeAt(0)
+
+            val model = AirPodsModel.fromModelNumber(strings.getOrNull(1)?: "A3063")
+
+            return InformationPacket(
+                metadata = AppleMetadata(
+                    name = strings.getOrNull(0) ?: "",
+                    model = model,
+                    modelName = AirPodsSpecs.getSpec(model).displayName,
+                    modelNumber = strings.getOrNull(1) ?: "",
+                    manufacturer = strings.getOrNull(2) ?: "",
+                    serialNumber = strings.getOrNull(3) ?: "",
+                    leftSerialNumber = strings.getOrNull(8) ?: "",
+                    rightSerialNumber = strings.getOrNull(9) ?: "",
+                    version1 = strings.getOrNull(4) ?: "",
+                    version2 = strings.getOrNull(5) ?: "",
+                    version3 = strings.getOrNull(10) ?: "",
+                    hardwareRevision = strings.getOrNull(6) ?: "",
+                    updaterIdentifier = strings.getOrNull(7) ?: ""
+                ),
+                payload = payload
+            )
+        }
+    }
+}
+

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/MagicKeysResponsePacket.kt

@@ -0,0 +1,55 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import android.util.Log
+import me.kavishdevar.librepods.bluetooth.aacp.types.MagicKeyType
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.devices.PacketDestination
+
+private const val TAG = "MagicKeyResponsePacket"
+
+data class MagicKeyResponsePacket(
+    val magicKeys: Map<MagicKeyType, ByteArray>,
+    override val payload: ByteArray,
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.MAGIC_KEYS_RESPONSE
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+        ): MagicKeyResponsePacket {
+            val payload = packet.copyOfRange(6, packet.size)
+            val keyCount = payload[0].toInt()
+            val keys = mutableMapOf<MagicKeyType, ByteArray>()
+            var offset = 1
+            for (i in 0 until keyCount) {
+                Log.d(TAG, "Parsing Proximity Key $i")
+                if (offset + 3 >= payload.size) {
+                    throw IllegalArgumentException("Data array too short to parse Proximity Keys Response")
+                }
+                val keyType = payload[offset]
+                val keyLength = payload[offset + 2].toInt()
+                Log.d(TAG, "Key Type: ${keyType.toString(16)}, Key Length: $keyLength")
+                offset += 4
+                if (offset + keyLength > payload.size) {
+                    throw IllegalArgumentException("Data array too short to parse Proximity Keys Response")
+                }
+                val key = ByteArray(keyLength)
+                System.arraycopy(payload, offset, key, 0, keyLength)
+                try {
+                    keys[MagicKeyType.fromByte(keyType)] = key
+                } catch (e: Exception) {
+                    Log.e(TAG, "incorrect key type received: $keyType, ${key.toHexString()}", e)
+                }
+                offset += keyLength
+                Log.d(TAG, "Parsed Proximity Key: Type: ${keyType}, Length: $keyLength, Key: ${key.toHexString()}")
+            }
+
+            return MagicKeyResponsePacket(keys, payload)
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/RTBuddyPacket.kt

@@ -0,0 +1,121 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.rtbuddy.proto.SensorDataWX
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.bluetooth.aacp.types.Opcode
+import me.kavishdevar.librepods.bluetooth.aacp.types.RTBuddyDescriptor
+import me.kavishdevar.librepods.bluetooth.aacp.types.RTBuddyPayload
+import me.kavishdevar.librepods.bluetooth.aacp.types.SensorDataWxBuddyPayload
+import me.kavishdevar.librepods.bluetooth.aacp.types.UnknownBuddyPayload
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class RTBuddyPacket(
+    val rtBuddyPayload: RTBuddyPayload,
+
+    override val payload: ByteArray,
+    override val destination: PacketDestination,
+) : AACPPacket {
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+    override val opcode: Opcode = MessageOpcode.BUDDY_COMMAND
+
+    companion object {
+        fun parse(
+            data: ByteArray,
+            destination: PacketDestination = PacketDestination.HOST,
+        ): RTBuddyPacket {
+            val payload = if (
+                data.size >= 6 &&
+                data[0] == AACPPacketType.MESSAGE.value &&
+                data[4] == MessageOpcode.BUDDY_COMMAND.value
+            ) {
+                data.copyOfRange(6, data.size)
+            } else {
+                data
+            }
+
+            require(payload.size >= 6) {
+                "RTBuddy packet is too short: ${payload.size}"
+            }
+
+            val descriptorValue =
+                (payload[0].toUInt() and 0xFFu) or
+                    ((payload[1].toUInt() and 0xFFu) shl 8) or
+                    ((payload[2].toUInt() and 0xFFu) shl 16) or
+                    ((payload[3].toUInt() and 0xFFu) shl 24)
+
+            val length =
+                (payload[4].toInt() and 0xFF) or
+                    ((payload[5].toInt() and 0xFF) shl 8)
+
+            require(payload.size >= 6 + length) {
+                "RTBuddy payload truncated: expected $length bytes, got ${payload.size - 6}"
+            }
+
+            val descriptor = RTBuddyDescriptor.fromValue(descriptorValue)
+            val data = payload.copyOfRange(6, 6 + length)
+
+            val rtBuddyPayload: RTBuddyPayload = when (descriptor) {
+                RTBuddyDescriptor.SENSOR_DATA_WX -> {
+                    SensorDataWxBuddyPayload(
+                        data = SensorDataWX.parseFrom(data),
+                    )
+                }
+
+                else -> {
+                    UnknownBuddyPayload(
+                        descriptor = descriptor,
+                        descriptorValue = descriptorValue,
+                        data = data,
+                    )
+                }
+            }
+
+            return RTBuddyPacket(
+                rtBuddyPayload = rtBuddyPayload,
+                payload = payload,
+                destination = destination,
+            )
+        }
+        fun create(
+            rtBuddyPayload: RTBuddyPayload,
+            destination: PacketDestination = PacketDestination.DEVICE,
+        ): RTBuddyPacket {
+            val data = when (rtBuddyPayload) {
+                is SensorDataWxBuddyPayload ->
+                    rtBuddyPayload.data.toByteArray()
+
+                is UnknownBuddyPayload ->
+                    rtBuddyPayload.data
+            }
+
+            val descriptorValue = when (rtBuddyPayload) {
+                is SensorDataWxBuddyPayload ->
+                    rtBuddyPayload.descriptor.value
+
+                is UnknownBuddyPayload ->
+                    rtBuddyPayload.descriptorValue
+            }
+
+            require(data.size <= 0xFFFF) {
+                "RTBuddy payload too large: ${data.size}"
+            }
+
+            val payload = byteArrayOf(
+                (descriptorValue and 0xFFu).toByte(),
+                ((descriptorValue shr 8) and 0xFFu).toByte(),
+                ((descriptorValue shr 16) and 0xFFu).toByte(),
+                ((descriptorValue shr 24) and 0xFFu).toByte(),
+                (data.size and 0xFF).toByte(),
+                ((data.size shr 8) and 0xFF).toByte(),
+            ) + data
+
+            return RTBuddyPacket(
+                rtBuddyPayload = rtBuddyPayload,
+                payload = payload,
+                destination = destination,
+            )
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/RenamePacket.kt

@@ -0,0 +1,28 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class RenamePacket(
+    val name: String,
+    override val destination: PacketDestination = PacketDestination.DEVICE,
+): AACPPacket {
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.RENAME
+
+    override val payload: ByteArray = byteArrayOf(0x01, name.length.toByte()) + name.toByteArray() + byteArrayOf(0x00)
+
+    companion object {
+        fun create(
+            name: String,
+            destination: PacketDestination = PacketDestination.DEVICE
+        ): RenamePacket {
+            return RenamePacket(
+                name = name,
+                destination = destination,
+            )
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/packet/StemPressPacket.kt

@@ -0,0 +1,36 @@
+package me.kavishdevar.librepods.bluetooth.aacp.packet
+
+import me.kavishdevar.librepods.bluetooth.aacp.types.MessageOpcode
+import me.kavishdevar.librepods.bluetooth.aacp.types.StemPressBud
+import me.kavishdevar.librepods.bluetooth.aacp.types.StemPressType
+import me.kavishdevar.librepods.devices.PacketDestination
+
+data class StemPressPacket(
+    val stemPressBud: StemPressBud,
+    val stemPressType: StemPressType,
+    override val payload: ByteArray,
+): AACPPacket {
+    override val destination: PacketDestination = PacketDestination.HOST
+
+    override val type: AACPPacketType = AACPPacketType.MESSAGE
+    override val service: Byte = 0x04
+
+    override val opcode = MessageOpcode.STEM_PRESS
+
+    companion object {
+        fun parse(
+            packet: ByteArray,
+        ): StemPressPacket {
+            if (packet.size != 8) {
+                throw IllegalArgumentException("Data array too short to parse Stem Press Response")
+            }
+
+            val payload = packet.copyOfRange(6, packet.size)
+
+            val bud = StemPressBud.fromByte(payload[1])?: throw IllegalArgumentException("Invalid bud value: ${payload[1]}")
+            val type = StemPressType.fromByte(payload[0])?: throw IllegalArgumentException("Invalid type value: ${payload[0]}")
+
+            return StemPressPacket(bud, type, payload)
+        }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/AudioSource.kt

@@ -0,0 +1,20 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+import me.kavishdevar.librepods.bluetooth.MacAddress
+
+enum class AudioSourceType(val value: Byte) {
+    NONE(0x00),
+    CALL(0x01),
+    MEDIA(0x02),
+    UNKNOWN_1(0x04),
+    UNKNOWN_2(0x06),
+    UNKNOWN(-1);
+
+    companion object {
+        fun fromByte(byte: Byte): AudioSourceType = entries.find { it.value == byte }?: UNKNOWN
+    }
+}
+
+data class AudioSource(
+    val mac: MacAddress, val type: AudioSourceType
+)

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/Capability.kt

@@ -0,0 +1,70 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+import kotlinx.serialization.Serializable
+
+// TODO: use a map instead, this is inefficient
+
+@Serializable
+data class CapabilityEntry(
+    val capability: Capability,
+    val value: ByteArray
+)
+
+@Serializable
+enum class Capability(
+    val value: Byte,
+    val valueSize: Int = 1
+) {
+    UNKNOWN_01(0x01),
+    UNKNOWN_02(0x02),
+    UNKNOWN_03(0x03, 4),
+    SELECTIVE_SPEECH_LISTENING(0x04, 4),
+    ENHANCED_TRANSPARENCY_VERSION(0x06, 4),
+    UNKNOWN_07(0x07, 4),
+    UNKNOWN_09(0x09),
+    UNKNOWN_0A(0x0A),
+    UNKNOWN_0B(0x0B),
+    UNKNOWN_0F(0x0F),
+    UNKNOWN_10(0x10),
+    PERSONAL_MEDICAL_EQUIPMENT(0x11),
+    CASE_SOUND(0x12),
+    HIDE_OFF_LISTENING_MODE(0x13),
+    UNKNOWN_14(0x14),
+    SIRI_MULTITONE(0x15),
+    HIDE_EAR_DETECTION(0x16),
+    EAR_TIP_FIT_TEST(0x17),
+    AUTO_ANC(0x18),
+    UNKNOWN_PAUSE_MEDIA_ON_SLEEP(0x19),
+    WIRED_LOSSLESS_AUDIO(0x20),
+    SLEEP_DETECTION(0x21),
+    HEARING_AID(0x22),
+    CAMERA_CONTROL(0x23),
+    OVAD_STREAMING(0x24),
+    FAR_FIELD_UPLINK(0x25),
+    HEART_RATE_MONITOR(0x26),
+    HEARING_PROTECTION_PPE(0x28),
+    DYNAMIC_END_OF_CHARGE(0x29),
+    HEARING_PROTECTION(0x30, 4),
+    HEARING_AID_V2(0x31),
+    UNKNOWN_WIRED_LOSSLESS_AUDIO_2(0x34),
+    SMART_ROUTING_VERSION(0x35),
+    FAR_FIELD_UPLINK_MODERN(0x36),
+    PREFERENCE_EQ(0x37),
+    EXTENDED_CLICK_HOLD(0x38),
+    UNKNOWN_SPATIAL_AUDIO_SUPPORT(0x40),
+    UNKNOWN_CALL_MANAGEMENT(0x50),
+    UNKNOWN_60(0x60),
+    UNKNOWN_ADAPTIVE_VOLUME(0x90.toByte()),
+    UNKNOWN_A0(0xA0.toByte()),
+    UNKNOWN_AUTO_ANC_2(0xB0.toByte()),
+    UNKNOWN_HEARING_AID_2(0xC0.toByte()),
+    HEARING_TEST(0xD0.toByte()),
+    UNKNOWN_SENSOR_DATA_2(0xE0.toByte()),
+    BOBBLE(0xF0.toByte());
+
+    companion object {
+        private val map = entries.associateBy(Capability::value)
+
+        fun fromByte(value: Byte): Capability? = map[value]
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/ConnectedDevice.kt

@@ -0,0 +1,7 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+import me.kavishdevar.librepods.bluetooth.MacAddress
+
+data class ConnectedDevice(
+    val macAddress: MacAddress, val info1: Byte, val info2: Byte, var type: String?
+)

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/ControlCommand.kt

@@ -0,0 +1,115 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+data class ControlCommand(
+    val identifier: ControlCommandIdentifier, val value: ByteArray
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as ControlCommand
+
+        if (identifier != other.identifier) return false
+        if (!value.contentEquals(other.value)) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result: Int = identifier.value.toInt()
+        result = 31 * result + value.contentHashCode()
+        return result
+    }
+
+    companion object {
+        fun fromAACPPayload(data: ByteArray): ControlCommand {
+            val identifier = ControlCommandIdentifier.fromByte(data[0])
+                ?: throw IllegalArgumentException("Unknown ControlCommandIdentifier: ${data[0].toHexString()}")
+
+            val value = data.copyOfRange(1, data.size)
+            val trimmed = value.dropLastWhile { it == 0x00.toByte() }.toByteArray()
+            return ControlCommand(identifier, if (trimmed.isEmpty()) byteArrayOf(0x00) else trimmed)
+        }
+    }
+
+    fun toAACPPayload(): ByteArray {
+        val payload = ByteArray(5)
+        payload[0] = this.identifier.value
+        System.arraycopy(this.value, 0, payload, 1, this.value.size.coerceAtMost(4))
+        return payload
+    }
+}
+
+
+enum class ControlCommandIdentifier(val value: Byte) {
+    MIC_MODE(0x01),
+    SCAN(0x02),
+    RESET(0x03),
+    BASIC_DOUBLE_TAP_MODE(0x04),
+    BUTTON_SEND_MODE(0x05),
+    OWNS_CONNECTION(0x06),
+    TAP_INTERVAL(0x07),
+    BUD_ROLE(0x08),
+    DEBUG_GET_DATA(0x09),
+    EAR_DETECTION_CONFIG(0x0A),
+    JITTER_BUFFER(0x0B),
+    DOUBLE_TAP_MODE(0x0C),
+    LISTENING_MODE(0x0D),
+    HEART_RATE_MONITOR_1(0x0E),
+    HEART_RATE_MONITOR_2(0x0F),
+    UNKNOWN10(0x10),
+    SWITCH_CONTROL(0x11),
+    VOICE_TRIGGER(0x12),
+    DOAP_MODE(0x13),
+    SINGLE_CLICK_MODE(0x14),
+    DOUBLE_CLICK_MODE(0x15),
+    CLICK_HOLD_MODE(0x16),
+    DOUBLE_CLICK_INTERVAL(0x17),
+    CLICK_HOLD_INTERVAL(0x18),
+    UNKNOWN19(0x19),
+    LISTENING_MODE_CONFIGS(0x1A),
+    ONE_BUD_ANC_MODE(0x1B),
+    CROWN_ROTATION_DIRECTION(0x1C),
+    UNKNOWN1D(0x1D),
+    AUTO_ANSWER_MODE(0x1E),
+    CHIME_VOLUME(0x1F),
+    SMART_ROUTING_MODE(0x20),
+    UNKNOWN21(0x21),
+    HFP_UPLINK_MODE(0x22),
+    VOLUME_SWIPE_INTERVAL(0x23),
+    CALL_MANAGEMENT_CONFIG(0x24),
+    VOLUME_SWIPE_MODE(0x25),
+    ADAPTIVE_VOLUME_CONFIG(0x26),
+    SOFTWARE_MUTE_CONFIG(0x27),
+    CONVERSATION_DETECT_CONFIG(0x28),
+    SSL(0x29),
+    UNKNOWN2A(0x2A),
+    UNKNOWN2B(0x2B),
+    HEARING_AID(0x2C),
+    UNKNOWN2D(0x2D),
+    AUTO_ANC_STRENGTH(0x2E),
+    HPS_GAIN_SWIPE(0x2F),
+    HRM_STATE(0x30),
+    IN_CASE_TONE_CONFIG(0x31),
+    SIRI_MULTITONE_CONFIG(0x32),
+    HEARING_ASSIST_CONFIG(0x33),
+    ALLOW_OFF_OPTION(0x34),
+    SLEEP_DETECTION_CONFIG(0x35),
+    ALLOW_AUTO_CONNECT(0x36),
+    PPE_TOGGLE_CONFIG(0x37),
+    PPE_CAP_LEVEL_CONFIG(0x38),
+    RAW_GESTURES_CONFIG(0x39),
+    ALLOW_TEMPORARY_MANAGED_PAIRING(0x3A),
+    DYNAMIC_END_OF_CHARGE(0x3B),
+    SYSTEM_SIRI_MODE(0x3C),
+    HEARING_AID_GENERIC(0x3D),
+    UPLINK_EQ_BUD(0x3E),
+    UPLINK_EQ_SOURCE(0x3F),
+    IN_CASE_TONE_VOLUME(0x40),
+    DISABLE_BUTTON_INPUT(0x41),
+    EXTENDED_HOLD_AND_RELEASE(0x42);
+
+    companion object {
+        fun fromByte(byte: Byte): ControlCommandIdentifier? = entries.find { it.value == byte }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/CustomEq.kt

@@ -0,0 +1,30 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+import kotlinx.serialization.Serializable
+
+@Serializable
+data class CustomEq(
+    val state: Int,
+    val low: Int,
+    val mid: Int,
+    val high: Int
+) {
+
+    fun isEnabled(): Boolean {
+        return state == 2
+    }
+
+    fun toAACPPayload(): ByteArray {
+        return byteArrayOf(
+            0x05, 0x00, // length (LE)
+            0x01, state.toByte(),
+            low.toByte(), mid.toByte(), high.toByte()
+        )
+    }
+
+    init {
+        require(low in 0..100) { "low must be between 0 and 100, was $low" }
+        require(mid in 0..100) { "mid must be between 0 and 100, was $mid" }
+        require(high in 0..100) { "high must be between 0 and 100, was $high" }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/Events.kt

@@ -0,0 +1,21 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+sealed interface AppleEvent {
+    data class StemPress(
+        val pressType: StemPressType,
+        val bud: StemPressBud
+    ): AppleEvent
+
+    data class ShowNearbyUi(
+        val sender: String
+    ): AppleEvent
+
+    data class OwnershipToFalseRequest(
+        val sender: String,
+        val reverseTapped: Boolean
+    ): AppleEvent
+
+    data class HeadGesturesResult(
+        val yes: Boolean,
+    )
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/MagicKey.kt

@@ -0,0 +1,10 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+enum class MagicKeyType(val value: Byte) {
+    IRK(0x01), ENC_KEY(0x04);
+
+    companion object {
+        fun fromByte(byte: Byte): MagicKeyType = entries.find { it.value == byte }
+            ?: throw IllegalArgumentException("Unknown MagicKeyType: $byte")
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/Opcodes.kt

@@ -0,0 +1,91 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+sealed interface Opcode { val value: Byte }
+
+data class UnknownOpcode(override val value: Byte): Opcode
+
+enum class ConnectOpcode(override val value: Byte): Opcode {
+    SOMETHING (0x01);
+
+    companion object {
+        fun fromByte(value: Byte): Opcode =
+            entries.firstOrNull { it.value == value }?: UnknownOpcode(value)
+    }
+}
+
+enum class MessageOpcode(override val value: Byte): Opcode {
+    CAPABILITIES_REQUEST(0x01),
+    CAPABILITIES(0x02),
+    BATTERY_INFO_REQUEST(0x03),
+    BATTERY_INFO(0x04),
+    EAR_DETECTION_REQUEST(0x05),
+    EAR_DETECTION(0x06),
+    BUD_ROLE_REQUEST(0x07),
+    BUD_ROLE(0x08),
+    CONTROL_COMMAND(0x09),
+    DEVICE_LIST(0x0B),
+    MAC_ADDRESS(0x0C),
+    AUDIO_SOURCE_REQUEST(0x0D),
+    AUDIO_SOURCE(0x0E),
+    REQUEST_NOTIFICATIONS(0x0F),
+    SMART_ROUTING(0x10),
+    SMART_ROUTING_RESPONSE(0x11),
+    EASY_PAIR_REQUEST(0x12),
+    EASY_PAIR(0x13),
+    CONNECT_PRIORITY_LIST(0x14),
+    TRIANGLE_LINK_STATUS_REQUEST(0x15),
+    TRIANGLE_LINK_STATUS(0x16),
+    BUDDY_COMMAND(0x17),
+    STEM_PRESS(0x19),
+    RENAME(0x1A),
+    TIMESTAMP(0x1B),
+    INFORMATION(0x1D),
+    EXTERNAL_ACCESSORY_SESSION(0x1E),
+    SESSION_STATE(0x1F),
+    REMOTE_FIRMWARE_AUTH(0x20),
+    UNKNOWN_21(0x21),
+    CASE_INFO_REQUEST(0x22),
+    CASE_INFO(0x23),
+    DEVICE_INFO(0x24),
+    CERTIFICATES_REQUEST(0x26),
+    CERTIFICATES(0x27),
+    GYRO_INFO(0x28),
+    SET_COUNTRY_CODE(0x29),
+    STREAM_STATE_INFO(0x2B),
+    GAPA_CHALLENGE(0x2C),
+    CONNECTED_DEVICES_REQUEST(0x2D),
+    CONNECTED_DEVICES(0x2E),
+    MAGIC_KEYS_REQUEST(0x30),
+    MAGIC_KEYS_RESPONSE(0x31),
+    MAGIC_KEYS_2(0x32),
+    UNKNOWN_40(0x40),
+    SMART_ROUTING_V2_INFO(0x44),
+    FAST_CONNECT_COMPLETE(0x45),
+    BUD_SWAP_PROCEDURE(0x47),
+    SWAP_IMMINENT_CONFIRM(0x48),
+    BUD_SWAP_COMPLETE(0x49),
+    SWAP_COMPLETE_CONFIRM(0x4A),
+    CONVERSATION_AWARENESS(0x4B),
+    ADAPTIVE_VOLUME(0x4C),
+    SOURCE_FEATURE_CAPABILITIES(0x4D),
+    FEATURE_PROXCARD_STATUS(0x4E),
+    UARP_DATA(0x4F),
+    PERF_STATS(0x50),
+    SOURCE_CONTEXT(0x52),
+    HEADPHONE_ACCOMMODATION(0x53),
+    SET_BAND_EDGES(0x54),
+    UNKNOWN_55(0x55),
+    USB_SPATIAL_SENSOR_DATA_REQUEST(0x56),
+    SLEEP_DETECTION_UPDATE(0x57),
+    MICROPHONE_STREAM(0x58),
+    DYNAMIC_END_OF_CHARGE(0x59),
+    PERSONAL_TRANSLATION(0x60),
+    SET_FEATURE_FLAGS(0x62),
+    CUSTOM_EQ(0x63),
+    APPLECARE(0x64);
+
+    companion object {
+        fun fromByte(value: Byte): Opcode =
+            entries.firstOrNull { it.value == value }?: UnknownOpcode(value)
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/RTBuddyDescriptor.kt

@@ -0,0 +1,35 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+enum class RTBuddyDescriptor(val value: UInt) {
+    ACOUSTIC(0x00000001u),
+    SCP(0x00000002u),
+    BUDDY(0x00000004u),
+    VIRTUAL_CLI_PRIMARY(0x00000008u),
+    VIRTUAL_CLI_SECONDARY(0x00000010u),
+    APP_DIAGNOSTICS(0x00000020u),
+    LOGGING_TRIGGER(0x00000040u),
+    DEBUG_DATA(0x00000080u),
+    TOUCH(0x00000100u),
+    LOG_CONFIG(0x00000200u),
+    LOG_MSG(0x00000400u),
+    SENSOR(0x00000800u),
+    SWITCH_CONTROL(0x00001000u),
+    MISMATCHED_BUDS(0x00002000u),
+    UNKNOWN_4000(0x00004000u),
+    B2P(0x00008000u),
+    CONTINUITY(0x00010000u),
+    BATTERY_HEALTH(0x00020000u),
+    SENSOR_V2(0x00040000u),
+    OBC_V2(0x00080000u),
+    SENSOR_DATA_WX(0x00100000u),
+    UNKNOWN_00200000(0x00200000u),
+    UNKNOWN_00400000(0x00400000u),
+    DIGITAL_ENGRAVING_INFO(0x00800000u),
+    ACTIVE_MODE_DATA(0x01000000u),
+
+    UNKNOWN(0xFFFFFFFFu); // better way?
+
+    companion object {
+        fun fromValue(value: UInt): RTBuddyDescriptor = entries.firstOrNull { it.value == value } ?: UNKNOWN
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/RTBuddyPayload.kt

@@ -0,0 +1,11 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+sealed interface RTBuddyPayload {
+    val descriptor: RTBuddyDescriptor
+}
+
+data class UnknownBuddyPayload(
+    override val descriptor: RTBuddyDescriptor,
+    val descriptorValue: UInt,
+    val data: ByteArray,
+) : RTBuddyPayload

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/SensorDataWxBuddyPayload.kt

@@ -0,0 +1,9 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+import me.kavishdevar.librepods.bluetooth.aacp.rtbuddy.proto.SensorDataWX
+
+data class SensorDataWxBuddyPayload(
+    val data: SensorDataWX,
+): RTBuddyPayload {
+    override val descriptor: RTBuddyDescriptor = RTBuddyDescriptor.SENSOR_DATA_WX
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/aacp/types/StemPress.kt

@@ -0,0 +1,18 @@
+package me.kavishdevar.librepods.bluetooth.aacp.types
+
+enum class StemPressType(val value: Byte) {
+    SINGLE_PRESS(0x05), DOUBLE_PRESS(0x06), TRIPLE_PRESS(0x07), LONG_PRESS(0x08);
+
+    companion object {
+        fun fromByte(byte: Byte): StemPressType? = entries.find { it.value == byte }
+    }
+}
+
+// TODO: make DeviceComponent, BatteryComponent, and StemPressBud the same with helpers to parse from byte for specific messages
+enum class StemPressBud(val value: Byte) {
+    LEFT(0x01), RIGHT(0x02);
+
+    companion object {
+        fun fromByte(byte: Byte): StemPressBud? = entries.find { it.value == byte }
+    }
+}

android/app/src/main/kotlin/me/kavishdevar/librepods/bluetooth/att/ATTManager.kt

@@ -0,0 +1,159 @@
+/*
+    LibrePods - AirPods liberated from Apple’s ecosystem
+    Copyright (C) 2025 LibrePods contributors
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+package me.kavishdevar.librepods.bluetooth.att
+
+import android.bluetooth.BluetoothSocket
+import android.os.ParcelUuid
+import android.util.Log
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import me.kavishdevar.librepods.devices.Device
+
+enum class ATTHandle(val value: Int) {
+    TRANSPARENCY(0x18),
+    LOUD_SOUND_REDUCTION(0x1B),
+    HEARING_AID(0x2A)
+}
+
+class ATTManager (
+    private val device: Device<*, *, *>
+) {
+    val macParts = device.macAddress.value.split(":")
+    private val TAG = "ATTManager[${macParts[0]}:${macParts[1]}:${macParts[2]}]"
+    private var socket: BluetoothSocket? = null
+    suspend fun readCharacteristic(handle: ATTHandle): ByteArray? {
+        // TODO
+        return null
+        if (socket != null) {
+            Log.d(TAG, "Closing existing socket before reading characteristic")
+            try {
+                socket!!.close()
+                Log.d(TAG, "Existing socket closed successfully")
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            socket = null
+        }
+
+        Log.d(TAG, "Creating new socket for reading characteristic")
+        socket = try {
+            device.createSocket(ParcelUuid.fromString("00000000-0000-0000-0000-000000000000"), 31)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error creating socket: ${e.message}")
+            return null
+        }
+
+        try {
+            socket?.connect()
+            Log.d(TAG, "Socket connected successfully")
+            val output = socket?.outputStream ?: return null
+            Log.d(TAG, "Sending read request for handle: ${handle.value}")
+            val pdu = byteArrayOf(0x0A, handle.value.toByte(), 0x00)
+
+            withContext(Dispatchers.IO) {
+                output.write(pdu)
+                Log.d(TAG, "Read request sent: ${pdu.joinToString(" ") { String.format("%02X", it) }}")
+                output.flush()
+                Log.d(TAG, "Output stream flushed after sending read request")
+            }
+
+            val buffer = ByteArray(1024)
+            val bytesRead = withContext(Dispatchers.IO) {
+                socket?.inputStream?.read(buffer)?: -1
+            }
+            Log.d(TAG, "Read response received, bytes read: ${buffer.copyOfRange(0, bytesRead).toHexString()}")
+            return if (bytesRead > 0) {
+                buffer.copyOfRange(1, bytesRead)
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            Log.e(TAG, "Error during read operation: ${e.message}")
+        } finally {
+            try {
+                Log.d(TAG, "Closing socket after read operation")
+                socket?.close()
+                socket = null
+                Log.d(TAG, "Socket closed successfully after read operation")
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+        return null
+    }
+
+    suspend fun writeCharacteristic(handle: ATTHandle, data: ByteArray): Boolean {
+        return false
+        // todo
+        if (socket != null) {
+            Log.d(TAG, "Closing existing socket before writing characteristic")
+            try {
+                socket!!.close()
+                Log.d(TAG, "Existing socket closed successfully")
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+            socket = null
+        }
+
+        Log.d(TAG, "Creating new socket for writing characteristic")
+        socket = try {
+            device.createSocket(ParcelUuid.fromString("00000000-0000-0000-0000-000000000000"), 31)
+        } catch (e: Exception) {
+            e.printStackTrace()
+            return false
+        }
+        Log.d(TAG, "Socket created successfully, attempting to connect")
+
+        try {
+            socket?.connect()
+            Log.d(TAG, "Socket connected successfully")
+            val output = socket?.outputStream ?: return false
+            Log.d(TAG, "Sending write request for handle: ${handle.value}")
+            val pdu = byteArrayOf(0x12, handle.value.toByte(), 0x00) + data
+
+            withContext(Dispatchers.IO) {
+                output.write(pdu)
+                Log.d(TAG, "Write request sent: ${pdu.joinToString(" ") { String.format("%02X", it) }}")
+                output.flush()
+                Log.d(TAG, "Output stream flushed after sending write request")
+            }
+
+            val buffer = ByteArray(1024)
+            val bytesRead = withContext(Dispatchers.IO) {
+                socket?.inputStream?.read(buffer)?: -1
+            }
+            Log.d(TAG, "Write response received, bytes read: ${buffer.copyOfRange(0, bytesRead).toHexString()}")
+            return bytesRead > 0
+        } catch (e: Exception) {
+            e.printStackTrace()
+        } finally {
+            try {
+                Log.d(TAG, "Closing socket after write operation")
+                socket?.close()
+                socket = null
+                Log.d(TAG, "Socket closed successfully after write operation")
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+        return false
+    }
+}