android: update dialog and add app info to incompatible page

too many emails with absolutely no content

.editorconfig

@@ -0,0 +1,20 @@
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+charset = utf-8
+indent_style = space
+indent_size = 2
+end_of_line = lf
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{md,apib}]
+indent_size = 4
+# In Markdown a trailing double space is interpreted as <br>
+trim_trailing_whitespace = false
+max_line_length = off
+
+[*.{py,java,r,R,kt,xml,kts,h,hpp,cpp,qml}]
+indent_size = 4

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,31 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
- - Distro: [e.g. Ubuntu, KDE Neon, Arch]
- - Version [e.g. 22.04]
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/workflows/ci-android.yml

@@ -0,0 +1,143 @@
+name: Android CI
+
+on:
+  push:
+    branches:
+      - '*'
+    paths:
+      - 'android/**'
+  pull_request:
+    paths:
+      - 'android/**'
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: Branch to build
+        required: true
+        default: main
+  workflow_call:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    outputs:
+      short_sha: ${{ steps.vars.outputs.short_sha }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+          ref: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.branch || github.ref }}
+      - uses: actions/setup-java@v4
+        with:
+          distribution: zulu
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v4
+      - name: Decode keystore
+        run: echo "${{ secrets.RELEASE_KEYSTORE_FILE }}" | base64 --decode > android/release.keystore
+      - name: Setup Android SDK
+        uses: android-actions/setup-android@v3
+      - name: Accept Licenses
+        run: yes | sdkmanager --licenses
+      - name: Install NDK
+        run: sdkmanager "ndk;30.0.14904198"
+      - name: Create local.properties
+        run: |
+          cat <<EOF > android/local.properties
+          RELEASE_STORE_FILE=../release.keystore
+          RELEASE_STORE_PASSWORD=${{ secrets.RELEASE_STORE_PASSWORD }}
+          RELEASE_KEY_ALIAS=${{ secrets.RELEASE_KEY_ALIAS }}
+          RELEASE_KEY_PASSWORD=${{ secrets.RELEASE_KEY_PASSWORD }}
+          EOF
+      - name: Build
+        run: ./gradlew packageReleaseArtifacts
+        working-directory: android
+      - id: vars
+        run: echo "short_sha=$(git rev-parse --short HEAD)" >> $GITHUB_OUTPUT
+      - uses: actions/upload-artifact@v4
+        with:
+          name: apk-release
+          path: release/*release.apk
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: apk-debug
+          path: release/*debug.apk
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: root-module-release
+          path: release/*release.zip
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: root-module-debug
+          path: release/*debug.zip
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: release-bundle
+          path: release/*.aab
+
+  release:
+    if: github.event_name == 'push'
+    runs-on: ubuntu-latest
+    needs: build
+    permissions:
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          fetch-tags: true
+      - uses: actions/download-artifact@v4
+        with:
+          name: apk-release
+          path: artifacts/apk-release
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: apk-debug
+          path: artifacts/apk-debug
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: root-module-release
+          path: artifacts/root-module-release
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: root-module-debug
+          path: artifacts/root-module-debug
+      - id: prev
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          TAG=$(gh release list \
+            --limit 1 \
+            --json tagName \
+            --jq '.[0].tagName')
+
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+      - id: changelog
+        run: |
+          if [ -z "${{ steps.prev.outputs.tag }}" ]; then
+            NOTES=$(git log --pretty=format:"- %s (%h)")
+          else
+            NOTES=$(git log ${{ steps.prev.outputs.tag }}..HEAD --pretty=format:"- %s (%h)")
+          fi
+          echo "notes<<EOF" >> $GITHUB_OUTPUT
+          echo "$NOTES" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+
+      - id: tag
+        run: echo "tag=nightly-${{ needs.build.outputs.short_sha }}" >> $GITHUB_OUTPUT
+
+      - env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release create "${{ steps.tag.outputs.tag }}" \
+            artifacts/**/* \
+            -t "Nightly ${{ needs.build.outputs.short_sha }}" \
+            --notes "${{ steps.changelog.outputs.notes }}" \
+            --prerelease

.github/workflows/ci-linux-rust.yml

@@ -0,0 +1,87 @@
+name: Linux Build & Release
+
+on:
+  push:
+    branches:
+      - linux/rust
+    tags:
+      - 'linux-v*'
+    paths:
+      - 'linux-rust/**'
+      - '.github/workflows/linux-build.yml'
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y pkg-config libdbus-1-dev libpulse-dev appstream just libfuse2
+
+      - name: Install AppImage tools
+        run: |
+          wget -q https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage -O /usr/local/bin/appimagetool
+          wget -q https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage -O /usr/local/bin/linuxdeploy
+          chmod +x /usr/local/bin/{appimagetool,linuxdeploy}
+
+      - name: Install Rust
+        uses: dtolnay/rust-toolchain@stable
+
+      - name: Cache Cargo
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            linux-rust/target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('linux-rust/Cargo.lock') }}
+
+      - name: Build AppImage and Binary
+        working-directory: linux-rust
+        run: |
+          cargo build --release --verbose
+          just
+          mkdir -p dist
+          cp target/release/librepods dist/librepods
+          mv dist/LibrePods-x86_64.AppImage dist/librepods-x86_64.AppImage
+
+      - name: Upload AppImage artifact
+        if: "!startsWith(github.ref, 'refs/tags/linux-v')"
+        uses: actions/upload-artifact@v4
+        with:
+          name: librepods-x86_64.AppImage
+          path: linux-rust/dist/librepods-x86_64.AppImage
+
+      - name: Upload binary artifact
+        if: "!startsWith(github.ref, 'refs/tags/linux-v')"
+        uses: actions/upload-artifact@v4
+        with:
+          name: librepods
+          path: linux-rust/dist/librepods
+
+      - name: Create tarball for Flatpak
+        if: startsWith(github.ref, 'refs/tags/linux-v')
+        working-directory: linux-rust
+        run: |
+          VERSION="${GITHUB_REF_NAME#linux-v}"
+          just tarball "${VERSION}"
+          echo "VERSION=${VERSION}" >> $GITHUB_ENV
+          echo "TAR_PATH=linux-rust/dist/librepods-v${VERSION}-source.tar.gz" >> $GITHUB_ENV
+
+      - name: Create GitHub Release (AppImage + binary + source)
+        if: startsWith(github.ref, 'refs/tags/linux-v')
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: ${{ github.ref_name }}
+          files: |
+            linux-rust/dist/librepods-v${{ env.VERSION }}-source.tar.gz
+            linux-rust/dist/librepods-x86_64.AppImage
+            linux-rust/dist/librepods
+          generate_release_notes: true
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/ci-linux.yml

@@ -0,0 +1,37 @@
+name: Build LibrePods Linux
+
+on:
+  workflow_dispatch:
+#  push:
+#    branches:
+#      - '*'
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y build-essential cmake ninja-build \
+            qt6-base-dev qt6-declarative-dev qt6-svg-dev \
+            qt6-tools-dev qt6-tools-dev-tools qt6-connectivity-dev \
+            libxkbcommon-dev
+
+      - name: Build project
+        working-directory: linux
+        run: |
+          mkdir build
+          cd build
+          cmake .. -G Ninja
+          ninja
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: librepods-linux
+          path: linux/build/librepods

.gitignore

@@ -1,7 +1,12 @@
-testing.py
+release
+.vscode
 .DS_Store
+CMakeLists.txt.user*
+
 # Android Template
 
+
+### Android ###
 # Gradle files
 .gradle/
 build/
@@ -36,19 +41,284 @@ google-services.json
 # Android Profiling
 *.hprof
 
-# Python Template
+### Android Patch ###
+gen-external-apklibs
 
+# Replacement of .externalNativeBuild directories introduced
+# with Android Studio 3.5.
+
+### C++ ###
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+### CLion ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### CLion Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+.idea/**/sonarlint/
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+.idea/**/sonarIssues.xml
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+.idea/**/markdown-navigator.xml
+.idea/**/markdown-navigator-enh.xml
+.idea/**/markdown-navigator/
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+.idea/$CACHE_FILE$
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+.idea/codestream.xml
+
+# Azure Toolkit for IntelliJ plugin
+# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
+.idea/**/azureSettings.xml
+
+### Kotlin ###
+# Compiled class file
+*.class
+
+# Log file
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*
+
+### Linux ###
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+### PyCharm ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+
+# AWS User-specific
+
+# Generated files
+
+# Sensitive or high-churn files
+
+# Gradle
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+
+# Mongo Explorer plugin
+
+# File-based project format
+
+# IntelliJ
+
+# mpeltonen/sbt-idea plugin
+
+# JIRA plugin
+
+# Cursive Clojure plugin
+
+# SonarLint plugin
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+
+# Editor-based Rest Client
+
+# Android studio 3.1+ serialized cache file
+
+### PyCharm Patch ###
+# Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721
+
+# *.iml
+# modules.xml
+# .idea/misc.xml
+# *.ipr
+
+# Sonarlint plugin
+# https://plugins.jetbrains.com/plugin/7973-sonarlint
+
+# SonarQube Plugin
+# https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin
+
+# Markdown Navigator plugin
+# https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced
+
+# Cache file creation bug
+# See https://youtrack.jetbrains.com/issue/JBR-2257
+
+# CodeStream plugin
+# https://plugins.jetbrains.com/plugin/12206-codestream
+
+# Azure Toolkit for IntelliJ plugin
+# https://plugins.jetbrains.com/plugin/8053-azure-toolkit-for-intellij
+
+### Python ###
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
 *$py.class
 
 # C extensions
-*.so
 
 # Distribution / packaging
 .Python
-build/
 develop-eggs/
 dist/
 downloads/
@@ -96,7 +366,6 @@ cover/
 *.pot
 
 # Django stuff:
-*.log
 local_settings.py
 db.sqlite3
 db.sqlite3-journal
@@ -146,10 +415,8 @@ ipython_config.py
 #pdm.lock
 #   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
 #   in version control.
-#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+#   https://pdm.fming.dev/#use-with-ide
 .pdm.toml
-.pdm-python
-.pdm-build/
 
 # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
 __pypackages__/
@@ -200,3 +467,190 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 #.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+### Qt ###
+# C++ objects and libs
+*.so.*
+
+# Qt-es
+object_script.*.Release
+object_script.*.Debug
+*_plugin_import.cpp
+/.qmake.cache
+/.qmake.stash
+*.pro.user
+*.pro.user.*
+*.qbs.user
+*.qbs.user.*
+*.moc
+moc_*.cpp
+moc_*.h
+qrc_*.cpp
+ui_*.h
+*.qmlc
+*.jsc
+Makefile*
+*build-*
+*.qm
+*.prl
+
+# Qt unit tests
+target_wrapper.*
+
+# QtCreator
+*.autosave
+
+# QtCreator Qml
+*.qmlproject.user
+*.qmlproject.user.*
+
+# QtCreator CMake
+CMakeLists.txt.user*
+
+# QtCreator 4.8< compilation database
+compile_commands.json
+
+# QtCreator local machine specific files for imported projects
+*creator.user*
+
+*_qmlcache.qrc
+
+### VisualStudioCode ###
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### VisualStudioCode Patch ###
+# Ignore all local history of files
+.history
+.ionide
+
+### AndroidStudio ###
+# Covers files to be ignored for android development using Android Studio.
+
+# Built application files
+*.ap_
+*.aab
+
+# Files for the ART/Dalvik VM
+*.dex
+
+# Java class files
+
+# Generated files
+bin/
+gen/
+
+# Gradle files
+.gradle
+
+# Signing files
+.signing/
+
+# Local configuration file (sdk path, etc)
+
+# Proguard folder generated by Eclipse
+proguard/
+
+# Log Files
+
+# Android Studio
+/*/build/
+/*/local.properties
+/*/out
+/*/*/build
+/*/*/production
+.navigation/
+*.ipr
+*.swp
+
+# Keystore files
+
+# Google Services (e.g. APIs or Firebase)
+# google-services.json
+
+# Android Patch
+
+# External native build folder generated in Android Studio 2.2 and later
+.externalNativeBuild
+
+# NDK
+obj/
+
+# IntelliJ IDEA
+/out/
+
+# User-specific configurations
+.idea/caches/
+.idea/libraries/
+.idea/shelf/
+.idea/workspace.xml
+.idea/tasks.xml
+.idea/.name
+.idea/compiler.xml
+.idea/copyright/profiles_settings.xml
+.idea/encodings.xml
+.idea/misc.xml
+.idea/modules.xml
+.idea/scopes/scope_settings.xml
+.idea/dictionaries
+.idea/vcs.xml
+.idea/jsLibraryMappings.xml
+.idea/datasources.xml
+.idea/dataSources.ids
+.idea/sqlDataSources.xml
+.idea/dynamic.xml
+.idea/uiDesigner.xml
+.idea/assetWizardSettings.xml
+.idea/gradle.xml
+.idea/jarRepositories.xml
+.idea/navEditor.xml
+
+# Legacy Eclipse project files
+.classpath
+.project
+.cproject
+.settings/
+
+# Mobile Tools for Java (J2ME)
+
+# Package Files #
+
+# virtual machine crash logs (Reference: http://www.java.com/en/download/help/error_hotspot.xml)
+
+## Plugin-specific files:
+
+# mpeltonen/sbt-idea plugin
+
+# JIRA plugin
+
+# Mongo Explorer plugin
+.idea/mongoSettings.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+
+### AndroidStudio Patch ###
+
+!/gradle/wrapper/gradle-wrapper.jar
+
+# End of https://www.toptal.com/developers/gitignore/api/qt,c++,clion,kotlin,python,android,pycharm,androidstudio,visualstudiocode,linux
+linux/.qmlls.ini

AAP Definitions.md

@@ -28,7 +28,7 @@ It also enables the Adaptive Transparency feature. (We can set Adaptive Transpar
 
 # Requesting notifications
 
-This packet is necessary to receive notifications from the AirPods like ear detection, noise control mode, conversation awareness, battery status, etc.
+This packet is necessary to receive notifications from the AirPods like ear detection, noise control mode, conversational awareness, battery status, etc.
 
 *Captured using PacketLogger on an Intel Mac running macOS Sequoia 15.0.1*
 ```plaintext
@@ -122,7 +122,7 @@ If primary is removed, mic will be changed and the secondary will be the new pri
 
 ## Conversational Awareness
 
-AirPods send conversational awareness packets when the person wearing them start speaking. The packet format is as follows:
+AirPods send conversational awareness packets when the person wearing them starts speaking. The packet format is as follows:
 
 ```plaintext
 04 00 04 00 4B 00 02 00 01 [level]
@@ -134,7 +134,57 @@ AirPods send conversational awareness packets when the person wearing them start
 | 03                  | Person Stopped Speaking; increase volume back to normal |
 | Intermediate values | Intermediate volume levels                              |
 | 08/09               | Normal Volume                                           |
+### Reading Conversational Awareness State
 
+After requesting notifications, the AirPods send a packet indicating the current state of Conversational Awareness (CA). This packet is only sent once after notifications are requested, not when the CA state is changed.
+
+The packet format is:
+
+```plaintext
+04 00 04 00 09 00 28 [status] 00 00 00
+```
+
+- `[status]` is a single byte at offset 7 (zero-based), immediately after the header.
+    - `0x01` — Conversational Awareness is **enabled**
+    - `0x02` — Conversational Awareness is **disabled**
+    - Any other value — Unknown/undetermined state
+
+**Example:**
+```plaintext
+04 00 04 00 09 00 28 01 00 00 00
+```
+Here, `01` at the 8th byte (offset 7) means CA is enabled.
+
+## Metadata
+
+This packet contains device information like name, model number, etc. The packet format is:
+
+```plaintext
+04 00 04 00 1d [strings...]
+```
+
+The strings are null-terminated UTF-8 strings in the following order:
+
+1. Bluetooth advertising name (varies in length)
+2. Model number 
+3. Manufacturer
+4. Serial number
+5. Firmware version
+6. Firmware version 2 (the exact same as before??)
+7. Software version   (1.0.0 why would we need it?)
+8. App identifier     (com.apple.accessory.updater.app.71 what?)
+9. Serial number 1
+10. Serial number 2
+11. Unknown numeric value
+12. Encrypted data
+13. Additional encrypted data
+
+Example packet:
+```plaintext
+040004001d0002d5000400416972506f64732050726f004133303438004170706c6520496e632e0051584e524848595850360036312e313836383034303030323030303030302e323731330036312e313836383034303030323030303030302e3237313300312e302e3000636f6d2e6170706c652e6163636573736f72792e757064617465722e6170702e3731004859394c5432454632364a59004833504c5748444a32364b3000363335373533360089312a6567a5400f84a3ca234947efd40b90d78436ae5946748d70273e66066a2589300035333935303630363400```
+
+The packet contains device identification and version information followed by some encrypted data whose format is not known.
+```
 
 # Writing to the AirPods
 
@@ -211,38 +261,53 @@ The level can be any value between 0 and 100, 0 to allow maximum noise (i.e. min
 
 *I find it quite funny how I have greater control over the noise control on the AirPods on non-Apple devices than on Apple devices, becuase on Apple Devices, there are just 3 options More Noise (0), Midway through (50), and Less Noise (100), but here I can set any value between 0 and 100.*
 
-# To-Do List
+## Accessiblity Settings
 
-- [x] Receive Battery Information
-- [x] Set/Receive ANC Modes
-- [x] Set Adaptive Audio Noise settings
-- [x] Receive In-Ear detection Status 
-- [ ] Personalized Volume (idk how this works, if it received data from icloud, or is purely from airpods)
-- [x] Conversational Awareness
-- [x] Ear Detection
-- [ ] Head Gestures
-- [ ] Siri (Voice assistant on long stem press)
-- [ ] Hold and Press configuration (this is really weird, mac sends different packets based on what the current status is, instead of a fixed packet for what the current button state is, like common there's only so many to map out numbers to states)
-- [ ] Head Tracking (i really want this, could be easy, could be difficult, i'll never know because i don't have a device with apple silicon 😭)
-- [x] Case Charging Sounds
-- [x] Rename AirPods
-- [ ] Mute Unmute Calls
-- Accessibilty
-    - [ ] Press Speed
-    - [ ] Press and hold duration
-    - [ ] Noise Cancellation with one AirPod
-    - [ ] Tone Volume
-    - [ ] Toggle Volume Control on Swipe (APP only, i believe)
-    - [ ] Volume Swipe (Normal/Longer/Longest)
-    - [ ] Headphone accomodation (I literally can't tell the difference between any samples played, lol, also, idk if this is something that the mac does)
-    - [ ] Audio Tuning (idk if this is also smth that mac does)
-    - [ ] Customize Transparency Mode (This is gonna take some while to parse, it is 103 bytes :(... probably all the 4 sliders and 1 switch under this is sent as a whole)
+## Headphone Accomodation
+```
+04 00 04 00 53 00 84 00 02 02 [Phone] [Media]
+[EQ1][EQ2][EQ3][EQ4][EQ5][EQ6][EQ7][EQ8]
+duplicated thrice for some reason
+```
+
+| Data                | Type          | Value range                 |
+|---------------------|---------------|-----------------------------|
+| Phone               | Decimal       | 1 (Enabled) or 2 (Disabled) |
+| Media               | Decimal       | 1 (Enabled) or 2 (Disabled) |
+| EQ                  | Little Endian | 0 to 100                    |
+
+## Customize Transparency mode
+
+```
+12 18 00 [enabled]
+<left bud>
+[EQ1][EQ2][EQ3][EQ4][EQ5][EQ6][EQ7][EQ8]
+[Amplification]
+[Tone]
+[Conversation Boost]
+[Ambient Noise Reduction]
+<repeat for right bud>
+```
+
+
+All values are formatted as IEEE 754 floats in little endian order.
+| Data                    | Type          | Range |
+|-------------------------|---------------|-------|
+| Enabled                 | IEEE754 Float | 0/1   |
+| EQ                      | IEEE754 Float | 0-100 |
+| Amplification           | IEEE754 Float | 0-2   |
+| Tone                    | IEEE754 Float | 0-2   |
+| Conversation Boost      | IEEE754 Float | 0/1   |
+| Ambient Noise Reduction | IEEE754 Float | 0-1   |
+| Ambient Noise Reduction | IEEE754 Float | 0-1   |
+
+> [!IMPORTANT]
+> Also send the [Headphone Accomodation](#headphone-accomodation) after this.
 
-# Miscellaneous/Unknown
 
 ## Configure Stem Long Press
 
-I have noted all the packets sent to configure what the press and hold of the steam should do. The packets sent are specific to the current state. And are probably overwritten everytime the AirPods are connected to a new (apple) device that is not synced with icloud (i think)... So, for non-Apple device too, the configuration needs to be stored and overwritten everytime the AirPods are connected to the device. That is the only way to keep the configuration.
+I have noted all the packets sent to configure what the press and hold of the steam should do. The packets sent are specific to the current state. And are probably overwritten everytime the AirPods are connected to a new (apple) device that is not synced with icloud (i think)... So, for non-Apple devices too, the configuration needs to be stored and overwritten everytime the AirPods are connected to the device. That is the only way to keep the configuration.
 
 This is also the only way to control the configuration as the previous state needs to be known, and then the new state can be set. 
 
@@ -310,20 +375,31 @@ The packets sent (based on the previous states) are as follows:
 
 > *i do hate apple for not hardcoding these, like there are literally only 4^2 - ${\binom{4}{1}}$ - $\binom{4}{2}$*
 
-## Request something (Probably Head Positions)
+# Head Tracking
+
+## Start Tracking
+
+This packet initiates head tracking. When sent, the AirPods begin streaming head tracking data (e.g. orientation and acceleration) for live plotting and analysis.
 
 ```plaintext
-04 00 04 00 17 00 00 00 10 00 11 00 08 7C 10 02 42 0B 08 4E 10 02 1A 05 01 40 9C 00 00
+04 00 04 00 17 00 00 00 10 00 10 00 08 A1 02 42 0B 08 0E 10 02 1A 05 01 40 9C 00 00
 ```
 
-Example packet
+## Stop Tracking
 
-```plaintext
-04 00 04 00 17 00 00 00 10 00 43 00 08 ec 07 10 01 1a 3c 0e 00 01 90 95 5d af 86 19 00 00 03 04 43 94 04 9e 6b 01 00 00 00 d5 a2 06 13 eb 13 03 00 f0 ff 01 00 67 83 67 83 67 83 fe ff fd ff 07 00 b3 01 9c 03 65 00 48 74 2c 37 fd 1e 00 00
-```
-
-## Stop whatever was requested
+This packet stops the head tracking data stream.
 
 ```plaintext
 04 00 04 00 17 00 00 00 10 00 11 00 08 7E 10 02 42 0B 08 4E 10 02 1A 05 01 00 00 00 00
 ```
+## Received Head Tracking Sensor Data
+
+Once tracking is active, the AirPods stream sensor packets with the following common structure:
+  
+| Field                    | Offset | Length (bytes) |
+|--------------------------|--------|----------------|
+| orientation 1            | 43     | 2              |
+| orientation 2            | 45     | 2              |
+| orientation 3            | 47     | 2              |
+| Horizontal Acceleration  | 51     | 2              |
+| Vertical Acceleration    | 53     | 2              |

CHANGELOG.md

@@ -0,0 +1,2 @@
+## LibrePods root module changelog
+_[See here](https://github.com/kavishdevar/librepods/releases)_

FUNDING.yml

@@ -0,0 +1 @@
+github: kavishdevar

LICENSE

@@ -631,21 +631,21 @@ to attach them to the start of each source file to most effectively
 state the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
-  <one line to give the program's name and a brief idea of what it does.>
-  Copyright (C) <year>  <name of author>
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
 
-  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
-  (at your option) any later version.
+    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.
+    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/>.
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 

Proximity Pairing Message.md

@@ -0,0 +1,164 @@
+# Bluetooth Low Energy (BLE) - Apple Proximity Pairing Message
+
+This document describes how the AirPods BLE "Proximity Pairing Message" is parsed and interpreted in the application. This message is broadcast by Apple devices (such as AirPods) and contains key information about the device's state, battery, and other properties.
+
+## Overview
+
+When scanning for BLE devices, the application looks for manufacturer data with Apple's ID (`0x004C`). If the data starts with `0x07`, it is identified as a Proximity Pairing Message. The message contains various fields, each representing a specific property of the AirPods.
+
+## Proximity Pairing Message Structure
+
+| Byte Index | Field Name              | Description                                             | Example Value(s)         |
+|------------|-------------------------|---------------------------------------------------------|--------------------------|
+| 0          | Prefix                  | Message type (should be `0x07` for proximity pairing)   | `0x07`                   |
+| 1          | Length                  | Length of the message                                   | `0x12`                   |
+| 2          | Pairing Mode            | `0x01` = Paired, `0x00` = Pairing mode                 | `0x01`, `0x00`           |
+| 3-4        | Device Model            | Big-endian: [3]=high, [4]=low                          | `0x0E20` (AirPods Pro)   |
+| 5          | Status                  | Bitfield, see below                                    | `0x62`                   |
+| 6          | Pods Battery Byte       | Nibbles for left/right pod battery                     | `0xA7`                   |
+| 7          | Flags & Case Battery    | Upper nibble: case battery, lower: flags               | `0xB3`                   |
+| 8          | Lid Indicator           | Bits for lid state and open counter                    | `0x09`                   |
+| 9          | Device Color            | Color code                                             | `0x02`                   |
+| 10         | Connection State        | Enum, see below                                        | `0x04`                   |
+| 11-26      | Encrypted Payload       | 16 bytes, not parsed                                   |                          |
+
+## Field Details
+
+### Device Model
+
+| Value (hex) | Model Name                |
+|-------------|--------------------------|
+| 0x0220      | AirPods 1st Gen          |
+| 0x0F20      | AirPods 2nd Gen          |
+| 0x1320      | AirPods 3rd Gen          |
+| 0x1920      | AirPods 4th Gen          |
+| 0x1B20      | AirPods 4th Gen (ANC)    |
+| 0x0A20      | AirPods Max              |
+| 0x1F20      | AirPods Max (USB-C)      |
+| 0x0E20      | AirPods Pro              |
+| 0x1420      | AirPods Pro 2nd Gen      |
+| 0x2420      | AirPods Pro 2nd Gen (USB-C) |
+
+### Status Byte (Bitfield)
+
+| Bit | Meaning                        | Value if Set |
+|-----|--------------------------------|-------------|
+| 0   | Right Pod In Ear (XOR logic)   | true        |
+| 1   | Right Pod In Ear (XOR logic)   | true        |
+| 2   | Both Pods In Case              | true        |
+| 3   | Left Pod In Ear (XOR logic)    | true        |
+| 4   | One Pod In Case                | true        |
+| 5   | Primary Pod (1=Left, 0=Right)  | true/false  |
+| 6   | This Pod In Case               | true        |
+
+### Ear Detection Logic
+
+The in-ear detection uses XOR logic based on:
+- Whether the right pod is primary (`areValuesFlipped`)
+- Whether this pod is in the case (`isThisPodInTheCase`)
+
+```cpp
+bool xorFactor = areValuesFlipped ^ deviceInfo.isThisPodInTheCase;
+deviceInfo.isLeftPodInEar = xorFactor ? (status & 0x08) != 0 : (status & 0x02) != 0;  // Bit 3 or 1
+deviceInfo.isRightPodInEar = xorFactor ? (status & 0x02) != 0 : (status & 0x08) != 0; // Bit 1 or 3
+```
+
+### Primary Pod
+
+Determined by bit 5 of the status byte:
+- `1` = Left pod is primary
+- `0` = Right pod is primary
+
+This affects:
+1. Battery level interpretation (which nibble corresponds to which pod)
+2. Microphone assignment
+3. Ear detection logic
+
+### Microphone Status
+
+The active microphone is determined by:
+```cpp
+deviceInfo.isLeftPodMicrophone = primaryLeft ^ deviceInfo.isThisPodInTheCase;
+deviceInfo.isRightPodMicrophone = !primaryLeft ^ deviceInfo.isThisPodInTheCase;
+```
+
+### Pods Battery Byte
+
+- Upper nibble: one pod battery (depends on primary)
+- Lower nibble: other pod battery
+
+| Value | Meaning         |
+|-------|----------------|
+| 0x0-0x9 | 0-90% (x10)  |
+| 0xA-0xE | 100%         |
+| 0xF     | Not available|
+
+### Flags & Case Battery Byte
+
+- Upper nibble: case battery (same encoding as pods)
+- Lower nibble: flags
+
+#### Flags (Lower Nibble)
+
+| Bit | Meaning                  |
+|-----|--------------------------|
+| 0   | Right Pod Charging (XOR) |
+| 1   | Left Pod Charging (XOR)  |
+| 2   | Case Charging            |
+
+### Lid Indicator
+
+| Bits | Meaning                |
+|------|------------------------|
+| 0-2  | Lid Open Counter       |
+| 3    | Lid State (0=Open, 1=Closed) |
+
+### Device Color
+
+| Value | Color        |
+|-------|-------------|
+| 0x00  | White       |
+| 0x01  | Black       |
+| 0x02  | Red         |
+| 0x03  | Blue        |
+| 0x04  | Pink        |
+| 0x05  | Gray        |
+| 0x06  | Silver      |
+| 0x07  | Gold        |
+| 0x08  | Rose Gold   |
+| 0x09  | Space Gray  |
+| 0x0A  | Dark Blue   |
+| 0x0B  | Light Blue  |
+| 0x0C  | Yellow      |
+| 0x0D+ | Unknown     |
+
+### Connection State
+
+| Value | State         |
+|-------|--------------|
+| 0x00  | Disconnected |
+| 0x04  | Idle         |
+| 0x05  | Music        |
+| 0x06  | Call         |
+| 0x07  | Ringing      |
+| 0x09  | Hanging Up   |
+| 0xFF  | Unknown      |
+
+## Example Message
+
+| Byte Index | Example Value | Description                |
+|------------|--------------|----------------------------|
+| 0          | 0x07         | Proximity Pairing Message  |
+| 1          | 0x12         | Length                     |
+| 2          | 0x01         | Paired                     |
+| 3-4        | 0x0E 0x20    | AirPods Pro                |
+| 5          | 0x62         | Status                     |
+| 6          | 0xA7         | Pods Battery               |
+| 7          | 0xB3         | Flags & Case Battery       |
+| 8          | 0x09         | Lid Indicator              |
+| 9          | 0x02         | Device Color               |
+| 10         | 0x04         | Connection State (Idle)    |
+
+---
+
+For further details, see [`BleManager`](linux/ble/blemanager.cpp) and [`BleScanner`](linux/ble/blescanner.cpp).

README.md

@@ -1,51 +1,187 @@
-# ALN - AirPods like Normal
-*Bringing Apple-only features to Linux and Android for seamless AirPods functionality!*
-### Check out the packet definitions at [AAP Definitions](/AAP%20Definitions.md)
+<p align="center">
+  <img src="https://img.shields.io/github/stars/kavishdevar/librepods?style=for-the-badge&logoColor=white" />
+  <img src="https://img.shields.io/github/license/kavishdevar/librepods?style=for-the-badge" />
+  <img src="https://img.shields.io/github/v/release/kavishdevar/librepods?style=for-the-badge&logoColor=white&label=Release" />
+  <img src="https://img.shields.io/github/downloads/kavishdevar/librepods/total?style=for-the-badge&label=Downloads" />
+  <img src="https://img.shields.io/github/issues/kavishdevar/librepods?style=for-the-badge" />
+  
+  <a href="https://discord.gg/HhG4ycVum4">
+    <img src="https://img.shields.io/discord/1441416992027574375?style=for-the-badge&logoColor=white&color=5865F2&label=Discord" />
+  </a>
+</p>
 
-## Currently supported device(s)
-- AirPods Pro 2
+>[!IMPORTANT]
+Development paused due to lack of time until 17th May 2026 (JEE Advanced). PRs and issues might not be responded to until then.
 
-## Implemented Features
+![LibrePods Banner](./imgs/banner.png)
 
-| Feature | Linux | Android |
-| --- | --- | --- |
-| Ear Detection | ✅ | ✅ |
-| Conversational Awareness | ✅ | ✅ |
-| Setting Noise Control | ✅ | ✅ |
-| Battery Level | ✅ | ✅ |
-| Rename AirPods | ✅ | ❌ |
-| Adjust Adaptive Audio | ❌ | ✅ |
+# What is LibrePods?
 
+LibrePods unlocks Apple's exclusive AirPods features on non-Apple devices. Get access to noise control modes, adaptive transparency, ear detection, hearing aid, customized transparency mode, battery status, and more - all the premium features you paid for but Apple locked to their ecosystem.
+
+# Device Compatibility
+
+| Status | Device                | Features                                                   |
+| ------ | --------------------- | ---------------------------------------------------------- |
+| ✅      | AirPods Pro (2nd Gen) | Fully supported and tested                                 |
+| ✅      | AirPods Pro (3rd Gen) | Fully supported (except heartrate monitoring)              |
+| ✅      | AirPods Max           | Fully supported (client shows unsupported features)        |
+| ⚠️      | Other AirPods models  | Basic features (battery status, ear detection) should work |
+
+Most features should work with any AirPods. Currently, I've only got AirPods Pro 2 to test with. But, I believe the protocol remains the same for all other AirPods (based on analysis of the bluetooth stack on macOS).
+
+# Key Features
+
+- **Noise Control Modes**: Easily switch between noise control modes without having to reach out to your AirPods to long press
+- **Ear Detection**: Controls your music automatically when you put your AirPods in or take them out, and switch to phone speaker when you take them out
+- **Battery Status**: Accurate battery levels
+- **Head Gestures**: Answer calls just by nodding your head
+- **Conversational Awareness**: Volume automatically lowers when you speak
+- **Hearing Aid\***
+- **Customize Transparency Mode\***
+- **Multi-device connectivity\*** (upto 2 devices)
+- **Other customizations**:
+  - Rename your AirPods
+  - Customize long-press actions
+  - All accessibility settings
+  - And more!
+
+&ast; Features marked with an asterisk require the VendorID to be change to that of Apple.
+
+# Platform Support
 
 ## Linux
-Check out the README file in [linux](/linux) folder for more info.
+for the old version see the [Linux README](./linux/README.md). (doesn't have many features, maintainer didn't have time to work on it)
 
-This tray app communicates with a daemon with the help of a UNIX socket. The daemon is responsible for the actual communication with the AirPods. The tray app is just a frontend for the daemon, that does ear-detection, conversational awareness, setting the noise-cancellation mode, and more.
+new version in development ([#241](https://github.com/kavishdevar/librepods/pull/241))
 
-![Tray Battery App](/linux/imgs/tray-icon-hover.png)
-![Tray Noise Control Mode Menu](/linux/imgs/tray-icon-menu.png)
+![new version](https://github.com/user-attachments/assets/86b3c871-89a8-4e49-861a-5119de1e1d28)
 
 ## Android
 
-> Currently, there's a [bug on android](https://issuetracker.google.com/issues/371713238) that prevents this from working (psst, go upvote!)
+### Screenshots
 
-But once that's fixed, or you have fixed the issue using root, download the APK, and you're off!
+|                                                                                         |                                                    |                                                                              |
+| --------------------------------------------------------------------------------------- | -------------------------------------------------- | ---------------------------------------------------------------------------- |
+| ![Settings 1](./android/imgs/settings-1.png)                                            | ![Settings 2](./android/imgs/settings-2.png)       | ![Debug Screen](./android/imgs/debug.png)                                    |
+| ![Battery Notification and QS Tile for NC Mode](./android/imgs/notification-and-qs.png) | ![Popup](./android/imgs/popup.png)                 | ![Head Tracking and Gestures](./android/imgs/head-tracking-and-gestures.png) |
+| ![Long Press Configuration](./android/imgs/long-press.png)                              | ![Widget](./android/imgs/widget.png)               | ![Customizations 1](./android/imgs/customizations-1.png)                     |
+| ![Customizations 2](./android/imgs/customizations-2.png)                                | ![accessibility](./android/imgs/accessibility.png) | ![transparency](./android/imgs/transparency.png)                             |
+| ![hearing-aid](./android/imgs/hearing-aid.png)                                          | ![hearing-test](./android/imgs/hearing-test.png)   | ![hearing-aid-adjustments](./android/imgs/hearing-aid-adjustments.png)       |
 
-I don't know how to write READMEs for android apps, because they're just that, apps. So, here are two screenshots of the app:
 
-![AirPods Settings](/android/imgs/settings.png)
-![Debugging View](/android/imgs/debug.png)
+here's a very unprofessional demo video
 
-> Quick Tile to toggle Conversational Awareness and to switch Noise Control modes, and Battery Widget (App and AndroidSystemIntelligence)/Notification coming soon!!
+https://github.com/user-attachments/assets/43911243-0576-4093-8c55-89c1db5ea533
+
+### Root Requirement
+
+The app needs root because of a bug in the Android Bluetooth stack Fluoride/non-compliance of Apple with Bluetooth standards. You must have Xposed installed for the app to workaround this bug and connect to AirPods. 
+
+[https://issuetracker.google.com/issues/371713238](https://issuetracker.google.com/issues/371713238)
+
+Please do not comment in the thread. The issue has already been resolved and should be available in Android 17 for all devices. 
+
+However, if you are using ColorOS/OxygenOS 16, Android 16 QPR3 on Pixel (ensure you're on the latest Play system update), you don't need root for most features.
+
+> [!IMPORTANT]
+> This workaround with Xposed is not guaranteed to work on all devices.
+
+Features requiring the VendorID hook will still require root. These features include customizing transparency mode, setting up hearing aid, and use Bluetooth Multipoint.
+
+### Troubleshooting steps for common errors
+- Ensure the correct scope is set in LSPosed/Vector.
+- Ensure there is no root-hiding module preventing the hook from loading on the Bluetooth app.
+- Restart your phone after confirming the scope.
+
+### A few notes
+
+- Due to recent AirPods' firmware upgrades, you must enable `Off listening mode` to switch to `Off`. This is because in this mode, loud sounds are not reduced.
+
+- If you have take both AirPods out, the app will automatically switch to the phone speaker. But, Android might keep on trying to connect to the AirPods because the phone is still connected to them, just the A2DP profile is not connected. The app tries to disconnect the A2DP profile as soon as it detects that Android has connected again if they're not in the ear.
+
+- When renaming your AirPods through the app, you'll need to re-pair them with your phone for the name change to take effect. This is a limitation of how Bluetooth device naming works on Android.
+
+- If you want the AirPods icon and battery status to show in Android Settings app, install the app as a system app by using the root module.
+
+# Changing VendorID in the DID profile to that of Apple
+
+Turns out, if you change the VendorID in DID Profile to that of Apple, you get access to several special features!
+
+You can do this on Linux by editing the DeviceID in `/etc/bluetooth/main.conf`. Add this line to the config file `DeviceID = bluetooth:004C:0000:0000`. For android you can enable the `act as Apple device` setting in the app's settings.
+
+## Multi-device Connectivity
+
+Upto two devices can be simultaneously connected to AirPods, for audio and control both. Seamless connection switching. The same notification shows up on Apple device when Android takes over the AirPods as if it were an Apple device ("Move to iPhone"). Android also shows a popup when the other device takes over.
+
+## Accessibility Settings and Hearing Aid
+
+Accessibility settings like customizing transparency mode (amplification, balance, tone, conversation boost, and ambient noise reduction), and loud sound reduction can be configured.
+
+All hearing aid customizations can be done from Android (linux soon), including setting the audiogram result. The app doesn't provide a way to take a hearing test because it requires much more precision. It is much better to use an already available audiogram result. 
+
+# Supporters
+
+A huge thank you to everyone supporting the project!
+- @davdroman
+- @tedsalmon
+- @wiless
+- @SmartMsg
+- @lunaroyster
+- @ressiwage
+
+# Special thanks
+- @tyalie for making the first documentation on the protocol! ([tyalie/AAP-Protocol-Definition](https://github.com/tyalie/AAP-Protocol-Defintion))
+- @rithvikvibhu and folks over at lagrangepoint for helping with the hearing aid feature ([gist](https://gist.github.com/rithvikvibhu/45e24bbe5ade30125f152383daf07016))
+- @devnoname120 for helping with the first root patch
+- @timgromeyer for making the first version of the linux app
+- @hackclub for hosting [High Seas](https://highseas.hackclub.com) and [Low Skies](https://low-skies.hackclub.com)!
+
+# Alternates for other platforms:
+- CAPod - A companion app for AirPods on Android. ([play store](https://play.google.com/store/apps/details?id=eu.darken.capod) | [source code](https://github.com/d4rken-org/capod)). Use this if you're using Android version 16 QPR3 or below and are not rooted.
+- MagicPods for Steam Deck ([website](https://magicpods.app/steamdeck/))
+- MagicPods - if you're looking for "LibrePods for Windows"  ([ms store](https://apps.microsoft.com/store/detail/9P6SKKFKSHKM) [installer](https://magicpods.app/installer/MagicPods.appinstaller) | [website](https://magicpods.app/))
+
+# Nightly/Development Builds
+
+Want to try the latest features before they're officially released? You can grab nightly builds from GitHub Actions:
+
+### Android
+1. Go to the [Actions tab](https://github.com/kavishdevar/librepods/actions/workflows/ci-android.yml)
+2. Click on the most recent successful workflow run
+3. Scroll down to **Artifacts** and download the **Debug APK** zip file
+4. Extract the zip and install the `.apk` on your device
+
+> [!NOTE]
+> You need to be signed in to GitHub to download artifacts. Nightly builds are debug-signed and may not auto-update. You may need to uninstall the stable version first.
+
+### Linux (Rust)
+1. Go to the [Actions tab](https://github.com/kavishdevar/librepods/actions/workflows/ci-linux-rust.yml)
+2. Click on the most recent successful workflow run
+3. Download the **librepods-x86_64.AppImage** or **librepods** binary from **Artifacts**
+
+> [!WARNING]
+> Nightly builds are unstable and may contain bugs. Use at your own risk.
+
+# Star History
+
+<a href="https://www.star-history.com/#kavishdevar/librepods&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" />
+ </picture>
+</a>
 
 # License
 
-AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
-Copyright (C) 2024 Kavish Devar
+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, version 3 of the License.
+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
@@ -53,4 +189,6 @@ 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 over [here](/LICENSE). If not, see <https://www.gnu.org/licenses/>.
+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.

android/.gitignore

@@ -1,3 +1,4 @@
+crowdin.yml
 *.iml
 .gradle
 /local.properties

android/README.md

@@ -1,9 +0,0 @@
-# Android App for ALN
-
-> Sorry, I don't know how to write READMEs for android apps, because they're just that, apps. So, here are 2 screenshots of the app:
-
-## Settings Screen
-![Settings Screen](/android/imgs/settings.png)
-
-## Debug Screen
-![Debug Screen](/android/imgs/debug.png)

android/app/build.gradle.kts

@@ -1,63 +1,227 @@
+import java.util.Properties
+
+val appVersionName = "0.2.4"
+
 plugins {
     alias(libs.plugins.android.application)
-    alias(libs.plugins.kotlin.android)
     alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.aboutLibraries)
+//    alias(libs.plugins.hilt)
     id("kotlin-parcelize")
 }
 
+val props = Properties().apply {
+    load(rootProject.file("local.properties").inputStream())
+}
+
 android {
-    namespace = "me.kavishdevar.aln"
-    compileSdk = 34
+    signingConfigs {
+        create("release") {
+            storeFile = file(props["RELEASE_STORE_FILE"] as String)
+            storePassword = props["RELEASE_STORE_PASSWORD"] as String
+            keyAlias = props["RELEASE_KEY_ALIAS"] as String
+            keyPassword = props["RELEASE_KEY_PASSWORD"] as String
+        }
+    }
+    namespace = "me.kavishdevar.librepods"
+    compileSdk = 37
 
     defaultConfig {
-        applicationId = "me.kavishdevar.aln"
-        minSdk = 28
-        targetSdk = 35
-        versionCode = 1
-        versionName = "1.0"
-
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        applicationId = "me.kavishdevar.librepods"
+        minSdk = 33
+        targetSdk = 37
+        versionCode = 40
+        versionName = appVersionName
     }
-
     buildTypes {
         release {
-            isMinifyEnabled = false
+            isMinifyEnabled = true
+            isShrinkResources = true
             proguardFiles(
-                getDefaultProguardFile("proguard-android-optimize.txt"),
-                "proguard-rules.pro"
+                getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro"
             )
+            externalNativeBuild {
+                cmake {
+                    arguments += "-DCMAKE_BUILD_TYPE=Release"
+                }
+            }
+            buildConfigField("Boolean", "PLAY_BUILD", "false")
+            signingConfig = signingConfigs.getByName("release")
+        }
+        debug {
+            buildConfigField("Boolean", "PLAY_BUILD", "false")
+            signingConfig = signingConfigs.getByName("release")
+            versionNameSuffix = "-debug"
+        }
+        create("playRelease") {
+            initWith(getByName("release"))
+            buildConfigField("Boolean", "PLAY_BUILD", "true")
+            versionNameSuffix = "-play"
+        }
+        create("playDebug") {
+            initWith(getByName("debug"))
+            buildConfigField("Boolean", "PLAY_BUILD", "true")
+            versionNameSuffix = "-youshouldnothavethis"
         }
     }
     compileOptions {
-        sourceCompatibility = JavaVersion.VERSION_1_8
-        targetCompatibility = JavaVersion.VERSION_1_8
-    }
-    kotlinOptions {
-        jvmTarget = "1.8"
+        sourceCompatibility = JavaVersion.VERSION_21
+        targetCompatibility = JavaVersion.VERSION_21
     }
     buildFeatures {
         compose = true
+        viewBinding = true
+        buildConfig = true
+    }
+    androidResources {
+        generateLocaleConfig = true
+    }
+    externalNativeBuild {
+        cmake {
+            path = file("src/main/cpp/CMakeLists.txt")
+            version = "3.22.1"
+        }
+    }
+    sourceSets {
+        getByName("main") {
+            res.directories += "src/main/res-apple"
+        }
+    }
+
+    ndkVersion = "30.0.14904198"
+
+    flavorDimensions += "env"
+
+    productFlavors {
+        create("normal") {
+            dimension = "env"
+            externalNativeBuild {
+                cmake {
+                    arguments += "-DIS_XPOSED=OFF"
+                }
+            }
+        }
+        create("xposed") {
+            dimension = "env"
+            externalNativeBuild {
+                cmake {
+                    arguments += "-DIS_XPOSED=ON"
+                }
+            }
+        }
     }
 }
 
 dependencies {
+    implementation(platform(libs.androidx.compose.bom))
     implementation(libs.accompanist.permissions)
-    implementation(libs.hiddenapibypass)
     implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.process)
     implementation(libs.androidx.lifecycle.runtime.ktx)
     implementation(libs.androidx.activity.compose)
-    implementation(platform(libs.androidx.compose.bom))
     implementation(libs.androidx.ui)
     implementation(libs.androidx.ui.graphics)
     implementation(libs.androidx.ui.tooling.preview)
     implementation(libs.androidx.material3)
     implementation(libs.annotations)
     implementation(libs.androidx.navigation.compose)
-    testImplementation(libs.junit)
-    androidTestImplementation(libs.androidx.junit)
-    androidTestImplementation(libs.androidx.espresso.core)
-    androidTestImplementation(platform(libs.androidx.compose.bom))
-    androidTestImplementation(libs.androidx.ui.test.junit4)
-    debugImplementation(libs.androidx.ui.tooling)
-    debugImplementation(libs.androidx.ui.test.manifest)
-}
+    implementation(libs.androidx.constraintlayout)
+    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.m3)
+    implementation(libs.backdrop)
+//    implementation(libs.hilt)
+//    implementation(libs.hilt.compiler)
+    add("xposedCompileOnly", libs.libxposed.api)
+    add("xposedImplementation", libs.libxposed.service)
+    add("playReleaseImplementation", libs.billing)
+}
+
+aboutLibraries {
+    export {
+        prettyPrint = true
+        excludeFields = listOf("generated")
+        outputFile = file("src/main/res/raw/aboutlibraries.json")
+    }
+}
+
+val rootModuleDir = rootProject.file("../root-module-manual")
+val releaseDir = rootProject.file("../release")
+
+fun cap(s: String) = s.replaceFirstChar { it.uppercase() }
+
+fun registerRootModuleZipTask(
+    name: String,
+    flavor: String,
+    buildType: String
+) = tasks.register<Zip>(name) {
+
+    val variantTask = "assemble${cap(flavor)}${cap(buildType)}"
+    dependsOn(variantTask)
+
+    val apkPath = "outputs/apk/$flavor/$buildType/app-$flavor-$buildType.apk"
+
+    from(rootModuleDir)
+
+    duplicatesStrategy = DuplicatesStrategy.WARN
+
+    from(layout.buildDirectory.file(apkPath)) {
+        into("system/priv-app/LibrePods")
+        rename { "LibrePods.apk" }
+    }
+
+    archiveFileName.set("LibrePods-FOSS-v$appVersionName-$buildType.zip")
+    destinationDirectory.set(layout.buildDirectory.dir("outputs/rootModuleZips"))
+}
+
+val zipRelease = registerRootModuleZipTask(
+    "zipXposedReleaseModule",
+    "xposed",
+    "release"
+)
+
+val zipDebug = registerRootModuleZipTask(
+    "zipXposedDebugModule",
+    "xposed",
+    "debug"
+)
+
+val collect = tasks.register<Copy>("collectReleaseArtifacts") {
+
+    dependsOn(
+        zipRelease,
+        zipDebug,
+        "bundleXposedPlayRelease"
+    )
+
+    into(releaseDir)
+
+    from(layout.buildDirectory.dir("outputs/apk/xposed/release")) {
+        include("*.apk")
+        rename(".*", "LibrePods-FOSS-v$appVersionName-release.apk")
+    }
+
+    from(layout.buildDirectory.dir("outputs/apk/xposed/debug")) {
+        include("*.apk")
+        rename(".*", "LibrePods-FOSS-v$appVersionName-debug.apk")
+    }
+
+    from(layout.buildDirectory.dir("outputs/bundle/xposedPlayRelease")) {
+        include("*.aab")
+    }
+
+    from(layout.buildDirectory.dir("outputs/rootModuleZips")) {
+        include("*.zip")
+    }
+}
+
+tasks.register("packageReleaseArtifacts") {
+    dependsOn(collect)
+}

android/app/proguard-rules.pro

@@ -18,4 +18,6 @@
 
 # If you keep the line number information, uncomment this to
 # hide the original source file name.
-#-renamesourcefileattribute SourceFile
+#-renamesourcefileattribute SourceFile
+
+-keep class me.kavishdevar.librepods.utils.KotlinModule { *; }

android/app/release/output-metadata.json

@@ -1,37 +0,0 @@
-{
-  "version": 3,
-  "artifactType": {
-    "type": "APK",
-    "kind": "Directory"
-  },
-  "applicationId": "me.kavishdevar.aln",
-  "variantName": "release",
-  "elements": [
-    {
-      "type": "SINGLE",
-      "filters": [],
-      "attributes": [],
-      "versionCode": 1,
-      "versionName": "1.0",
-      "outputFile": "app-release.apk"
-    }
-  ],
-  "elementType": "File",
-  "baselineProfiles": [
-    {
-      "minApi": 28,
-      "maxApi": 30,
-      "baselineProfiles": [
-        "baselineProfiles/1/app-release.dm"
-      ]
-    },
-    {
-      "minApi": 31,
-      "maxApi": 2147483647,
-      "baselineProfiles": [
-        "baselineProfiles/0/app-release.dm"
-      ]
-    }
-  ],
-  "minSdkVersionForDexing": 28
-}

android/app/src/androidTest/java/me/kavishdevar/aln/ExampleInstrumentedTest.kt

@@ -1,24 +0,0 @@
-package me.kavishdevar.aln
-
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.ext.junit.runners.AndroidJUnit4
-
-import org.junit.Test
-import org.junit.runner.RunWith
-
-import org.junit.Assert.*
-
-/**
- * Instrumented test, which will execute on an Android device.
- *
- * See [testing documentation](http://d.android.com/tools/testing).
- */
-@RunWith(AndroidJUnit4::class)
-class ExampleInstrumentedTest {
-    @Test
-    fun useAppContext() {
-        // Context of the app under test.
-        val appContext = InstrumentationRegistry.getInstrumentation().targetContext
-        assertEquals("me.kavishdevar.aln", appContext.packageName)
-    }
-}

android/app/src/main/AndroidManifest.xml

@@ -2,58 +2,157 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools">
 
+    <uses-feature
+        android:name="android.hardware.telephony"
+        android:required="false" />
+
     <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"
+        tools:ignore="ForegroundServicesPolicy" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
     <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
-    <uses-permission android:name="android.permission.BLUETOOTH_PRIVILEGED"
+    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
+    <uses-permission
+        android:name="android.permission.BLUETOOTH_PRIVILEGED"
         tools:ignore="ProtectedPermissions" />
-    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN"
+    <uses-permission
+        android:name="android.permission.MODIFY_PHONE_STATE"
+        tools:ignore="ProtectedPermissions" />
+    <uses-permission
+        android:name="android.permission.LOCAL_MAC_ADDRESS"
+        tools:ignore="ProtectedPermissions" />
+    <uses-permission
+        android:name="android.permission.INTERACT_ACROSS_USERS"
         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" />-->
+<!--    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"-->
+<!--        android:maxSdkVersion="30" />-->
+    <uses-permission android:name="com.android.vending.BILLING" />
 
     <application
+        android:name=".LibrePodsApplication"
         android:allowBackup="true"
         android:dataExtractionRules="@xml/data_extraction_rules"
+        android:enableOnBackInvokedCallback="true"
         android:fullBackupContent="@xml/backup_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.ALN"
-        android:enableOnBackInvokedCallback="true"
-        tools:targetApi="31"
-        tools:ignore="UnusedAttribute">
+        android:theme="@style/Theme.LibrePods"
+        android:description="@string/app_description"
+        tools:ignore="UnusedAttribute" >
+        <receiver
+            android:name=".presentation.widgets.NoiseControlWidget"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/noise_control_widget_info" />
+        </receiver>
+
+        <receiver
+            android:name=".presentation.widgets.BatteryWidget"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/battery_widget_info" />
+        </receiver>
 
         <activity
             android:name=".MainActivity"
             android:exported="true"
-            android:theme="@style/Theme.ALN">
+            android:theme="@style/Theme.LibrePods">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
+            <!-- <intent-filter android:autoVerify="true">
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+                <data android:scheme="librepods"
+                    android:host="add-magic-keys" />
+            </intent-filter> -->
         </activity>
 
+        <activity
+            android:name=".QuickSettingsDialogActivity"
+            android:exported="false"
+            android:theme="@style/Theme.TransparentDialog"
+            android:launchMode="singleTask"
+            android:excludeFromRecents="true"
+            android:taskAffinity=""
+             />
+
         <service
-            android:name=".AirPodsService"
+            android:name=".services.AirPodsService"
             android:enabled="true"
             android:exported="true"
             android:foregroundServiceType="connectedDevice"
             android:permission="android.permission.BLUETOOTH_CONNECT" />
-
-<!--        <receiver android:name=".StartupReceiver"-->
+        <service
+            android:name=".services.AirPodsQSService"
+            android:exported="true"
+            android:icon="@drawable/airpods"
+            android:label="ANC Mode"
+            android:permission="android.permission.BIND_QUICK_SETTINGS_TILE">
+            <intent-filter>
+                <action android:name="android.service.quicksettings.action.QS_TILE" />
+            </intent-filter>
+        </service>
+<!--        <service-->
+<!--            android:name=".services.AppListenerService"-->
+<!--            android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE"-->
 <!--            android:exported="true">-->
 <!--            <intent-filter>-->
-<!--                <action android:name="android.bluetooth.device.action.ACL_CONNECTED" />-->
-<!--                <action android:name="android.bluetooth.device.action.ACL_DISCONNECTED" />-->
-<!--                <action android:name="android.bluetooth.adapter.action.CONNECTION_STATE_CHANGED" />-->
-<!--                <action android:name="android.bluetooth.device.action.BOND_STATE_CHANGED" />-->
-<!--                <action android:name="android.bluetooth.device.action.NAME_CHANGED" />-->
-<!--                <action android:name="android.intent.action.BOOT_COMPLETED" />-->
-<!--                <action android:name="android.bluetooth.adapter.action.STATE_CHANGED" />-->
+<!--                <action android:name="android.accessibilityservice.AccessibilityService" />-->
 <!--            </intent-filter>-->
-<!--        </receiver>-->
+<!--            <meta-data-->
+<!--                android:name="android.accessibilityservice"-->
+<!--                android:resource="@xml/app_listener_service_config" />-->
+<!--        </service>-->
+        <receiver
+            android:name=".receivers.BootReceiver"
+            android:enabled="true"
+            android:exported="true"
+            android:label="@string/app_name">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
+            </intent-filter>
+        </receiver>
+
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="${applicationId}.provider"
+            android:exported="false"
+            android:grantUriPermissions="true">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/file_paths" />
+        </provider>
     </application>
-</manifest>
+
+</manifest>

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

@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project("l2c_fcr_hook")
+set(CMAKE_CXX_STANDARD 23)
+
+option(IS_XPOSED "Build Xposed components" OFF)
+
+add_library(bluetooth_socket SHARED
+        bluetooth_socket.cpp
+)
+
+target_compile_options(bluetooth_socket PRIVATE
+        -O2
+        -fvisibility=hidden
+)
+
+target_link_options(bluetooth_socket PRIVATE
+        -Wl,--strip-all
+        -Wl,--gc-sections
+)
+
+target_link_libraries(bluetooth_socket
+        android
+        log
+)
+
+if(IS_XPOSED)
+
+    set(XPOSED_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../xposed/cpp)
+
+    add_library(l2c_fcr_hook SHARED
+            ${XPOSED_SRC_DIR}/l2c_fcr_hook.cpp
+
+            ${XPOSED_SRC_DIR}/xz/xz_crc32.c
+            ${XPOSED_SRC_DIR}/xz/xz_crc64.c
+            ${XPOSED_SRC_DIR}/xz/xz_sha256.c
+            ${XPOSED_SRC_DIR}/xz/xz_dec_stream.c
+            ${XPOSED_SRC_DIR}/xz/xz_dec_lzma2.c
+            ${XPOSED_SRC_DIR}/xz/xz_dec_bcj.c
+    )
+
+    target_include_directories(l2c_fcr_hook PRIVATE
+            ${XPOSED_SRC_DIR}
+            ${XPOSED_SRC_DIR}/xz
+    )
+
+    target_compile_definitions(l2c_fcr_hook PRIVATE
+            XZ_DEC_X86
+            XZ_DEC_ARM
+            XZ_DEC_ARMTHUMB
+            XZ_DEC_ARM64
+            XZ_DEC_ANY_CHECK
+            XZ_USE_CRC64
+            XZ_USE_SHA256
+            XZ_DEC_CONCATENATED
+    )
+
+    target_link_libraries(l2c_fcr_hook
+            android
+            log
+    )
+
+endif()

android/app/src/main/cpp/bluetooth_socket.cpp

@@ -0,0 +1,68 @@
+#include <jni.h>
+#include <pthread.h>
+#include <array>
+#include <string>
+
+static JavaVM* gVm = nullptr;
+
+template<size_t N>
+constexpr auto encryptString(const char (&str)[N], char key) {
+    std::array<char, N> encrypted{};
+    for (size_t i = 0; i < N; i++) {
+        encrypted[i] = str[i] ^ key;
+    }
+    return encrypted;
+}
+
+template<size_t N>
+static std::string decryptString(const std::array<char, N>& encrypted, char key) {
+    std::string result(N - 1, '\0');
+    for (size_t i = 0; i < N - 1; i++) {
+        result[i] = encrypted[i] ^ key;
+    }
+    return result;
+}
+
+#define ENC(str) encryptString(str, 0x47)
+#define DEC(arr) decryptString(arr, 0x47).c_str()
+
+__attribute__((visibility("hidden")))
+static JavaVM* getVm() { return gVm; }
+
+__attribute__((visibility("default")))
+JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved) {
+    gVm = vm;
+
+    auto fn = [](void*) -> void* {
+        constexpr auto c1 = ENC("dalvik/system/VMRuntime");
+        constexpr auto c2 = ENC("getRuntime");
+        constexpr auto c3 = ENC("()Ldalvik/system/VMRuntime;");
+        constexpr auto c4 = ENC("setHiddenApiExemptions");
+        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;");
+
+        JNIEnv* env;
+        getVm()->AttachCurrentThread(&env, nullptr);
+
+        jclass vmRuntime = env->FindClass(DEC(c1));
+        jmethodID getRuntime = env->GetStaticMethodID(vmRuntime, DEC(c2), DEC(c3));
+        jmethodID setExemptions = env->GetMethodID(vmRuntime, DEC(c4), DEC(c5));
+
+        jobject runtime = env->CallStaticObjectMethod(vmRuntime, getRuntime);
+        jobjectArray prefixes = env->NewObjectArray(
+                2, env->FindClass(DEC(c6)), nullptr);
+        env->SetObjectArrayElement(prefixes, 0, env->NewStringUTF(DEC(c7)));
+        env->SetObjectArrayElement(prefixes, 1, env->NewStringUTF(DEC(c8)));
+
+        env->CallVoidMethod(runtime, setExemptions, prefixes);
+        getVm()->DetachCurrentThread();
+        return nullptr;
+    };
+
+    pthread_t t;
+    pthread_create(&t, nullptr, fn, nullptr);
+    pthread_join(t, nullptr);
+    return JNI_VERSION_1_6;
+}

android/app/src/main/java/me/kavishdevar/aln/AirPodsService.kt

@@ -1,476 +0,0 @@
-package me.kavishdevar.aln
-
-import android.annotation.SuppressLint
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.Service
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothHeadset
-import android.bluetooth.BluetoothManager
-import android.bluetooth.BluetoothProfile
-import android.bluetooth.BluetoothSocket
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.media.AudioManager
-import android.os.Binder
-import android.os.Build
-import android.os.IBinder
-import android.os.ParcelUuid
-import android.util.Log
-import androidx.core.app.NotificationCompat
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import org.lsposed.hiddenapibypass.HiddenApiBypass
-
-private const val VENDOR_SPECIFIC_HEADSET_EVENT_IPHONEACCEV = "+IPHONEACCEV"
-private const val VENDOR_SPECIFIC_HEADSET_EVENT_IPHONEACCEV_BATTERY_LEVEL = 1
-private const val APPLE = 0x004C
-const val ACTION_BATTERY_LEVEL_CHANGED = "android.bluetooth.device.action.BATTERY_LEVEL_CHANGED"
-const val EXTRA_BATTERY_LEVEL = "android.bluetooth.device.extra.BATTERY_LEVEL"
-private const val PACKAGE_ASI = "com.google.android.settings.intelligence"
-private const val ACTION_ASI_UPDATE_BLUETOOTH_DATA = "batterywidget.impl.action.update_bluetooth_data"
-//private const val COMPANION_TYPE_NONE = "COMPANION_NONE"
-//const val VENDOR_RESULT_CODE_COMMAND_ANDROID = "+ANDROID"
-
-class AirPodsService : Service() {
-    inner class LocalBinder : Binder() {
-        fun getService(): AirPodsService = this@AirPodsService
-    }
-
-    override fun onBind(intent: Intent?): IBinder {
-        return LocalBinder()
-    }
-
-    var isRunning: Boolean = false
-    private var socket: BluetoothSocket? = null
-
-    fun sendPacket(packet: String) {
-        val fromHex = packet.split(" ").map { it.toInt(16).toByte() }
-        socket?.outputStream?.write(fromHex.toByteArray())
-        socket?.outputStream?.flush()
-    }
-
-    fun setANCMode(mode: Int) {
-        when (mode) {
-            1 -> {
-                socket?.outputStream?.write(Enums.NOISE_CANCELLATION_OFF.value)
-            }
-            2 -> {
-                socket?.outputStream?.write(Enums.NOISE_CANCELLATION_ON.value)
-            }
-            3 -> {
-                socket?.outputStream?.write(Enums.NOISE_CANCELLATION_TRANSPARENCY.value)
-            }
-            4 -> {
-                socket?.outputStream?.write(Enums.NOISE_CANCELLATION_ADAPTIVE.value)
-            }
-        }
-        socket?.outputStream?.flush()
-    }
-
-    fun setCAEnabled(enabled: Boolean) {
-        socket?.outputStream?.write(if (enabled) Enums.SET_CONVERSATION_AWARENESS_ON.value else Enums.SET_CONVERSATION_AWARENESS_OFF.value)
-    }
-
-    fun setAdaptiveStrength(strength: Int) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x2E, strength.toByte(), 0x00, 0x00, 0x00)
-        socket?.outputStream?.write(bytes)
-        socket?.outputStream?.flush()
-    }
-
-    val earDetectionNotification = AirPodsNotifications.EarDetection()
-    val ancNotification = AirPodsNotifications.ANC()
-    val batteryNotification = AirPodsNotifications.BatteryNotification()
-    val conversationAwarenessNotification = AirPodsNotifications.ConversationalAwarenessNotification()
-
-    var earDetectionEnabled = true
-
-    fun setCaseChargingSounds(enabled: Boolean) {
-        val bytes = byteArrayOf(0x12, 0x3a, 0x00, 0x01, 0x00, 0x08, if (enabled) 0x00 else 0x01)
-        socket?.outputStream?.write(bytes)
-        socket?.outputStream?.flush()
-    }
-
-    fun setEarDetection(enabled: Boolean) {
-        earDetectionEnabled = enabled
-    }
-
-    fun getBattery(): List<Battery> {
-        return batteryNotification.getBattery()
-    }
-
-    fun getANC(): Int {
-        return ancNotification.status
-    }
-//
-//    private fun buildBatteryText(battery: List<Battery>): String {
-//        val left = battery[0]
-//        val right = battery[1]
-//        val case = battery[2]
-//
-//        return "Left: ${left.level}% ${left.getStatusName()}, Right: ${right.level}% ${right.getStatusName()}, Case: ${case.level}% ${case.getStatusName()}"
-//    }
-
-    private fun createNotification(): Notification {
-        val channelId = "battery"
-        val notificationBuilder = NotificationCompat.Builder(this, channelId)
-            .setSmallIcon(R.drawable.pro_2_buds)
-            .setContentTitle("AirPods Connected")
-            .setOngoing(true)
-            .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
-
-        val channel =
-            NotificationChannel(channelId, "Battery Notification", NotificationManager.IMPORTANCE_LOW)
-
-        val notificationManager = getSystemService(NotificationManager::class.java)
-        notificationManager.createNotificationChannel(channel)
-        return notificationBuilder.build()
-    }
-
-    fun disconnectAudio(context: Context, device: BluetoothDevice?) {
-        val bluetoothAdapter = context.getSystemService(BluetoothManager::class.java).adapter
-
-        bluetoothAdapter?.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
-            override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                if (profile == BluetoothProfile.A2DP) {
-                    try {
-                        val method = proxy.javaClass.getMethod("disconnect", BluetoothDevice::class.java)
-                        method.invoke(proxy, device)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    } finally {
-                        bluetoothAdapter.closeProfileProxy(BluetoothProfile.A2DP, proxy)
-                    }
-                }
-            }
-
-            override fun onServiceDisconnected(profile: Int) { }
-        }, BluetoothProfile.A2DP)
-
-        bluetoothAdapter?.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
-            override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                if (profile == BluetoothProfile.HEADSET) {
-                    try {
-                        val method = proxy.javaClass.getMethod("disconnect", BluetoothDevice::class.java)
-                        method.invoke(proxy, device)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    } finally {
-                        bluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, proxy)
-                    }
-                }
-            }
-
-            override fun onServiceDisconnected(profile: Int) { }
-        }, BluetoothProfile.HEADSET)
-    }
-
-    fun connectAudio(context: Context, device: BluetoothDevice?) {
-        val bluetoothAdapter = context.getSystemService(BluetoothManager::class.java).adapter
-
-        bluetoothAdapter?.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
-            override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                if (profile == BluetoothProfile.A2DP) {
-                    try {
-                        val method = proxy.javaClass.getMethod("connect", BluetoothDevice::class.java)
-                        method.invoke(proxy, device)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    } finally {
-                        bluetoothAdapter.closeProfileProxy(BluetoothProfile.A2DP, proxy)
-                    }
-                }
-            }
-
-            override fun onServiceDisconnected(profile: Int) { }
-        }, BluetoothProfile.A2DP)
-
-        bluetoothAdapter?.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
-            override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                if (profile == BluetoothProfile.HEADSET) {
-                    try {
-                        val method = proxy.javaClass.getMethod("connect", BluetoothDevice::class.java)
-                        method.invoke(proxy, device)
-                    } catch (e: Exception) {
-                        e.printStackTrace()
-                    } finally {
-                        bluetoothAdapter.closeProfileProxy(BluetoothProfile.HEADSET, proxy)
-                    }
-                }
-            }
-
-            override fun onServiceDisconnected(profile: Int) { }
-        }, BluetoothProfile.HEADSET)
-    }
-
-    fun updatePodsStatus(device: BluetoothDevice, batteryList: List<Battery>) {
-        var batteryUnified = 0
-        var batteryUnifiedArg = 0
-
-            // Handle each Battery object from batteryList
-//            batteryList.forEach { battery ->
-//                when (battery.getComponentName()) {
-//                    "LEFT" -> {
-//                        HiddenApiBypass.invoke(BluetoothDevice::class.java, device, "setMetadata", 10, battery.level.toString().toByteArray())
-//                        HiddenApiBypass.invoke(BluetoothDevice::class.java, device, "setMetadata", 13, battery.getStatusName()?.uppercase()?.toByteArray())
-//                    }
-//                    "RIGHT" -> {
-//                        HiddenApiBypass.invoke(BluetoothDevice::class.java, device, "setMetadata", 11, battery.level.toString().toByteArray())
-//                        HiddenApiBypass.invoke(BluetoothDevice::class.java, device, "setMetadata", 14, battery.getStatusName()?.uppercase()?.toByteArray())
-//                    }
-//                    "CASE" -> {
-//                        HiddenApiBypass.invoke(BluetoothDevice::class.java, device, "setMetadata", 12, battery.level.toString().toByteArray())
-//                        HiddenApiBypass.invoke(BluetoothDevice::class.java, device, "setMetadata", 15, battery.getStatusName()?.uppercase()?.toByteArray())
-//                    }
-//                }
-//            }
-
-
-        // Sending broadcast for battery update
-        broadcastVendorSpecificEventIntent(
-            VENDOR_SPECIFIC_HEADSET_EVENT_IPHONEACCEV,
-            APPLE,
-            BluetoothHeadset.AT_CMD_TYPE_SET,
-            batteryUnified,
-            batteryUnifiedArg,
-            device
-        )
-    }
-
-    @Suppress("SameParameterValue")
-    @SuppressLint("MissingPermission")
-    private fun broadcastVendorSpecificEventIntent(
-        command: String,
-        companyId: Int,
-        commandType: Int,
-        batteryUnified: Int,
-        batteryUnifiedArg: Int,
-        device: BluetoothDevice
-    ) {
-        val arguments = arrayOf(
-            1, // Number of key(IndicatorType)/value pairs
-            VENDOR_SPECIFIC_HEADSET_EVENT_IPHONEACCEV_BATTERY_LEVEL, // IndicatorType: Battery Level
-            batteryUnifiedArg // Battery Level
-        )
-
-        val intent = Intent(BluetoothHeadset.ACTION_VENDOR_SPECIFIC_HEADSET_EVENT).apply {
-            putExtra(BluetoothHeadset.EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD, command)
-            putExtra(BluetoothHeadset.EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_CMD_TYPE, commandType)
-            putExtra(BluetoothHeadset.EXTRA_VENDOR_SPECIFIC_HEADSET_EVENT_ARGS, arguments)
-            putExtra(BluetoothDevice.EXTRA_DEVICE, device)
-            putExtra(BluetoothDevice.EXTRA_NAME, device.name)
-            addCategory(BluetoothHeadset.VENDOR_SPECIFIC_HEADSET_EVENT_COMPANY_ID_CATEGORY + "." + companyId.toString())
-        }
-        sendBroadcast(intent)
-
-        val batteryIntent = Intent(ACTION_BATTERY_LEVEL_CHANGED).apply {
-            putExtra(BluetoothDevice.EXTRA_DEVICE, device)
-            putExtra(EXTRA_BATTERY_LEVEL, batteryUnified)
-        }
-        sendBroadcast(batteryIntent)
-
-        val statusIntent = Intent(ACTION_ASI_UPDATE_BLUETOOTH_DATA).setPackage(PACKAGE_ASI).apply {
-            putExtra(ACTION_BATTERY_LEVEL_CHANGED, intent)
-        }
-        sendBroadcast(statusIntent)
-    }
-
-
-    fun setName(name: String) {
-        val nameBytes = name.toByteArray()
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x1a, 0x00, 0x01,
-            nameBytes.size.toByte(), 0x00) + nameBytes
-        socket?.outputStream?.write(bytes)
-        socket?.outputStream?.flush()
-        val hex = bytes.joinToString(" ") { "%02X".format(it) }
-        Log.d("AirPodsService", "setName: $name, sent packet: $hex")
-    }
-
-    @SuppressLint("MissingPermission", "InlinedApi")
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-
-        val notification = createNotification()
-        startForeground(1, notification)
-
-        if (isRunning) {
-            return START_STICKY
-        }
-        isRunning = true
-
-        @Suppress("DEPRECATION") val device = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) intent?.getParcelableExtra("device", BluetoothDevice::class.java) else intent?.getParcelableExtra("device")
-
-        HiddenApiBypass.addHiddenApiExemptions("Landroid/bluetooth/BluetoothSocket;")
-        val uuid: ParcelUuid = ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a")
-
-        socket = HiddenApiBypass.newInstance(BluetoothSocket::class.java, 3, true, true, device, 0x1001, uuid) as BluetoothSocket?
-        try {
-            socket?.connect()
-            socket?.let { it ->
-                it.outputStream.write(Enums.HANDSHAKE.value)
-                it.outputStream.write(Enums.SET_SPECIFIC_FEATURES.value)
-                it.outputStream.write(Enums.REQUEST_NOTIFICATIONS.value)
-                sendBroadcast(Intent(AirPodsNotifications.AIRPODS_CONNECTED))
-                it.outputStream.flush()
-
-                CoroutineScope(Dispatchers.IO).launch {
-                    while (socket?.isConnected == true) {
-                        socket?.let {
-                            val audioManager = this@AirPodsService.getSystemService(AUDIO_SERVICE) as AudioManager
-                            MediaController.initialize(audioManager)
-                            val buffer = ByteArray(1024)
-                            val bytesRead = it.inputStream.read(buffer)
-                            var data: ByteArray = byteArrayOf()
-                            if (bytesRead > 0) {
-                                data = buffer.copyOfRange(0, bytesRead)
-                                sendBroadcast(Intent(AirPodsNotifications.AIRPODS_DATA).apply {
-                                    putExtra("data", buffer.copyOfRange(0, bytesRead))
-                                })
-                                val bytes = buffer.copyOfRange(0, bytesRead)
-                                val formattedHex = bytes.joinToString(" ") { "%02X".format(it) }
-                                Log.d("AirPods Data", "Data received: $formattedHex")
-                            }
-                            else if (bytesRead == -1) {
-                                Log.d("AirPods Service", "Socket closed (bytesRead = -1)")
-                                this@AirPodsService.stopForeground(STOP_FOREGROUND_REMOVE)
-                                socket?.close()
-                                sendBroadcast(Intent(AirPodsNotifications.AIRPODS_DISCONNECTED))
-                                return@launch
-                            }
-                            var inEar = false
-                            var inEarData = listOf<Boolean>()
-                            if (earDetectionNotification.isEarDetectionData(data)) {
-                                earDetectionNotification.setStatus(data)
-                                sendBroadcast(Intent(AirPodsNotifications.EAR_DETECTION_DATA).apply {
-                                    val list = earDetectionNotification.status
-                                    val bytes = ByteArray(2)
-                                    bytes[0] = list[0]
-                                    bytes[1] = list[1]
-                                    putExtra("data", bytes)
-                                })
-                                Log.d("AirPods Parser", "Ear Detection: ${earDetectionNotification.status[0]} ${earDetectionNotification.status[1]}")
-                                var justEnabledA2dp = false
-                                val earReceiver = object : BroadcastReceiver() {
-                                        override fun onReceive(context: Context, intent: Intent) {
-                                            val data = intent.getByteArrayExtra("data")
-                                            if (data != null && earDetectionEnabled) {
-                                                inEar = if (data.find { it == 0x02.toByte() } != null || data.find { it == 0x03.toByte() } != null) {
-                                                    data[0] == 0x00.toByte() || data[1] == 0x00.toByte()
-                                                } else {
-                                                    data[0] == 0x00.toByte() && data[1] == 0x00.toByte()
-                                                }
-
-                                                val newInEarData = listOf(data[0] == 0x00.toByte(), data[1] == 0x00.toByte())
-                                                if (newInEarData.contains(true) && inEarData == listOf(false, false)) {
-                                                    connectAudio(this@AirPodsService, device)
-                                                    justEnabledA2dp = true
-                                                    val bluetoothAdapter = this@AirPodsService.getSystemService(BluetoothManager::class.java).adapter
-                                                    bluetoothAdapter.getProfileProxy(
-                                                        this@AirPodsService, object : BluetoothProfile.ServiceListener {
-                                                            override fun onServiceConnected(
-                                                                profile: Int,
-                                                                proxy: BluetoothProfile
-                                                            ) {
-                                                                if (profile == BluetoothProfile.A2DP) {
-                                                                    val connectedDevices =
-                                                                        proxy.connectedDevices
-                                                                    if (connectedDevices.isNotEmpty()) {
-                                                                        MediaController.sendPlay()
-                                                                    }
-                                                                }
-                                                                bluetoothAdapter.closeProfileProxy(
-                                                                    profile,
-                                                                    proxy
-                                                                )
-                                                            }
-
-                                                            override fun onServiceDisconnected(
-                                                                profile: Int
-                                                            ) {
-                                                            }
-                                                        }
-                                                        ,BluetoothProfile.A2DP
-                                                    )
-
-                                                }
-                                                else if (newInEarData == listOf(false, false)){
-                                                    disconnectAudio(this@AirPodsService, device)
-                                                }
-
-                                                inEarData = newInEarData
-
-                                                if (inEar == true) {
-                                                    if (!justEnabledA2dp) {
-                                                        justEnabledA2dp = false
-                                                        MediaController.sendPlay()
-                                                    }
-                                                } else {
-                                                    MediaController.sendPause()
-                                                }
-                                            }
-                                        }
-                                    }
-
-                                val earIntentFilter = IntentFilter(AirPodsNotifications.EAR_DETECTION_DATA)
-                                this@AirPodsService.registerReceiver(earReceiver, earIntentFilter,
-                                    RECEIVER_EXPORTED
-                                )
-                            }
-                            else if (ancNotification.isANCData(data)) {
-                                ancNotification.setStatus(data)
-                                sendBroadcast(Intent(AirPodsNotifications.ANC_DATA).apply {
-                                    putExtra("data", ancNotification.status)
-                                })
-                                Log.d("AirPods Parser", "ANC: ${ancNotification.status}")
-                            }
-                            else if (batteryNotification.isBatteryData(data)) {
-                                batteryNotification.setBattery(data)
-                                sendBroadcast(Intent(AirPodsNotifications.BATTERY_DATA).apply {
-                                    putParcelableArrayListExtra("data", ArrayList(batteryNotification.getBattery()))
-                                })
-                                for (battery in batteryNotification.getBattery()) {
-                                    Log.d("AirPods Parser", "${battery.getComponentName()}: ${battery.getStatusName()} at ${battery.level}% ")
-                                }
-//                                updatePodsStatus(device!!, batteryNotification.getBattery())
-                            }
-                            else if (conversationAwarenessNotification.isConversationalAwarenessData(data)) {
-                                conversationAwarenessNotification.setData(data)
-                                sendBroadcast(Intent(AirPodsNotifications.CA_DATA).apply {
-                                    putExtra("data", conversationAwarenessNotification.status)
-                                })
-
-
-                                if (conversationAwarenessNotification.status == 1.toByte() || conversationAwarenessNotification.status == 2.toByte()) {
-                                    MediaController.startSpeaking()
-                                } else if (conversationAwarenessNotification.status == 8.toByte() || conversationAwarenessNotification.status == 9.toByte()) {
-                                    MediaController.stopSpeaking()
-                                }
-
-                                Log.d("AirPods Parser", "Conversation Awareness: ${conversationAwarenessNotification.status}")
-                            }
-                            else { }
-                        }
-                    }
-                    Log.d("AirPods Service", "Socket closed")
-                    isRunning = false
-                    this@AirPodsService.stopForeground(STOP_FOREGROUND_REMOVE)
-                    socket?.close()
-                    sendBroadcast(Intent(AirPodsNotifications.AIRPODS_DISCONNECTED))
-                }
-            }
-        }
-        catch (e: Exception) {
-            Log.e("AirPodsSettingsScreen", "Error connecting to device: ${e.message}")
-        }
-        return START_STICKY
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        socket?.close()
-        isRunning = false
-    }
-}

android/app/src/main/java/me/kavishdevar/aln/AirPodsSettingsScreen.kt

@@ -1,908 +0,0 @@
-package me.kavishdevar.aln
-
-import android.annotation.SuppressLint
-import android.bluetooth.BluetoothDevice
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.SharedPreferences
-import android.os.Build
-import androidx.annotation.RequiresApi
-import androidx.compose.animation.core.animateDpAsState
-import androidx.compose.foundation.Image
-import androidx.compose.foundation.background
-import androidx.compose.foundation.border
-import androidx.compose.foundation.clickable
-import androidx.compose.foundation.gestures.detectTapGestures
-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.PaddingValues
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.Spacer
-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.size
-import androidx.compose.foundation.layout.width
-import androidx.compose.foundation.rememberScrollState
-import androidx.compose.foundation.shape.CircleShape
-import androidx.compose.foundation.shape.RoundedCornerShape
-import androidx.compose.foundation.text.BasicTextField
-import androidx.compose.foundation.verticalScroll
-import androidx.compose.material.icons.Icons
-import androidx.compose.material.icons.filled.KeyboardArrowRight
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.IconButtonDefaults
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Slider
-import androidx.compose.material3.SliderDefaults
-import androidx.compose.material3.Text
-import androidx.compose.material3.VerticalDivider
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-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.alpha
-import androidx.compose.ui.draw.clip
-import androidx.compose.ui.draw.scale
-import androidx.compose.ui.draw.shadow
-import androidx.compose.ui.focus.onFocusChanged
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.ImageBitmap
-import androidx.compose.ui.graphics.SolidColor
-import androidx.compose.ui.graphics.luminance
-import androidx.compose.ui.input.pointer.pointerInput
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.res.imageResource
-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.tooling.preview.Preview
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-import kotlin.math.roundToInt
-
-@Composable
-fun BatteryView() {
-    val batteryStatus = remember { mutableStateOf<List<Battery>>(listOf()) }
-    @Suppress("DEPRECATION") val batteryReceiver = remember {
-        object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                batteryStatus.value = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) { intent.getParcelableArrayListExtra("data", Battery::class.java) } else { intent.getParcelableArrayListExtra("data") }?.toList() ?: listOf()
-            }
-        }
-    }
-    val context = LocalContext.current
-
-    LaunchedEffect(context) {
-        val batteryIntentFilter = IntentFilter(AirPodsNotifications.BATTERY_DATA)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            context.registerReceiver(batteryReceiver, batteryIntentFilter, Context.RECEIVER_EXPORTED)
-        }
-    }
-
-    Row {
-        Column (
-            modifier = Modifier
-                .fillMaxWidth(0.5f),
-            horizontalAlignment = Alignment.CenterHorizontally
-        ) {
-            Image (
-                bitmap = ImageBitmap.imageResource(R.drawable.pro_2_buds),
-                contentDescription = "Buds",
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .scale(0.50f)
-            )
-            val left = batteryStatus.value.find { it.component == BatteryComponent.LEFT }
-            val right = batteryStatus.value.find { it.component == BatteryComponent.RIGHT }
-            if ((right?.status == BatteryStatus.CHARGING && left?.status == BatteryStatus.CHARGING) || (left?.status == BatteryStatus.NOT_CHARGING && right?.status == BatteryStatus.NOT_CHARGING))
-            {
-                BatteryIndicator(right.level.let { left.level.coerceAtMost(it) }, left.status == BatteryStatus.CHARGING)
-            }
-            else {
-                Row {
-                    if (left?.status != BatteryStatus.DISCONNECTED) {
-                        Text(text = "\uDBC6\uDCE5", fontFamily = FontFamily(Font(R.font.sf_pro)))
-                        BatteryIndicator(left?.level ?: 0, left?.status == BatteryStatus.CHARGING)
-                        Spacer(modifier = Modifier.width(16.dp))
-                    }
-                    if (right?.status != BatteryStatus.DISCONNECTED) {
-                        Text(text = "\uDBC6\uDCE8", fontFamily = FontFamily(Font(R.font.sf_pro)))
-                        BatteryIndicator(right?.level ?: 0, right?.status == BatteryStatus.CHARGING)
-                    }
-                }
-            }
-        }
-
-        Column (
-            modifier = Modifier
-                .fillMaxWidth(),
-            horizontalAlignment = Alignment.CenterHorizontally
-        ) {
-            val case = batteryStatus.value.find { it.component == BatteryComponent.CASE }
-
-            Image(
-                bitmap = ImageBitmap.imageResource(R.drawable.pro_2_case),
-                contentDescription = "Case",
-                modifier = Modifier
-                    .fillMaxWidth()
-            )
-            BatteryIndicator(case?.level ?: 0)
-        }
-    }
-}
-
-@SuppressLint("MissingPermission", "NewApi")
-@Composable
-fun AirPodsSettingsScreen(paddingValues: PaddingValues, device: BluetoothDevice?, service: AirPodsService?,
-                          navController: NavController) {
-    val sharedPreferences = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
-    var deviceName by remember { mutableStateOf(TextFieldValue(sharedPreferences.getString("name", device?.name ?: "") ?: "")) }
-//  4B 61 76 69 73 68 E2 80 99 73 20 41 69 72 50 6F 64 73 20 50 72 6F
-    val verticalScrollState  = rememberScrollState()
-    Column(
-        modifier = Modifier
-            .fillMaxSize()
-            .padding(paddingValues)
-            .padding(vertical = 24.dp, horizontal = 12.dp)
-            .verticalScroll(
-                state = verticalScrollState,
-                enabled = true,
-            )
-    ) {
-        LaunchedEffect(service) {
-            service?.let {
-                it.sendBroadcast(Intent(AirPodsNotifications.BATTERY_DATA).apply {
-                    putParcelableArrayListExtra("data", ArrayList(it.getBattery()))
-                })
-                it.sendBroadcast(Intent(AirPodsNotifications.ANC_DATA).apply {
-                    putExtra("data", it.getANC())
-                })
-            }
-        }
-        val sharedPreferences = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
-
-        if (service != null) {
-            BatteryView()
-
-            Spacer(modifier = Modifier.height(32.dp))
-            StyledTextField(
-                name = "Name",
-                value = deviceName.text,
-                onValueChange = {
-                    deviceName = TextFieldValue(it)
-                    sharedPreferences.edit().putString("name", it).apply()
-                    service.setName(it)
-                }
-            )
-
-            Spacer(modifier = Modifier.height(32.dp))
-            NoiseControlSettings(service = service)
-
-            Spacer(modifier = Modifier.height(16.dp))
-            AudioSettings(service = service, sharedPreferences = sharedPreferences)
-
-            Spacer(modifier = Modifier.height(16.dp))
-            IndependentToggle(name = "Automatic Ear Detection", service = service, functionName = "setEarDetection", sharedPreferences = sharedPreferences, true)
-
-//            Spacer(modifier = Modifier.height(16.dp))
-
-//            val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-//            val textColor = if (isDarkTheme) Color.White else Color.Black
-
-            // localstorage stuff
-            // TODO: localstorage and call the setButtons() with previous configuration and new configuration
-//            Box (
-//                modifier = Modifier
-//                    .padding(vertical = 8.dp)
-//                    .background(
-//                        if (isDarkTheme) Color(0xFF1C1B20) else Color(0xFFFFFFFF),
-//                        RoundedCornerShape(14.dp)
-//                    )
-//            )
-//            {
-//                // TODO: A Column Rows with text at start and a check mark if ticked
-//            }
-
-            Spacer(modifier = Modifier.height(16.dp))
-            Row (
-                modifier = Modifier
-                    .background(if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(0xFF1C1B20) else Color(0xFFFFFFFF), RoundedCornerShape(14.dp))
-                    .height(55.dp)
-                    .clickable {
-                        navController.navigate("debug")
-                    }
-            ) {
-                Text(text = "Debug", modifier = Modifier.padding(16.dp), color = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White else Color.Black)
-                Spacer(modifier = Modifier.weight(1f))
-                IconButton(
-                    onClick = { navController.navigate("debug") },
-                    colors = IconButtonDefaults.iconButtonColors(
-                        containerColor = Color.Transparent,
-                        contentColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White else Color.Black ),
-                    modifier = Modifier.padding(start = 16.dp).fillMaxHeight()
-                ) {
-                    @Suppress("DEPRECATION")
-                    Icon(imageVector = Icons.Default.KeyboardArrowRight, contentDescription = "Debug")
-                }
-            }
-        }
-    }
-}
-
-@OptIn(ExperimentalMaterial3Api::class)
-@Composable
-fun NoiseControlSlider(service: AirPodsService, sharedPreferences: SharedPreferences) {
-    val sliderValue = remember { mutableFloatStateOf(0f) }
-    LaunchedEffect(sliderValue) {
-        if (sharedPreferences.contains("adaptive_strength")) {
-            sliderValue.floatValue = sharedPreferences.getInt("adaptive_strength", 0).toFloat()
-        }
-    }
-    LaunchedEffect(sliderValue.floatValue) {
-        sharedPreferences.edit().putInt("adaptive_strength", sliderValue.floatValue.toInt()).apply()
-    }
-
-    val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-
-    val trackColor = if (isDarkTheme) Color(0xFFB3B3B3) else Color(0xFFD9D9D9)
-    val activeTrackColor = if (isDarkTheme) Color(0xFFFFFFFF) else Color(0xFF007AFF)
-    val thumbColor = if (isDarkTheme) Color(0xFFFFFFFF) else Color(0xFFFFFFFF)
-    val labelTextColor = if (isDarkTheme) Color.White else Color.Black
-
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(horizontal = 8.dp),
-        horizontalAlignment = Alignment.CenterHorizontally
-    ) {
-        // Slider
-        Slider(
-            value = sliderValue.floatValue,
-            onValueChange = {
-                sliderValue.floatValue = it
-                service.setAdaptiveStrength(100 - it.toInt())
-            },
-            valueRange = 0f..100f,
-            onValueChangeFinished = {
-                // Round the value when the user stops sliding
-                sliderValue.floatValue = sliderValue.floatValue.roundToInt().toFloat()
-            },
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(36.dp),  // Adjust height to ensure thumb fits well
-            colors = SliderDefaults.colors(
-                thumbColor = thumbColor,
-                activeTrackColor = activeTrackColor,
-                inactiveTrackColor = trackColor
-            ),
-            thumb = {
-                Box(
-                    modifier = Modifier
-                        .size(24.dp)  // Circular thumb size
-                        .shadow(4.dp, CircleShape)  // Apply shadow to the thumb
-                        .background(thumbColor, CircleShape)  // Circular thumb
-                )
-            },
-            track = {
-                Box(
-                    modifier = Modifier
-                        .fillMaxWidth()
-                        .height(12.dp)
-                        .background(trackColor, RoundedCornerShape(6.dp))
-                )
-            }
-        )
-
-        // Labels
-        Row(
-            modifier = Modifier.fillMaxWidth(),
-            horizontalArrangement = Arrangement.SpaceBetween
-        ) {
-            Text(
-                text = "Less Noise",
-                style = TextStyle(
-                    fontSize = 14.sp,
-                    fontWeight = FontWeight.Light,
-                    color = labelTextColor
-                ),
-                modifier = Modifier.padding(start = 4.dp)
-            )
-            Text(
-                text = "More Noise",
-                style = TextStyle(
-                    fontSize = 14.sp,
-                    fontWeight = FontWeight.Light,
-                    color = labelTextColor
-                ),
-                modifier = Modifier.padding(end = 4.dp)
-            )
-        }
-    }
-}
-
-@Preview
-@Composable
-fun Preview() {
-    IndependentToggle("Case Charging Sounds", AirPodsService(), "setCaseChargingSounds", LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE))
-}
-
-@Composable
-fun IndependentToggle(name: String, service: AirPodsService, functionName: String, sharedPreferences: SharedPreferences, default: Boolean = false) {
-    val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    // Standardize the key
-    val snakeCasedName = name.replace(Regex("[\\W\\s]+"), "_").lowercase()
-
-    // State for the toggle
-    var checked by remember { mutableStateOf(default) }
-
-    // Load initial state from SharedPreferences
-    LaunchedEffect(sharedPreferences) {
-        checked = sharedPreferences.getBoolean(snakeCasedName, true)
-    }
-    Box (
-        modifier = Modifier
-            .padding(vertical = 8.dp)
-            .background(
-                if (isDarkTheme) Color(0xFF1C1B20) else Color(0xFFFFFFFF),
-                RoundedCornerShape(14.dp)
-            )
-    )
-    {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(55.dp)
-                .padding(horizontal = 12.dp)
-                .clickable {
-                    // Toggle checked state and save to SharedPreferences
-                    checked = !checked
-                    sharedPreferences
-                        .edit()
-                        .putBoolean(snakeCasedName, checked)
-                        .apply()
-
-                    // Call the corresponding method in the service
-                    val method = service::class.java.getMethod(functionName, Boolean::class.java)
-                    method.invoke(service, checked)
-                },
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Text(text = name, modifier = Modifier.weight(1f), fontSize = 16.sp, color = textColor)
-            StyledSwitch(
-                checked = checked,
-                onCheckedChange = {
-                    checked = it
-                    sharedPreferences.edit().putBoolean(snakeCasedName, it).apply()
-
-                    // Call the corresponding method in the service
-                    val method = service::class.java.getMethod(functionName, Boolean::class.java)
-                    method.invoke(service, it)
-                },
-            )
-        }
-    }
-}
-
-@Composable
-fun AudioSettings(service: AirPodsService, sharedPreferences: SharedPreferences) {
-    val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-
-    // Load the conversational awareness state from sharedPreferences
-    var conversationalAwarenessEnabled by remember {
-        mutableStateOf(
-            sharedPreferences.getBoolean("conversational_awareness", true)
-        )
-    }
-
-    // Update the service when the toggle is changed
-    fun updateConversationalAwareness(enabled: Boolean) {
-        conversationalAwarenessEnabled = enabled
-        sharedPreferences.edit().putBoolean("conversational_awareness", enabled).apply()
-        service.setCAEnabled(enabled)
-    }
-
-    Text(
-        text = "AUDIO",
-        style = TextStyle(
-            fontSize = 14.sp,
-            fontWeight = FontWeight.Light,
-            color = textColor.copy(alpha = 0.6f)
-        ),
-        modifier = Modifier.padding(8.dp, bottom = 2.dp)
-    )
-
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1B20) else Color(0xFFFFFFFF)
-    val isPressed = remember { mutableStateOf(false) }
-
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .background(backgroundColor, RoundedCornerShape(14.dp))
-            .padding(top = 2.dp)
-    ) {
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .background(
-                    shape = RoundedCornerShape(14.dp),
-                    color = if (isPressed.value) Color(0xFFE0E0E0) else Color.Transparent
-                )
-                .padding(horizontal = 12.dp, vertical = 12.dp)
-                .pointerInput(Unit) { // Detect press state for iOS-like effect
-                    detectTapGestures(
-                        onPress = {
-                            isPressed.value = true
-                            tryAwaitRelease() // Wait until release
-                            isPressed.value = false
-                        }
-                    )
-                }
-                .clickable(
-                    indication = null, // Disable ripple effect
-                    interactionSource = remember { MutableInteractionSource() } // Required for clickable
-                ) {
-                    // Toggle the conversational awareness value
-                    updateConversationalAwareness(!conversationalAwarenessEnabled)
-                },
-            verticalAlignment = Alignment.CenterVertically
-        ) {
-            Text(
-                text = "Conversational Awareness",
-                modifier = Modifier.weight(1f),
-                fontSize = 16.sp,
-                color = textColor
-            )
-
-            StyledSwitch(
-                checked = conversationalAwarenessEnabled,
-                onCheckedChange = {
-                    updateConversationalAwareness(it)
-                },
-            )
-        }
-
-        Column(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 8.dp, vertical = 10.dp)
-        ) {
-            Text(
-                text = "Adaptive Audio",
-                modifier = Modifier
-                    .padding(end = 8.dp, bottom = 2.dp, start = 2.dp)
-                    .fillMaxWidth(),
-                style = TextStyle(
-                    fontSize = 14.sp,
-                    fontWeight = FontWeight.Medium,
-                    color = textColor
-                )
-            )
-            Text(
-                text = "Adaptive audio dynamically responds to your environment and cancels or allows external noise. You can customize Adaptive Audio to allow more or less noise.",
-                modifier = Modifier
-                    .padding(8.dp, top = 2.dp)
-                    .fillMaxWidth(),
-                style = TextStyle(
-                    fontSize = 12.sp,
-                    color = textColor.copy(alpha = 0.6f)
-                )
-            )
-
-            NoiseControlSlider(service = service, sharedPreferences = sharedPreferences)
-        }
-    }
-}
-
-@RequiresApi(Build.VERSION_CODES.TIRAMISU)
-@Composable
-fun NoiseControlSettings(service: AirPodsService) {
-    val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1B20) 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(0xFF5C5A5F) else Color(0xFFFFFFFF)
-
-    val noiseControlMode = remember { mutableStateOf(NoiseControlMode.OFF) }
-
-    val noiseControlReceiver = remember {
-        object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                noiseControlMode.value = NoiseControlMode.entries.toTypedArray()[intent.getIntExtra("data", 3) - 1]
-            }
-        }
-    }
-
-    val context = LocalContext.current
-    val noiseControlIntentFilter = IntentFilter(AirPodsNotifications.ANC_DATA)
-    context.registerReceiver(noiseControlReceiver, noiseControlIntentFilter, Context.RECEIVER_EXPORTED)
-
-//    val paddingAnim by animateDpAsState(
-//        targetValue = when (noiseControlMode.value) {
-//            NoiseControlMode.OFF -> 0.dp
-//            NoiseControlMode.TRANSPARENCY -> 150.dp
-//            NoiseControlMode.ADAPTIVE -> 250.dp
-//            NoiseControlMode.NOISE_CANCELLATION -> 350.dp
-//        }, label = ""
-//    )
-
-    val d1a = remember { mutableFloatStateOf(0f) }
-    val d2a = remember { mutableFloatStateOf(0f) }
-    val d3a = remember { mutableFloatStateOf(0f) }
-
-    fun onModeSelected(mode: NoiseControlMode) {
-        noiseControlMode.value = mode
-        service.setANCMode(mode.ordinal+1)
-        when (mode) {
-            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
-            }
-        }
-    }
-
-    Text(
-        text = "NOISE CONTROL",
-        style = TextStyle(
-            fontSize = 14.sp,
-            fontWeight = FontWeight.Light,
-            color = textColor.copy(alpha = 0.6f)
-        ),
-        modifier = Modifier.padding(8.dp, bottom = 2.dp)
-    )
-
-    Column(
-        modifier = Modifier
-            .fillMaxWidth()
-            .padding(vertical = 16.dp)
-    ) {
-        Box(
-            modifier = Modifier
-                .fillMaxWidth()
-                .height(75.dp)
-                .padding(8.dp)
-        ) {
-//            Box(
-//                modifier = Modifier
-//                    .fillMaxHeight()
-//                    .width(80.dp)
-//                    .offset(x = paddingAnim)
-//                    .background(selectedBackground, RoundedCornerShape(8.dp))
-//            )
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .background(backgroundColor, RoundedCornerShape(14.dp))
-            ) {
-                NoiseControlButton(
-                    icon = ImageBitmap.imageResource(R.drawable.noise_cancellation),
-                    onClick = { onModeSelected(NoiseControlMode.OFF) },
-                    textColor = if (noiseControlMode.value == NoiseControlMode.OFF) textColorSelected else textColor,
-                    backgroundColor = if (noiseControlMode.value == NoiseControlMode.OFF) selectedBackground else Color.Transparent,
-                    modifier = Modifier.weight(1f)
-                )
-                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,
-                    backgroundColor = if (noiseControlMode.value == NoiseControlMode.TRANSPARENCY) selectedBackground else Color.Transparent,
-                    modifier = Modifier.weight(1f)
-                )
-                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,
-                    backgroundColor = if (noiseControlMode.value == NoiseControlMode.ADAPTIVE) selectedBackground else Color.Transparent,
-                    modifier = Modifier.weight(1f)
-                )
-                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,
-                    backgroundColor = if (noiseControlMode.value == NoiseControlMode.NOISE_CANCELLATION) selectedBackground else Color.Transparent,
-                    modifier = Modifier.weight(1f)
-                )
-            }
-        }
-        Row(
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(horizontal = 8.dp)
-                .padding(top = 1.dp)
-        ) {
-            Text(
-                text = "Off",
-                style = TextStyle(fontSize = 12.sp, color = textColor),
-                textAlign = TextAlign.Center,
-                fontWeight = FontWeight.Bold,
-                modifier = Modifier.weight(1f)
-            )
-            Text(
-                text = "Transparency",
-                style = TextStyle(fontSize = 12.sp, color = textColor),
-                textAlign = TextAlign.Center,
-                fontWeight = FontWeight.Bold,
-                modifier = Modifier.weight(1f)
-            )
-            Text(
-                text = "Adaptive",
-                style = TextStyle(fontSize = 12.sp, color = textColor),
-                textAlign = TextAlign.Center,
-                fontWeight = FontWeight.Bold,
-                modifier = Modifier.weight(1f)
-            )
-            Text(
-                text = "Noise Cancellation",
-                style = TextStyle(fontSize = 12.sp, color = textColor),
-                textAlign = TextAlign.Center,
-                fontWeight = FontWeight.Bold,
-                modifier = Modifier.weight(1f)
-            )
-        }
-    }
-}
-
-@Composable
-fun NoiseControlButton(
-    icon: ImageBitmap,
-    onClick: () -> Unit,
-    textColor: Color,
-    backgroundColor: Color,
-    modifier: Modifier = Modifier
-) {
-    Column(
-        modifier = modifier
-            .fillMaxHeight()
-            .padding(horizontal = 4.dp, vertical = 4.dp)
-            .background(color = backgroundColor, shape = RoundedCornerShape(11.dp))
-            .clickable(
-                onClick = onClick,
-                indication = null,
-                interactionSource = remember { MutableInteractionSource() }),
-        horizontalAlignment = Alignment.CenterHorizontally,
-        verticalArrangement = Arrangement.Center
-    ) {
-        Icon(
-            bitmap = icon,
-            contentDescription = null,
-            tint = textColor,
-            modifier = Modifier.size(40.dp)
-        )
-    }
-}
-
-enum class NoiseControlMode {
-    OFF,  NOISE_CANCELLATION, TRANSPARENCY, ADAPTIVE
-}
-
-@Composable
-fun StyledSwitch(
-    checked: Boolean,
-    onCheckedChange: (Boolean) -> Unit
-) {
-    val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-
-    val thumbColor = Color.White
-    val trackColor = if (checked) Color(0xFF34C759) else if (isDarkTheme) Color(0xFF5B5B5E) else Color(0xFFD1D1D6)
-
-    // Animate the horizontal offset of the thumb
-    val thumbOffsetX by animateDpAsState(targetValue = if (checked) 20.dp else 0.dp, label = "Test")
-
-    Box(
-        modifier = Modifier
-            .width(51.dp)
-            .height(31.dp)
-            .clip(RoundedCornerShape(15.dp))
-            .background(trackColor) // Dynamic track background
-            .padding(horizontal = 3.dp),
-        contentAlignment = Alignment.CenterStart
-    ) {
-        Box(
-            modifier = Modifier
-                .offset(x = thumbOffsetX) // Animate the offset for smooth transition
-                .size(27.dp)
-                .clip(CircleShape)
-                .background(thumbColor) // Dynamic thumb color
-                .clickable { onCheckedChange(!checked) } // Make the switch clickable
-        )
-    }
-}
-
-@Composable
-fun StyledTextField(
-    name: String,
-    value: String,
-    onValueChange: (String) -> Unit
-) {
-    var isFocused by remember { mutableStateOf(false) }
-
-    val isDarkTheme = MaterialTheme.colorScheme.surface.luminance() < 0.5
-
-    val backgroundColor = if (isDarkTheme) Color(0xFF1C1B20) else Color(0xFFFFFFFF)
-    val textColor = if (isDarkTheme) Color.White else Color.Black
-    val cursorColor = if (isFocused) { // Show cursor only when focused
-        if (isDarkTheme) Color.White else Color.Black
-    } else {
-        Color.Transparent // Hide cursor when not focused
-    }
-
-    Row(
-        verticalAlignment = Alignment.CenterVertically,
-        modifier = Modifier
-            .fillMaxWidth()
-            .height(55.dp)
-            .background(
-                backgroundColor,
-                RoundedCornerShape(14.dp)
-            )
-            .padding(horizontal = 16.dp, vertical = 8.dp)
-    ) {
-        Text(
-            text = name,
-            style = TextStyle(
-                fontSize = 16.sp,
-                color = textColor
-            )
-        )
-
-        BasicTextField(
-            value = value,
-            onValueChange = onValueChange,
-            textStyle = TextStyle(
-                color = textColor,
-                fontSize = 16.sp,
-            ),
-            cursorBrush = SolidColor(cursorColor), // Dynamic cursor color based on focus
-            decorationBox = { innerTextField ->
-                Row(
-                    verticalAlignment = Alignment.CenterVertically,
-                    horizontalArrangement = Arrangement.End
-                ) {
-                    innerTextField()
-                }
-            },
-            modifier = Modifier
-                .fillMaxWidth()
-                .padding(start = 8.dp)
-                .onFocusChanged { focusState ->
-                    isFocused = focusState.isFocused // Update focus state
-                }
-        )
-    }
-}
-
-@Composable
-fun BatteryIndicator(batteryPercentage: Int, charging: Boolean = false) {
-    val batteryOutlineColor = Color(0xFFBFBFBF) // Light gray outline
-    val batteryFillColor = if (batteryPercentage > 30) Color(0xFF30D158) else Color(0xFFFC3C3C)
-    val batteryTextColor = MaterialTheme.colorScheme.onSurface
-
-    // Battery indicator dimensions
-    val batteryWidth = 30.dp
-    val batteryHeight = 15.dp
-    val batteryCornerRadius = 4.dp
-    val tipWidth = 5.dp
-    val tipHeight = batteryHeight * 0.3f
-
-    Column(horizontalAlignment = Alignment.CenterHorizontally) {
-        // Row for battery icon and tip
-        Row(
-            verticalAlignment = Alignment.CenterVertically,
-            horizontalArrangement = Arrangement.spacedBy(0.dp),
-            modifier = Modifier.padding(bottom = 4.dp) // Padding between icon and percentage text
-        ) {
-            // Battery Icon
-            Box(
-                modifier = Modifier
-                    .width(batteryWidth)
-                    .height(batteryHeight)
-                    .border(1.dp, batteryOutlineColor, RoundedCornerShape(batteryCornerRadius))
-            ) {
-                Box(
-                    modifier = Modifier
-                        .fillMaxHeight()
-                        .padding(2.dp)
-                        .width(batteryWidth * (batteryPercentage / 100f))
-                        .background(batteryFillColor, RoundedCornerShape(2.dp))
-                )
-                if (charging) {
-                    Box(
-                        modifier = Modifier
-                            .fillMaxSize(), // Take up the entire size of the outer Box
-                        contentAlignment = Alignment.Center // Center the charging bolt within the Box
-                    ) {
-                        Text(
-                            text = "\uDBC0\uDEE6",
-                            fontSize = 12.sp,
-                            fontFamily = FontFamily(Font(R.font.sf_pro)),
-                            color = Color.White,
-                            modifier = Modifier.align(Alignment.Center)
-                        )
-                    }
-                }
-            }
-
-            // Battery Tip (Protrusion)
-            Box(
-                modifier = Modifier
-                    .width(tipWidth)
-                    .height(tipHeight)
-                    .padding(start = 1.dp)
-                    .background(
-                        batteryOutlineColor,
-                        RoundedCornerShape(
-                            topStart = 0.dp,
-                            topEnd = 12.dp,
-                            bottomStart = 0.dp,
-                            bottomEnd = 12.dp
-                        )
-                    )
-            )
-        }
-
-        // Battery Percentage Text
-        Text(
-            text = "$batteryPercentage%",
-            color = batteryTextColor,
-            style = TextStyle(fontSize = 16.sp, fontWeight = FontWeight.Bold)
-        )
-    }
-}

android/app/src/main/java/me/kavishdevar/aln/DebugScreen.kt

@@ -1,225 +0,0 @@
-package me.kavishdevar.aln
-
-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.os.Build
-import android.os.IBinder
-import android.util.Log
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Arrangement
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.ExperimentalLayoutApi
-import androidx.compose.foundation.layout.Row
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.imePadding
-import androidx.compose.foundation.layout.padding
-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.automirrored.filled.ArrowBack
-import androidx.compose.material.icons.filled.Send
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.HorizontalDivider
-import androidx.compose.material3.Icon
-import androidx.compose.material3.IconButton
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.material3.TextField
-import androidx.compose.material3.TextFieldDefaults
-import androidx.compose.material3.TopAppBar
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.mutableStateListOf
-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.luminance
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.input.TextFieldValue
-import androidx.compose.ui.unit.dp
-import androidx.compose.ui.unit.sp
-import androidx.navigation.NavController
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
-@Composable
-fun DebugScreen(navController: NavController) {
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = { Text("Debug") },
-                navigationIcon = {
-                    IconButton(onClick = {
-                        navController.popBackStack()
-                    }) {
-                        Icon(Icons.AutoMirrored.Filled.ArrowBack, null)
-                    }
-                }
-            )
-        },
-        containerColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(0xFF000000)
-        else Color(0xFFF2F2F7),
-    ) { paddingValues ->
-
-        val text = remember { mutableStateListOf<String>("Log Start") }
-        val context = LocalContext.current
-        val listState = rememberLazyListState()
-
-        val receiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                val data = intent.getByteArrayExtra("data")
-                data?.let {
-                    text.add(">" + it.joinToString(" ") { byte -> "%02X".format(byte) }) // Use ">" for received packets
-                }
-            }
-        }
-
-        LaunchedEffect(context) {
-            val intentFilter = IntentFilter(AirPodsNotifications.AIRPODS_DATA)
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                context.registerReceiver(receiver, intentFilter, Context.RECEIVER_EXPORTED)
-            }
-        }
-
-        LaunchedEffect(text.size) {
-            if (text.isNotEmpty()) {
-                listState.animateScrollToItem(text.size - 1)
-            }
-        }
-
-        Column(
-            modifier = Modifier
-                .fillMaxSize()
-                .padding(paddingValues)
-                .imePadding(), // Ensures padding for keyboard visibility
-        ) {
-            LazyColumn(
-                state = listState,
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .weight(1f),
-                content = {
-                    items(text.size) { index ->
-                        val message = text[index]
-                        val isSent = message.startsWith(">")
-                        val backgroundColor = if (isSent) Color(0xFFE1FFC7) else Color(0xFFD1D1D1)
-
-                        Box(
-                            modifier = Modifier
-                                .fillMaxWidth()
-                                .padding(8.dp)
-                                .background(backgroundColor, RoundedCornerShape(12.dp))
-                                .padding(12.dp),
-                        ) {
-                            Row(
-                                modifier = Modifier.fillMaxWidth(),
-                                verticalAlignment = Alignment.CenterVertically,
-                                horizontalArrangement = Arrangement.SpaceBetween
-                            ) {
-                                if (!isSent) {
-                                    Text("<", color = Color(0xFF00796B), fontSize = 16.sp)
-                                }
-
-                                Text(
-                                    text = if (isSent) message.substring(1) else message, // Remove the ">" from sent packets
-                                    fontFamily = FontFamily(Font(R.font.hack)),
-                                    color = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(0xFF000000)
-                                    else Color(0xFF000000),
-                                    modifier = Modifier.weight(1f) // Allows text to take available space
-                                )
-
-                                if (isSent) {
-                                    Text(">", color = Color(0xFF00796B), fontSize = 16.sp)
-                                }
-                            }
-                        }
-                    }
-                }
-            )
-            val airPodsService = remember { mutableStateOf<AirPodsService?>(null) }
-
-            val serviceConnection = object : ServiceConnection {
-                override fun onServiceConnected(name: ComponentName, service: IBinder) {
-                    val binder = service as AirPodsService.LocalBinder
-                    airPodsService.value = binder.getService()
-                    Log.d("AirPodsService", "Service connected")
-                }
-
-                override fun onServiceDisconnected(name: ComponentName) {
-                    airPodsService.value = null
-                }
-            }
-
-            val intent = Intent(context, AirPodsService::class.java)
-            context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
-            HorizontalDivider()
-            Row(
-                modifier = Modifier
-                    .fillMaxWidth()
-                    .background(if (MaterialTheme.colorScheme.surface.luminance() < 0.5) 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 for the input field
-                    trailingIcon = {
-                        IconButton(
-                            onClick = {
-                                airPodsService.value?.sendPacket(packet.value.text)
-                                text.add(packet.value.text) // Add sent message directly without prefix
-                                packet.value = TextFieldValue("") // Clear input field after sending
-                            }
-                        ) {
-                            @Suppress("DEPRECATION")
-                            Icon(Icons.Filled.Send, contentDescription = "Send")
-                        }
-                    },
-                    colors = TextFieldDefaults.colors(
-                        focusedContainerColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(0xFF1C1B20) else Color(0xFFF2F2F7),
-                        unfocusedContainerColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(0xFF1C1B20) else Color(0xFFF2F2F7),
-                        focusedIndicatorColor = Color.Transparent,
-                        unfocusedIndicatorColor = Color.Transparent,
-                        focusedTextColor =  if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White else Color.Black,
-                        unfocusedTextColor =  if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White else Color.Black.copy(alpha = 0.6f),
-                        focusedLabelColor =  if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White.copy(alpha = 0.6f) else Color.Black,
-                        unfocusedLabelColor =  if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White.copy(alpha = 0.6f) else Color.Black.copy(alpha = 0.6f),
-                    ),
-                    shape = RoundedCornerShape(12.dp)
-                )
-
-                val airPodsService = remember { mutableStateOf<AirPodsService?>(null) }
-
-                val serviceConnection = object : ServiceConnection {
-                    override fun onServiceConnected(name: ComponentName, service: IBinder) {
-                        val binder = service as AirPodsService.LocalBinder
-                        airPodsService.value = binder.getService()
-                        Log.d("AirPodsService", "Service connected")
-                    }
-
-                    override fun onServiceDisconnected(name: ComponentName) {
-                        airPodsService.value = null
-                    }
-                }
-
-                val intent = Intent(context, AirPodsService::class.java)
-                context.bindService(intent, serviceConnection, Context.BIND_AUTO_CREATE)
-            }
-        }
-    }
-}

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

@@ -1,267 +0,0 @@
-package me.kavishdevar.aln
-
-import android.annotation.SuppressLint
-import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothManager
-import android.bluetooth.BluetoothProfile
-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.os.Build
-import android.os.Bundle
-import android.os.IBinder
-import android.os.ParcelUuid
-import android.util.Log
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import androidx.activity.enableEdgeToEdge
-import androidx.compose.animation.core.tween
-import androidx.compose.animation.slideInHorizontally
-import androidx.compose.animation.slideOutHorizontally
-import androidx.compose.foundation.layout.Column
-import androidx.compose.foundation.layout.PaddingValues
-import androidx.compose.foundation.layout.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.CenterAlignedTopAppBar
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.MaterialTheme
-import androidx.compose.material3.Scaffold
-import androidx.compose.material3.Text
-import androidx.compose.material3.TopAppBarDefaults
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.LaunchedEffect
-import androidx.compose.runtime.MutableState
-import androidx.compose.runtime.mutableStateOf
-import androidx.compose.runtime.remember
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.luminance
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.tooling.preview.PreviewLightDark
-import androidx.compose.ui.unit.dp
-import androidx.core.content.ContextCompat.getSystemService
-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.isGranted
-import com.google.accompanist.permissions.rememberPermissionState
-import com.google.accompanist.permissions.shouldShowRationale
-import me.kavishdevar.aln.ui.theme.ALNTheme
-
-@ExperimentalMaterial3Api
-class MainActivity : ComponentActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        enableEdgeToEdge()
-        setContent {
-            val topAppBarTitle = remember { mutableStateOf("AirPods Pro") }
-            ALNTheme {
-                Scaffold (
-                    containerColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(
-                        0xFF000000
-                    ) else Color(
-                        0xFFF2F2F7
-                    ),
-                    topBar = {
-                        CenterAlignedTopAppBar(
-                            title = {
-                                Text(
-                                    text = topAppBarTitle.value,
-                                    color = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color.White else Color.Black,
-                                )
-                            },
-                            colors = TopAppBarDefaults.centerAlignedTopAppBarColors(
-                                containerColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(
-                                    0xFF000000
-                                ) else Color(
-                                    0xFFF2F2F7
-                                ),
-                            )
-                        )
-                    }
-                ) { innerPadding ->
-                    Main(innerPadding, topAppBarTitle)
-                }
-            }
-        }
-    }
-}
-
-@SuppressLint("MissingPermission")
-@OptIn(ExperimentalPermissionsApi::class)
-@Composable
-fun Main(paddingValues: PaddingValues, topAppBarTitle: MutableState<String>) {
-    val bluetoothConnectPermissionState = rememberPermissionState(
-        permission = "android.permission.BLUETOOTH_CONNECT"
-    )
-
-    if (bluetoothConnectPermissionState.status.isGranted) {
-        val context = LocalContext.current
-        val uuid: ParcelUuid = ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a")
-        val bluetoothManager = getSystemService(context, BluetoothManager::class.java)
-        val bluetoothAdapter = bluetoothManager?.adapter
-        val airpodsDevice = remember { mutableStateOf<BluetoothDevice?>(null) }
-        val airPodsService = remember { mutableStateOf<AirPodsService?>(null) }
-        val navController = rememberNavController()
-
-        val disconnectReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context?, intent: Intent?) {
-                navController.navigate("notConnected")
-            }
-        }
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            context.registerReceiver(disconnectReceiver, IntentFilter(AirPodsNotifications.AIRPODS_DISCONNECTED),
-                Context.RECEIVER_NOT_EXPORTED)
-        }
-
-        // Service connection for AirPodsService
-        val serviceConnection = object : ServiceConnection {
-            override fun onServiceConnected(name: ComponentName, service: IBinder) {
-                val binder = service as AirPodsService.LocalBinder
-                airPodsService.value = binder.getService()
-                Log.d("AirPodsService", "Service connected")
-            }
-
-            override fun onServiceDisconnected(name: ComponentName) {
-                airPodsService.value = null
-            }
-        }
-
-        // Function to check if AirPods are connected
-        fun checkIfAirPodsConnected() {
-            val devices = bluetoothAdapter?.bondedDevices
-            devices?.forEach { device ->
-                if (device.uuids.contains(uuid)) {
-                    bluetoothAdapter.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
-                        override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                            if (profile == BluetoothProfile.A2DP) {
-                                val connectedDevices = proxy.connectedDevices
-                                if (connectedDevices.isNotEmpty()) {
-                                    airpodsDevice.value = device
-                                    val sharedPreferences = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
-                                    topAppBarTitle.value = sharedPreferences.getString("name", device.name) ?: device.name
-                                    // Start AirPods service if not running
-                                    if (context.getSystemService(AirPodsService::class.java)?.isRunning != true) {
-                                        context.startService(Intent(context, AirPodsService::class.java).apply {
-                                            putExtra("device", device)
-                                        })
-                                        context.bindService(Intent(context, AirPodsService::class.java), serviceConnection, Context.BIND_AUTO_CREATE)
-                                    }
-                                } else {
-                                    airpodsDevice.value = null
-                                }
-                            }
-                            bluetoothAdapter.closeProfileProxy(profile, proxy)
-                        }
-
-                        override fun onServiceDisconnected(profile: Int) {}
-                    }, BluetoothProfile.A2DP)
-                }
-            }
-        }
-
-        // BroadcastReceiver to listen for connection state changes
-        val bluetoothReceiver = remember {
-            object : BroadcastReceiver() {
-                override fun onReceive(context: Context?, intent: Intent?) {
-                    val action = intent?.action
-                    val device = intent?.getParcelableExtra<BluetoothDevice>(BluetoothDevice.EXTRA_DEVICE)
-                    if (action == BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED) {
-                        when (intent.getIntExtra(BluetoothAdapter.EXTRA_CONNECTION_STATE, -1)) {
-                            BluetoothAdapter.STATE_CONNECTED -> {
-                                if (device?.uuids?.contains(uuid) == true) {
-                                    airpodsDevice.value = device
-                                    checkIfAirPodsConnected()
-                                }
-                            }
-                            BluetoothAdapter.STATE_DISCONNECTED -> {
-                                if (device?.uuids?.contains(uuid) == true) {
-                                    airpodsDevice.value = null
-                                    // Show not connected screen when AirPods disconnect
-                                    navController.navigate("notConnected")
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Register the receiver in LaunchedEffect
-        LaunchedEffect(Unit) {
-            val filter = IntentFilter().apply {
-                addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED)
-            }
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                context.registerReceiver(bluetoothReceiver, filter, Context.RECEIVER_NOT_EXPORTED)
-            }
-
-            // Initial check for AirPods connection
-            checkIfAirPodsConnected()
-        }
-
-        // UI logic
-        NavHost(
-            navController = navController,
-            startDestination = "notConnected",
-            enterTransition = { slideInHorizontally(initialOffsetX = { it }, animationSpec = tween(300)) },
-            exitTransition = { slideOutHorizontally(targetOffsetX = { -it }, animationSpec = tween(300)) },
-            popEnterTransition = { slideInHorizontally(initialOffsetX = { -it }, animationSpec = tween(300)) },
-            popExitTransition = { slideOutHorizontally(targetOffsetX = { it }, animationSpec = tween(300)) }
-        ) {
-            composable("notConnected") {
-                Text("Not Connected...")
-            }
-            composable("settings") {
-                AirPodsSettingsScreen(
-                    paddingValues,
-                    airpodsDevice.value,
-                    service = airPodsService.value,
-                    navController = navController
-                )
-            }
-            composable("debug") {
-                DebugScreen(navController = navController)
-            }
-        }
-
-        // Automatically navigate to settings screen if AirPods are connected
-        if (airpodsDevice.value != null) {
-            LaunchedEffect(Unit) {
-                navController.navigate("settings") {
-                    popUpTo("notConnected") { inclusive = true }
-                }
-            }
-        } else {
-            Text("No AirPods connected")
-        }
-    } else {
-        // Permission is not granted, request it
-        Column (
-            modifier = Modifier.padding(24.dp),
-        ){
-            val textToShow = if (bluetoothConnectPermissionState.status.shouldShowRationale) {
-                // If the user has denied the permission but not permanently, explain why it's needed.
-                "The BLUETOOTH_CONNECT permission is important for this app. Please grant it to proceed."
-            } else {
-                // If the user has permanently denied the permission, inform them to enable it in settings.
-                "BLUETOOTH_CONNECT permission required for this feature. Please enable it in settings."
-            }
-            Text(textToShow)
-            Button(onClick = { bluetoothConnectPermissionState.launchPermissionRequest() }) {
-                Text("Request permission")
-            }
-        }
-    }
-}
-
-@PreviewLightDark
-@Composable
-fun PreviewAirPodsSettingsScreen() {
-    AirPodsSettingsScreen(paddingValues = PaddingValues(0.dp), device = null, service = null, navController = rememberNavController())
-}

android/app/src/main/java/me/kavishdevar/aln/MediaController.kt

@@ -1,55 +0,0 @@
-package me.kavishdevar.aln
-
-import android.media.AudioManager
-import android.util.Log
-import android.view.KeyEvent
-
-object MediaController {
-    private var initialVolume: Int? = null  // Nullable to track the unset state
-    private lateinit var audioManager: AudioManager  // Declare AudioManager
-
-    // Initialize the singleton with the AudioManager instance
-    fun initialize(audioManager: AudioManager) {
-        this.audioManager = audioManager
-    }
-
-    @Synchronized
-    fun sendPause() {
-        if (audioManager.isMusicActive) {
-            audioManager.dispatchMediaKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MEDIA_PAUSE))
-            audioManager.dispatchMediaKeyEvent(KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PAUSE))
-        }
-    }
-
-    @Synchronized
-    fun sendPlay() {
-        if (!audioManager.isMusicActive) {
-            audioManager.dispatchMediaKeyEvent(KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_MEDIA_PLAY))
-            audioManager.dispatchMediaKeyEvent(KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_MEDIA_PLAY))
-        }
-    }
-
-    @Synchronized
-    fun startSpeaking() {
-        Log.d("MediaController", "Starting speaking")
-        if (initialVolume == null) {
-            initialVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
-            Log.d("MediaController", "Initial Volume Set: $initialVolume")
-            audioManager.setStreamVolume(
-                AudioManager.STREAM_MUSIC,
-                1,  // Set to a lower volume when speaking starts
-                0
-            )
-        }
-        Log.d("MediaController", "Initial Volume: $initialVolume")
-    }
-
-    @Synchronized
-    fun stopSpeaking() {
-        Log.d("MediaController", "Stopping speaking, initialVolume: $initialVolume")
-        initialVolume?.let { volume ->
-            audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, volume, 0)
-            initialVolume = null  // Reset to null after restoring the volume
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/aln/Packets.kt

@@ -1,193 +0,0 @@
-package me.kavishdevar.aln
-
-import android.os.Parcelable
-import kotlinx.parcelize.Parcelize
-
-enum class Enums(val value: ByteArray) {
-    NOISE_CANCELLATION(Capabilities.NOISE_CANCELLATION),
-    CONVERSATION_AWARENESS(Capabilities.CONVERSATION_AWARENESS),
-    CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY(Capabilities.CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY),
-    PREFIX(byteArrayOf(0x04, 0x00, 0x04, 0x00)),
-    SETTINGS(byteArrayOf(0x09, 0x00)),
-    SUFFIX(byteArrayOf(0x00, 0x00, 0x00)),
-    NOTIFICATION_FILTER(byteArrayOf(0x0f)),
-    HANDSHAKE(byteArrayOf(0x00, 0x00, 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)),
-    SPECIFIC_FEATURES(byteArrayOf(0x4d)),
-    SET_SPECIFIC_FEATURES(PREFIX.value + SPECIFIC_FEATURES.value + byteArrayOf(0x00,
-        0xff.toByte(), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)),
-    REQUEST_NOTIFICATIONS(PREFIX.value + NOTIFICATION_FILTER.value + byteArrayOf(0x00, 0xff.toByte(), 0xff.toByte(), 0xff.toByte(), 0xff.toByte())),
-    NOISE_CANCELLATION_PREFIX(PREFIX.value + SETTINGS.value + NOISE_CANCELLATION.value),
-    NOISE_CANCELLATION_OFF(NOISE_CANCELLATION_PREFIX.value + Capabilities.NoiseCancellation.OFF.value + SUFFIX.value),
-    NOISE_CANCELLATION_ON(NOISE_CANCELLATION_PREFIX.value + Capabilities.NoiseCancellation.ON.value + SUFFIX.value),
-    NOISE_CANCELLATION_TRANSPARENCY(NOISE_CANCELLATION_PREFIX.value + Capabilities.NoiseCancellation.TRANSPARENCY.value + SUFFIX.value),
-    NOISE_CANCELLATION_ADAPTIVE(NOISE_CANCELLATION_PREFIX.value + Capabilities.NoiseCancellation.ADAPTIVE.value + SUFFIX.value),
-    SET_CONVERSATION_AWARENESS_OFF(PREFIX.value + SETTINGS.value + CONVERSATION_AWARENESS.value + Capabilities.ConversationAwareness.OFF.value + SUFFIX.value),
-    SET_CONVERSATION_AWARENESS_ON(PREFIX.value + SETTINGS.value + CONVERSATION_AWARENESS.value + Capabilities.ConversationAwareness.ON.value + SUFFIX.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
-}
-
-@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"
-            else -> null
-        }
-    }
-}
-
-class AirPodsNotifications {
-    companion object {
-        const val AIRPODS_CONNECTED = "me.kavishdevar.aln.AIRPODS_CONNECTED"
-        const val AIRPODS_DATA = "me.kavishdevar.aln.AIRPODS_DATA"
-        const val EAR_DETECTION_DATA = "me.kavishdevar.aln.EAR_DETECTION_DATA"
-        const val ANC_DATA = "me.kavishdevar.aln.ANC_DATA"
-        const val BATTERY_DATA = "me.kavishdevar.aln.BATTERY_DATA"
-        const val CA_DATA = "me.kavishdevar.aln.CA_DATA"
-        const val AIRPODS_DISCONNECTED = "me.kavishdevar.aln.AIRPODS_DISCONNECTED"
-    }
-
-    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) {
-            status = data[7].toInt()
-        }
-
-        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.size != 22) {
-                return false
-            }
-            return data[0] == 0x04.toByte() && data[1] == 0x00.toByte() && data[2] == 0x04.toByte() &&
-                    data[3] == 0x00.toByte() && data[4] == 0x04.toByte() && data[5] == 0x00.toByte()
-        }
-
-        fun setBattery(data: ByteArray) {
-            first = Battery(data[7].toInt(), data[9].toInt(), data[10].toInt())
-            second = Battery(data[12].toInt(), data[14].toInt(), data[15].toInt())
-            case = if (data[20].toInt() == BatteryStatus.DISCONNECTED && case.status != BatteryStatus.DISCONNECTED) {
-                Battery(data[17].toInt(), case.level, data[20].toInt())
-            } else {
-                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 {
-        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 CONVERSATION_AWARENESS = byteArrayOf(0x28)
-        val CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY = byteArrayOf(0x01, 0x02)
-        val EAR_DETECTION = byteArrayOf(0x06)
-    }
-
-    enum class NoiseCancellation(val value: ByteArray) {
-        OFF(byteArrayOf(0x01)),
-        ON(byteArrayOf(0x02)),
-        TRANSPARENCY(byteArrayOf(0x03)),
-        ADAPTIVE(byteArrayOf(0x04));
-    }
-
-    enum class ConversationAwareness(val value: ByteArray) {
-        OFF(byteArrayOf(0x02)),
-        ON(byteArrayOf(0x01));
-    }
-}

android/app/src/main/java/me/kavishdevar/aln/StartupReceiver.kt

@@ -1,74 +0,0 @@
-package me.kavishdevar.aln
-
-import android.annotation.SuppressLint
-import android.bluetooth.BluetoothAdapter
-import android.bluetooth.BluetoothDevice
-import android.bluetooth.BluetoothProfile
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.os.ParcelUuid
-
-class StartupReceiver : BroadcastReceiver() {
-
-    companion object {
-        val PodsUUIDS: Set<ParcelUuid> = setOf(
-            ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a"),
-            ParcelUuid.fromString("2a72e02b-7b99-778f-014d-ad0b7221ec74")
-        )
-
-        val btActions: Set<String> = setOf(
-            BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED,
-            BluetoothDevice.ACTION_ACL_CONNECTED,
-            BluetoothDevice.ACTION_ACL_DISCONNECTED,
-            BluetoothDevice.ACTION_BOND_STATE_CHANGED,
-            BluetoothDevice.ACTION_NAME_CHANGED
-        )
-    }
-
-    override fun onReceive(context: Context?, intent: Intent?) {
-        if (intent == null || context == null) return
-
-        intent.action?.let { action ->
-            if (btActions.contains(action)) {
-                try {
-                    val state = intent.getIntExtra(BluetoothProfile.EXTRA_STATE, BluetoothAdapter.ERROR)
-                    val device: BluetoothDevice? = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE)
-                    device?.let {
-                        btProfileChanges(context, state, it)
-                    }
-                } catch (e: NullPointerException) {
-                }
-            }
-        }
-    }
-
-    @SuppressLint("MissingPermission")
-    private fun isPods(device: BluetoothDevice): Boolean {
-        device.uuids?.forEach { uuid ->
-            if (PodsUUIDS.contains(uuid)) {
-                return true
-            }
-        }
-        return false
-    }
-
-    private fun startPodsService(context: Context, device: BluetoothDevice) {
-        if (!isPods(device)) return
-        val intent = Intent(context, AirPodsService::class.java).apply {
-            putExtra(BluetoothDevice.EXTRA_DEVICE, device)
-        }
-        context.startService(intent)
-    }
-
-    private fun stopPodsService(context: Context) {
-        context.stopService(Intent(context, AirPodsService::class.java))
-    }
-
-    private fun btProfileChanges(context: Context, state: Int, device: BluetoothDevice) {
-        when (state) {
-            BluetoothProfile.STATE_CONNECTED -> startPodsService(context, device)
-            BluetoothProfile.STATE_DISCONNECTED, BluetoothProfile.STATE_DISCONNECTING -> stopPodsService(context)
-        }
-    }
-}

android/app/src/main/java/me/kavishdevar/aln/ui/theme/Color.kt

@@ -1,11 +0,0 @@
-package me.kavishdevar.aln.ui.theme
-
-import androidx.compose.ui.graphics.Color
-
-val Purple80 = Color(0xFFD0BCFF)
-val PurpleGrey80 = Color(0xFFCCC2DC)
-val Pink80 = Color(0xFFEFB8C8)
-
-val Purple40 = Color(0xFF6650a4)
-val PurpleGrey40 = Color(0xFF625b71)
-val Pink40 = Color(0xFF7D5260)

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

@@ -0,0 +1,993 @@
+/*
+    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.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.text.input.rememberTextFieldState
+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.focus.FocusRequester
+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.LocalSoftwareKeyboardController
+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.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.ConfirmationDialog
+import me.kavishdevar.librepods.presentation.components.DeviceInfoCard
+import me.kavishdevar.librepods.presentation.components.SelectItem
+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.StyledSelectList
+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
+
+//@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 showDialog = remember { mutableStateOf(false) }
+        val showPlayBypassVisible = remember { mutableStateOf(false) }
+        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)
+                        )
+                    }
+                    StyledButton(
+                        onClick = { showDialog.value = true },
+                        backdrop = rememberLayerBackdrop(),
+                        modifier = Modifier
+                            .fillMaxWidth(),
+                        isInteractive = false,
+                        surfaceColor = if (isDarkTheme) Color(0xFF862424) else Color(0xFFC94646)
+                    ) {
+                        Text(
+                            text = stringResource(R.string.bypass_compatibility_check),
+                            style = TextStyle(
+                                fontFamily = FontFamily(Font(R.font.sf_pro)),
+                                fontWeight = FontWeight.Medium,
+                                color = Color.White,
+                                fontSize = 16.sp
+                            ),
+                        )
+                    }
+                    Spacer(modifier = Modifier.height(24.dp))
+                    DeviceInfoCard()
+                    AppInfoCard()
+                }
+                Spacer(modifier = Modifier.height(48.dp))
+            }
+        }
+
+        ConfirmationDialog(
+            showDialog = showDialog,
+            title = stringResource(R.string.bypass_compatibility_check),
+            message = stringResource(R.string.bypass_compatiblity_check_confirmation),
+            confirmText = stringResource(R.string.yes),
+            dismissText = stringResource(R.string.no),
+            onConfirm = {
+                showDialog.value = false
+                if (BuildConfig.PLAY_BUILD) {
+                    showPlayBypassVisible.value = true
+                } else {
+                    sharedPreferences.edit {
+                        putBoolean("bypass_device_check.v2", true)
+                    }
+                    val intent = Intent(context, MainActivity::class.java)
+                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                    context.startActivity(intent)
+                }
+            },
+            onDismiss = {
+                showDialog.value = false
+            },
+            backdrop = backdrop
+//            hazeState = hazeState
+        )
+
+        if (BuildConfig.PLAY_BUILD) {
+            StyledBottomSheet(
+                visible = showPlayBypassVisible.value,
+                onDismiss = {
+                    showPlayBypassVisible.value = false
+                    showDialog.value = true
+                },
+                backdrop = backdrop
+            ) { innerBackdrop, _ ->
+                val contentColor = if (isDarkTheme) Color.White else Color.Black
+
+                var acknowledged by remember { mutableStateOf(false) }
+                val inputState = rememberTextFieldState("")
+
+                val isValid = acknowledged && inputState.text.trim() == "OK"
+
+                val sfPro = FontFamily(Font(R.font.sf_pro))
+
+                Column(verticalArrangement = Arrangement.spacedBy(12.dp)) {
+                    Text(
+                        text = stringResource(R.string.bypass_compatibility_check),
+                        style = TextStyle(
+                            fontFamily = sfPro,
+                            fontWeight = FontWeight.SemiBold,
+                            fontSize = 18.sp,
+                            color = contentColor
+                        ),
+                        modifier = Modifier.padding(horizontal = 12.dp)
+                    )
+
+                    Text(
+                        text = stringResource(R.string.compatibility_play_dialog_confirmation),
+                        style = TextStyle(
+                            fontFamily = sfPro,
+                            fontWeight = FontWeight.Medium,
+                            fontSize = 14.sp,
+                            color = contentColor
+                        ),
+                        modifier = Modifier.padding(horizontal = 12.dp)
+                    )
+
+                    StyledSelectList(
+                        items = listOf(
+                            SelectItem(
+                                name = stringResource(R.string.read_compatibility_requirements),
+                                selected = acknowledged,
+                                onClick = { acknowledged = !acknowledged }
+                            )
+                        )
+                    )
+
+                    val focusRequester = remember { FocusRequester() }
+                    val keyboardController = LocalSoftwareKeyboardController.current
+
+                    LaunchedEffect(Unit) {
+                        focusRequester.requestFocus()
+                        keyboardController?.show()
+                    }
+
+                    StyledInputField(
+                        inputState = inputState,
+                        focusRequester = focusRequester,
+                        placeholder = stringResource(R.string.type_ok_to_continue, "OK")
+                    )
+
+                    Row(
+                        modifier = Modifier.fillMaxWidth(),
+                        horizontalArrangement = Arrangement.spacedBy(24.dp)
+                    ) {
+                        StyledButton(
+                            onClick = { showPlayBypassVisible.value = false },
+                            backdrop = innerBackdrop,
+                            modifier = Modifier.weight(1f),
+                        ) {
+                            Text(
+                                text = stringResource(R.string.no),
+                                style = TextStyle(
+                                    fontFamily = sfPro,
+                                    fontWeight = FontWeight.Medium,
+                                    fontSize = 14.sp,
+                                    color = contentColor
+                                )
+                            )
+                        }
+                        StyledButton(
+                            onClick =  {
+                                showPlayBypassVisible.value = false
+                                sharedPreferences.edit {
+                                    putBoolean("bypass_device_check.v2", true)
+                                    val intent = Intent(context, MainActivity::class.java)
+                                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                                    context.startActivity(intent)
+                                }
+                            },
+                            backdrop = innerBackdrop,
+                            isInteractive = isValid,
+                            modifier = Modifier.weight(1f),
+                            enabled = isValid,
+                            surfaceColor = if (isDarkTheme) Color(0xFF0091FF) else Color(0xFF0088FF)
+                        ) {
+                            Text(
+                                text = stringResource(R.string.proceed),
+                                style = TextStyle(
+                                    fontFamily = sfPro,
+                                    fontWeight = FontWeight.Medium,
+                                    fontSize = 14.sp,
+                                    color = if (isValid) contentColor else contentColor.copy(alpha = 0.4f)
+                                )
+                            )
+                        }
+                    }
+                }
+            }
+        }
+
+        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()
+
+        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()
+                    }
+                    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()
+                }
+
+                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) })
+    }
+}
+
+@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

@@ -0,0 +1,639 @@
+/*
+    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/billing/BillingManager.kt

@@ -0,0 +1,5 @@
+package me.kavishdevar.librepods.billing
+
+object BillingManager {
+    lateinit var provider: BillingProvider
+}

android/app/src/main/java/me/kavishdevar/librepods/billing/BillingProvider.kt

@@ -0,0 +1,30 @@
+/*
+    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.billing
+
+import android.app.Activity
+import kotlinx.coroutines.flow.StateFlow
+
+interface BillingProvider {
+    val isPremium: StateFlow<Boolean>
+    val price: StateFlow<String>
+    fun purchase(activity: Activity)
+    fun queryPurchases()
+    fun restorePurchases()
+}

android/app/src/main/java/me/kavishdevar/librepods/billing/BillingProviderFactory.kt

@@ -0,0 +1,33 @@
+/*
+    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.billing
+
+import android.content.Context
+import me.kavishdevar.librepods.BuildConfig
+
+object BillingProviderFactory {
+
+    fun create(context: Context): BillingProvider {
+        return if (BuildConfig.PLAY_BUILD) {
+            PlayBillingProvider(context)
+        } else {
+            FOSSBillingProvider(context)
+        }
+    }
+}

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

@@ -0,0 +1,77 @@
+/*
+    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.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
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.R
+
+class FOSSBillingProvider(context: Context): BillingProvider {
+    private val _isPremium = MutableStateFlow(false)
+    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
+
+    init {
+        queryPurchases()
+    }
+
+    override fun purchase(activity: Activity) {
+        activity.startActivity(
+            Intent(Intent.ACTION_VIEW, "https://github.com/sponsors/kavishdevar".toUri())
+        )
+
+        purchaseJob?.cancel()
+
+        purchaseJob = scope.launch {
+            delay(5_000)
+            _isPremium.value = true
+            sharedPreferences.edit { putBoolean("foss_upgraded", true) }
+        }
+    }
+
+    override fun queryPurchases() {
+        val stored = sharedPreferences.getBoolean("foss_upgraded", false)
+        if (stored != _isPremium.value) {
+            _isPremium.value = stored
+        }
+    }
+
+    override fun restorePurchases() {
+        _isPremium.value = true
+        sharedPreferences.edit { putBoolean("foss_upgraded", true) }
+    }
+}

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

@@ -0,0 +1,206 @@
+/*
+    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.billing
+
+import android.app.Activity
+import android.content.Context
+import android.util.Log
+import com.android.billingclient.api.AcknowledgePurchaseParams
+import com.android.billingclient.api.BillingClient
+import com.android.billingclient.api.BillingClientStateListener
+import com.android.billingclient.api.BillingFlowParams
+import com.android.billingclient.api.BillingResult
+import com.android.billingclient.api.PendingPurchasesParams
+import com.android.billingclient.api.ProductDetails
+import com.android.billingclient.api.Purchase
+import com.android.billingclient.api.PurchasesUpdatedListener
+import com.android.billingclient.api.QueryProductDetailsParams
+import com.android.billingclient.api.QueryPurchasesParams
+import com.android.billingclient.api.acknowledgePurchase
+import com.android.billingclient.api.queryProductDetails
+import com.android.billingclient.api.queryPurchasesAsync
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+
+const val TAG = "PlayBillingProvider"
+
+private const val PREMIUM_PRODUCT_ID = "librepods.advanced_features.v2"
+
+class PlayBillingProvider(
+    context: Context
+) : BillingProvider, PurchasesUpdatedListener {
+
+    private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+
+    private val _isPremium = MutableStateFlow(false)
+    override val isPremium: StateFlow<Boolean> = _isPremium
+
+    private val _price = MutableStateFlow("unknown")
+    override val price: StateFlow<String> = _price
+
+
+    private var productDetails: ProductDetails? = null
+
+    private val billingClient = BillingClient.newBuilder(context)
+        .setListener(this)
+        .enablePendingPurchases(
+            PendingPurchasesParams.newBuilder().enableOneTimeProducts().build()
+        )
+        .build()
+
+    init {
+        connect()
+    }
+
+    private fun connect() {
+        billingClient.startConnection(object : BillingClientStateListener {
+            override fun onBillingSetupFinished(result: BillingResult) {
+                if (result.responseCode == BillingClient.BillingResponseCode.OK) {
+                    scope.launch {
+                        queryProductDetails()
+                        queryExistingPurchases()
+                    }
+                } else {
+                    Log.w(TAG, "Billing setup failed: ${result.debugMessage}")
+                }
+            }
+
+            override fun onBillingServiceDisconnected() {
+                connect()
+            }
+        })
+    }
+
+    private suspend fun queryProductDetails() {
+        val params = QueryProductDetailsParams.newBuilder()
+            .setProductList(
+                listOf(
+                    QueryProductDetailsParams.Product.newBuilder()
+                        .setProductId(PREMIUM_PRODUCT_ID)
+                        .setProductType(BillingClient.ProductType.INAPP)
+                        .build()
+                )
+            ).build()
+
+        val result = billingClient.queryProductDetails(params)
+        if (result.billingResult.responseCode == BillingClient.BillingResponseCode.OK) {
+            productDetails = result.productDetailsList?.firstOrNull()
+            Log.d(TAG, "Product loaded: ${productDetails?.name}")
+            val priceString = productDetails
+                ?.oneTimePurchaseOfferDetails
+                ?.formattedPrice
+
+            if (priceString != null) {
+                _price.value = priceString
+            }
+        } else {
+            Log.w(TAG, "queryProductDetails failed: ${result.billingResult.debugMessage}")
+        }
+    }
+
+    private suspend fun queryExistingPurchases() {
+        val result = billingClient.queryPurchasesAsync(
+            QueryPurchasesParams.newBuilder()
+                .setProductType(BillingClient.ProductType.INAPP)
+                .build()
+        )
+        processPurchases(result.purchasesList)
+    }
+
+    override fun purchase(activity: Activity) {
+        val details = productDetails ?: run {
+            Log.e(TAG, "Product details not loaded yet")
+            return
+        }
+
+        val billingFlowParams = BillingFlowParams.newBuilder()
+            .setProductDetailsParamsList(
+                listOf(
+                    BillingFlowParams.ProductDetailsParams.newBuilder()
+                        .setProductDetails(details)
+                        .build()
+                )
+            ).build()
+
+        val result = billingClient.launchBillingFlow(activity, billingFlowParams)
+        if (result.responseCode != BillingClient.BillingResponseCode.OK) {
+            Log.e(TAG, "launchBillingFlow failed: ${result.debugMessage}")
+        }
+    }
+
+    override fun onPurchasesUpdated(result: BillingResult, purchases: List<Purchase>?) {
+        when (result.responseCode) {
+            BillingClient.BillingResponseCode.OK -> purchases?.let { processPurchases(it) }
+            BillingClient.BillingResponseCode.USER_CANCELED -> Log.d(TAG, "User cancelled")
+            else -> Log.w(TAG, "Purchase error ${result.responseCode}: ${result.debugMessage}")
+        }
+    }
+
+    private fun processPurchases(purchases: List<Purchase>) {
+        val hasPremium = purchases.any {
+            it.products.contains(PREMIUM_PRODUCT_ID) &&
+                it.purchaseState == Purchase.PurchaseState.PURCHASED
+        }
+
+//        val purchase = purchases.find {
+//            it.products.contains(PREMIUM_PRODUCT_ID) && it.purchaseState == Purchase.PurchaseState.PURCHASED
+//        }
+//
+//        if (purchase != null) {
+//            val consumeParams = ConsumeParams.newBuilder()
+//                .setPurchaseToken(purchase.purchaseToken)
+//                .build()
+//            scope.launch {
+//                billingClient.consumeAsync(consumeParams) { _, _ ->}
+//            }
+//        }
+
+        _isPremium.value = hasPremium
+
+        scope.launch {
+            purchases
+                .filter { it.purchaseState == Purchase.PurchaseState.PURCHASED && !it.isAcknowledged }
+                .forEach { acknowledge(it) }
+        }
+    }
+
+    private suspend fun acknowledge(purchase: Purchase) {
+        val params = AcknowledgePurchaseParams.newBuilder()
+            .setPurchaseToken(purchase.purchaseToken)
+            .build()
+        val result = billingClient.acknowledgePurchase(params)
+        if (result.responseCode != BillingClient.BillingResponseCode.OK) {
+            Log.e(TAG, "Acknowledgement failed: ${result.debugMessage}")
+        }
+    }
+
+    override fun queryPurchases() {
+        scope.launch {
+            queryExistingPurchases()
+        }
+    }
+
+    override fun restorePurchases() {
+        queryPurchases()
+    }
+}

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

@@ -0,0 +1,248 @@
+/*
+    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 a very basic ATT (Attribute Protocol) implementation. I have only implemented
+  * what is necessary for LibrePods to function, i.e. reading and writing characteristics,
+  * and receiving notifications. It is not a complete implementation of the ATT protocol.
+ */
+
+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.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.launch
+import java.io.InputStream
+import java.io.OutputStream
+import java.util.concurrent.LinkedBlockingQueue
+import java.util.concurrent.TimeUnit
+
+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),
+    HEARING_AID(ATTHandles.HEARING_AID.value + 1),
+}
+
+class ATTManager(private val adapter: BluetoothAdapter, private val device: BluetoothDevice) {
+    companion object {
+        private const val TAG = "ATTManager"
+
+        private const val OPCODE_READ_REQUEST: Byte = 0x0A
+        private const val OPCODE_WRITE_REQUEST: Byte = 0x12
+        private const val OPCODE_HANDLE_VALUE_NTF: Byte = 0x1B
+    }
+
+    var socket: BluetoothSocket? = null
+    private var input: InputStream? = null
+    private var output: OutputStream? = null
+    private val listeners = mutableMapOf<Int, MutableList<(ByteArray) -> Unit>>()
+    private var notificationJob: Job? = null
+
+    // queue for non-notification PDUs (responses to requests)
+    private val responses = LinkedBlockingQueue<ByteArray>()
+
+    @SuppressLint("MissingPermission")
+    fun connect() {
+        val uuid = ParcelUuid.fromString("00000000-0000-0000-0000-000000000000")
+
+        try {
+            socket = createBluetoothSocket(adapter, device, uuid)
+        } catch (e: Exception) {
+            Log.w(TAG, "Failed to create socket")
+        }
+        try {
+            socket!!.connect()
+        } catch (e: Exception) {
+            Log.w(TAG, "ATT socket failed to connect")
+            return
+        }
+        input = socket!!.inputStream
+        output = socket!!.outputStream
+        Log.d(TAG, "Connected to ATT")
+
+        notificationJob = CoroutineScope(Dispatchers.IO).launch {
+            while (socket?.isConnected == true) {
+                try {
+                    val pdu = readPDU()
+                    if (pdu.isNotEmpty() && pdu[0] == OPCODE_HANDLE_VALUE_NTF) {
+                        // notification -> dispatch to listeners
+                        val handle = (pdu[1].toInt() and 0xFF) or ((pdu[2].toInt() and 0xFF) shl 8)
+                        val value = pdu.copyOfRange(3, pdu.size)
+                        listeners[handle]?.forEach { listener ->
+                            try {
+                                listener(value)
+                                Log.d(TAG, "Dispatched notification for handle $handle to listener, with value ${value.joinToString(" ") { String.format("%02X", it) }}")
+                            } catch (e: Exception) {
+                                Log.w(TAG, "Error in listener for handle $handle: ${e.message}")
+                            }
+                        }
+                    } else {
+                        // not a notification -> treat as a response for pending request(s)
+                        responses.put(pdu)
+                    }
+                } catch (e: Exception) {
+                    Log.w(TAG, "Error reading notification/response: ${e.message}")
+                    if (socket?.isConnected != true) break
+                }
+            }
+        }
+    }
+
+    fun disconnect() {
+        try {
+            notificationJob?.cancel()
+            socket?.close()
+        } catch (e: Exception) {
+            Log.w(TAG, "Error closing socket: ${e.message}")
+        }
+    }
+
+    fun registerListener(handle: ATTHandles, listener: (ByteArray) -> Unit) {
+        listeners.getOrPut(handle.value) { mutableListOf() }.add(listener)
+    }
+
+    fun unregisterListener(handle: ATTHandles, listener: (ByteArray) -> Unit) {
+        listeners[handle.value]?.remove(listener)
+    }
+
+    fun enableNotifications(handle: ATTHandles) {
+        write(ATTCCCDHandles.valueOf(handle.name), byteArrayOf(0x01, 0x00))
+    }
+
+    fun read(handle: ATTHandles): ByteArray {
+        val lsb = (handle.value and 0xFF).toByte()
+        val msb = ((handle.value shr 8) and 0xFF).toByte()
+        val pdu = byteArrayOf(OPCODE_READ_REQUEST, lsb, msb)
+        writeRaw(pdu)
+        // wait for response placed into responses queue by the reader coroutine
+        return readResponse()
+    }
+
+    fun write(handle: ATTHandles, value: ByteArray) {
+        val lsb = (handle.value and 0xFF).toByte()
+        val msb = ((handle.value shr 8) and 0xFF).toByte()
+        val pdu = byteArrayOf(OPCODE_WRITE_REQUEST, lsb, msb) + value
+        writeRaw(pdu)
+        // usually a Write Response (0x13) will arrive; wait for it (but discard return)
+        try {
+            readResponse()
+        } catch (e: Exception) {
+            Log.w(TAG, "No write response received: ${e.message}")
+        }
+    }
+
+    fun write(handle: ATTCCCDHandles, value: ByteArray) {
+        val lsb = (handle.value and 0xFF).toByte()
+        val msb = ((handle.value shr 8) and 0xFF).toByte()
+        val pdu = byteArrayOf(OPCODE_WRITE_REQUEST, lsb, msb) + value
+        writeRaw(pdu)
+        // usually a Write Response (0x13) will arrive; wait for it (but discard return)
+        try {
+            readResponse()
+        } catch (e: Exception) {
+            Log.w(TAG, "No write response received: ${e.message}")
+        }
+    }
+
+    private fun writeRaw(pdu: ByteArray) {
+        output?.write(pdu)
+        output?.flush()
+        Log.d(TAG, "writeRaw: ${pdu.joinToString(" ") { String.format("%02X", it) }}")
+    }
+
+    // rename / specialize: read raw PDU directly from input stream (blocking)
+    private fun readPDU(): ByteArray {
+        val inp = input ?: throw IllegalStateException("Not connected")
+        val buffer = ByteArray(512)
+        val len = inp.read(buffer)
+        if (len == -1) {
+            disconnect()
+            throw IllegalStateException("End of stream reached")
+        }
+        val data = buffer.copyOfRange(0, len)
+        Log.d(TAG, "readPDU: ${data.joinToString(" ") { String.format("%02X", it) }}")
+        return data
+    }
+
+    // wait for a response PDU produced by the background reader
+    private fun readResponse(timeoutMs: Long = 2000): ByteArray {
+        try {
+            val resp = responses.poll(timeoutMs, TimeUnit.MILLISECONDS)
+                ?: throw IllegalStateException("No response read from ATT socket within $timeoutMs ms")
+            Log.d(TAG, "readResponse: ${resp.joinToString(" ") { String.format("%02X", it) }}")
+            return resp.copyOfRange(1, resp.size)
+        } catch (e: InterruptedException) {
+            Thread.currentThread().interrupt()
+            throw IllegalStateException("Interrupted while waiting for ATT response", e)
+        }
+    }
+
+    private fun createBluetoothSocket(adapter: BluetoothAdapter, device: BluetoothDevice, uuid: ParcelUuid): BluetoothSocket {
+        val type = 3 // L2CAP
+        val constructorSpecs = listOf(
+            arrayOf(adapter, device, type, true, true, 31, uuid),
+            arrayOf(device, type, true, true, 31, uuid),
+            arrayOf(device, type, 1, true, true, 31, uuid),
+            arrayOf(type, 1, true, true, device, 31, uuid),
+            arrayOf(type, true, true, device, 31, uuid)
+        )
+
+        val constructors = BluetoothSocket::class.java.declaredConstructors
+        Log.d("ATTManager", "BluetoothSocket has ${constructors.size} constructors:")
+
+        constructors.forEachIndexed { index, constructor ->
+            val params = constructor.parameterTypes.joinToString(", ") { it.simpleName }
+            Log.d("ATTManager", "Constructor $index: ($params)")
+        }
+
+        var lastException: Exception? = null
+        var attemptedConstructors = 0
+
+        for ((index, params) in constructorSpecs.withIndex()) {
+            try {
+                Log.d("ATTManager", "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("ATTManager", "Constructor signature #${index + 1} failed: ${e.message}")
+                lastException = e
+            }
+        }
+
+        val errorMessage = "Failed to create BluetoothSocket after trying $attemptedConstructors constructor signatures"
+        Log.e("ATTManager", errorMessage)
+        throw lastException ?: IllegalStateException(errorMessage)
+    }
+}

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

@@ -0,0 +1,498 @@
+/*
+    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.BluetoothManager
+import android.bluetooth.le.BluetoothLeScanner
+import android.bluetooth.le.ScanCallback
+import android.bluetooth.le.ScanFilter
+import android.bluetooth.le.ScanResult
+import android.bluetooth.le.ScanSettings
+import android.content.Context
+import android.content.SharedPreferences
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import me.kavishdevar.librepods.utils.BluetoothCryptography
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+import kotlin.collections.iterator
+import kotlin.io.encoding.Base64
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+/**
+ * Manager for Bluetooth Low Energy scanning operations specifically for AirPods
+ */
+@OptIn(ExperimentalEncodingApi::class)
+class BLEManager(private val context: Context) {
+
+    data class AirPodsStatus(
+        val address: String,
+        val lastSeen: Long = System.currentTimeMillis(),
+        val paired: Boolean = false,
+        val model: String = "Unknown",
+        val leftBattery: Int? = null,
+        val rightBattery: Int? = null,
+        val caseBattery: Int? = null,
+        val isLeftInEar: Boolean = false,
+        val isRightInEar: Boolean = false,
+        val isLeftCharging: Boolean = false,
+        val isRightCharging: Boolean = false,
+        val isCaseCharging: Boolean = false,
+        val lidOpen: Boolean = false,
+        val color: String = "Unknown",
+        val connectionState: String = "Unknown"
+    )
+
+    fun getMostRecentStatus(): AirPodsStatus? {
+        return deviceStatusMap.values.maxByOrNull { it.lastSeen }
+    }
+
+    interface AirPodsStatusListener {
+        fun onDeviceStatusChanged(device: AirPodsStatus, previousStatus: AirPodsStatus?)
+        fun onBroadcastFromNewAddress(device: AirPodsStatus)
+        fun onLidStateChanged(lidOpen: Boolean)
+        fun onEarStateChanged(device: AirPodsStatus, leftInEar: Boolean, rightInEar: Boolean)
+        fun onBatteryChanged(device: AirPodsStatus)
+        fun onDeviceDisappeared()
+    }
+
+    private var mBluetoothLeScanner: BluetoothLeScanner? = null
+    private var mScanCallback: ScanCallback? = null
+    private var airPodsStatusListener: AirPodsStatusListener? = null
+    private val deviceStatusMap = mutableMapOf<String, AirPodsStatus>()
+    private val verifiedAddresses = mutableSetOf<String>()
+    private val sharedPreferences: SharedPreferences = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    private var currentGlobalLidState: Boolean? = null
+    private var lastBroadcastTime: Long = 0
+    private val processedAddresses = mutableSetOf<String>()
+
+    private val lastValidCaseBatteryMap = mutableMapOf<String, Int>()
+    private val modelNames = mapOf(
+        0x0E20 to "AirPods Pro",
+        0x1420 to "AirPods Pro 2",
+        0x2420 to "AirPods Pro 2 (USB-C)",
+        0x0220 to "AirPods 1",
+        0x0F20 to "AirPods 2",
+        0x1320 to "AirPods 3",
+        0x1920 to "AirPods 4",
+        0x1B20 to "AirPods 4 (ANC)",
+        0x0A20 to "AirPods Max",
+        0x1F20 to "AirPods Max (USB-C)"
+    )
+
+    val colorNames = mapOf(
+        0x00 to "White", 0x01 to "Black", 0x02 to "Red", 0x03 to "Blue",
+        0x04 to "Pink", 0x05 to "Gray", 0x06 to "Silver", 0x07 to "Gold",
+        0x08 to "Rose Gold", 0x09 to "Space Gray", 0x0A to "Dark Blue",
+        0x0B to "Light Blue", 0x0C to "Yellow"
+    )
+
+    val connStates = mapOf(
+        0x00 to "Disconnected", 0x04 to "Idle", 0x05 to "Music",
+        0x06 to "Call", 0x07 to "Ringing", 0x09 to "Hanging Up", 0xFF to "Unknown"
+    )
+
+    private val cleanupHandler = Handler(Looper.getMainLooper())
+    private val cleanupRunnable = object : Runnable {
+        override fun run() {
+            cleanupStaleDevices()
+            checkLidStateTimeout()
+            cleanupHandler.postDelayed(this, CLEANUP_INTERVAL_MS)
+        }
+    }
+
+    fun setAirPodsStatusListener(listener: AirPodsStatusListener) {
+        airPodsStatusListener = listener
+    }
+
+    @SuppressLint("MissingPermission")
+    fun startScanning() {
+        try {
+            Log.d(TAG, "Starting BLE scanner")
+
+            val btManager = context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+            val btAdapter = btManager.adapter
+
+            if (btAdapter == null) {
+                Log.d(TAG, "No Bluetooth adapter available")
+                return
+            }
+
+            if (mBluetoothLeScanner != null && mScanCallback != null) {
+                mBluetoothLeScanner?.stopScan(mScanCallback)
+                mScanCallback = null
+            }
+
+            if (!btAdapter.isEnabled) {
+                Log.d(TAG, "Bluetooth is disabled")
+                return
+            }
+
+            mBluetoothLeScanner = btAdapter.bluetoothLeScanner
+
+            val scanSettings = ScanSettings.Builder()
+                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
+                .setMatchMode(ScanSettings.MATCH_MODE_AGGRESSIVE)
+                .setCallbackType(ScanSettings.CALLBACK_TYPE_ALL_MATCHES)
+                .setNumOfMatches(ScanSettings.MATCH_NUM_MAX_ADVERTISEMENT)
+                .setReportDelay(500L)
+                .build()
+
+            val manufacturerData = ByteArray(27)
+            val manufacturerDataMask = ByteArray(27)
+
+            manufacturerData[0] = 7
+            manufacturerData[1] = 25
+
+            manufacturerDataMask[0] = -1
+            manufacturerDataMask[1] = -1
+
+            val scanFilter = ScanFilter.Builder()
+                .setManufacturerData(76, manufacturerData, manufacturerDataMask)
+                .build()
+
+            mScanCallback = object : ScanCallback() {
+                override fun onScanResult(callbackType: Int, result: ScanResult) {
+                    processScanResult(result)
+                }
+
+                override fun onBatchScanResults(results: List<ScanResult>) {
+                    processedAddresses.clear()
+                    for (result in results) {
+                        processScanResult(result)
+                    }
+                }
+
+                override fun onScanFailed(errorCode: Int) {
+                    Log.e(TAG, "BLE scan failed with error code: $errorCode")
+                }
+            }
+
+            mBluetoothLeScanner?.startScan(listOf(scanFilter), scanSettings, mScanCallback)
+            Log.d(TAG, "BLE scanner started successfully")
+
+            cleanupHandler.postDelayed(cleanupRunnable, CLEANUP_INTERVAL_MS)
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error starting BLE scanner", t)
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    fun stopScanning() {
+        try {
+            if (mBluetoothLeScanner != null && mScanCallback != null) {
+                Log.d(TAG, "Stopping BLE scanner")
+                mBluetoothLeScanner?.stopScan(mScanCallback)
+                mScanCallback = null
+            }
+
+            cleanupHandler.removeCallbacks(cleanupRunnable)
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error stopping BLE scanner", t)
+        }
+    }
+
+    @OptIn(ExperimentalEncodingApi::class)
+    private fun getEncryptionKeyFromPreferences(): ByteArray? {
+        val keyBase64 = sharedPreferences.getString(AACPManager.Companion.ProximityKeyType.ENC_KEY.name, null)
+        return if (keyBase64 != null) {
+            try {
+                Base64.decode(keyBase64)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to decode encryption key", e)
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    @SuppressLint("GetInstance")
+    private fun decryptLastBytes(data: ByteArray, key: ByteArray): ByteArray? {
+        return try {
+            if (data.size < 16) {
+                return null
+            }
+
+            val block = data.copyOfRange(data.size - 16, data.size)
+            val cipher = Cipher.getInstance("AES/ECB/NoPadding")
+            val secretKey = SecretKeySpec(key, "AES")
+            cipher.init(Cipher.DECRYPT_MODE, secretKey)
+            cipher.doFinal(block)
+        } catch (e: Exception) {
+            Log.e(TAG, "Error decrypting data", e)
+            null
+        }
+    }
+
+    private fun formatBattery(byteVal: Int): Pair<Boolean, Int> {
+        val charging = (byteVal and 0x80) != 0
+        val level = byteVal and 0x7F
+        return Pair(charging, level)
+    }
+
+    private fun processScanResult(result: ScanResult) {
+        try {
+            val scanRecord = result.scanRecord ?: return
+            val address = result.device.address
+
+            if (processedAddresses.contains(address)) {
+                return
+            }
+
+            val manufacturerData = scanRecord.getManufacturerSpecificData(76) ?: return
+            if (manufacturerData.size <= 20) return
+
+            if (!verifiedAddresses.contains(address)) {
+                val irk = getIrkFromPreferences()
+                if (irk == null || !BluetoothCryptography.verifyRPA(address, irk)) {
+                    return
+                }
+                verifiedAddresses.add(address)
+                Log.d(TAG, "RPA verified and added to trusted list: $address")
+            }
+
+            processedAddresses.add(address)
+            lastBroadcastTime = System.currentTimeMillis()
+
+            val encryptionKey = getEncryptionKeyFromPreferences()
+            val decryptedData = if (encryptionKey != null) decryptLastBytes(manufacturerData, encryptionKey) else null
+            val parsedStatus = if (decryptedData != null && decryptedData.size == 16) {
+                parseProximityMessageWithDecryption(address, manufacturerData, decryptedData)
+            } else {
+                parseProximityMessage(address, manufacturerData)
+            }
+
+            val previousStatus = deviceStatusMap[address]
+            deviceStatusMap[address] = parsedStatus
+
+            airPodsStatusListener?.let { listener ->
+                if (previousStatus == null) {
+                    listener.onBroadcastFromNewAddress(parsedStatus)
+                    Log.d(TAG, "New AirPods device detected: $address")
+
+                    if (currentGlobalLidState == null || currentGlobalLidState != parsedStatus.lidOpen) {
+                        currentGlobalLidState = parsedStatus.lidOpen
+                        listener.onLidStateChanged(parsedStatus.lidOpen)
+                        Log.d(TAG, "Lid state ${if (parsedStatus.lidOpen) "opened" else "closed"} (detected from new device)")
+                    }
+                } else {
+                    if (parsedStatus != previousStatus) {
+                        listener.onDeviceStatusChanged(parsedStatus, previousStatus)
+                    }
+
+                    if (parsedStatus.lidOpen != previousStatus.lidOpen) {
+                        val previousGlobalState = currentGlobalLidState
+                        currentGlobalLidState = parsedStatus.lidOpen
+
+                        if (previousGlobalState != parsedStatus.lidOpen) {
+                            listener.onLidStateChanged(parsedStatus.lidOpen)
+                            Log.d(TAG, "Lid state changed from $previousGlobalState to ${parsedStatus.lidOpen}")
+                        }
+                    }
+
+                    if (parsedStatus.isLeftInEar != previousStatus.isLeftInEar ||
+                        parsedStatus.isRightInEar != previousStatus.isRightInEar) {
+                        listener.onEarStateChanged(
+                            parsedStatus,
+                            parsedStatus.isLeftInEar,
+                            parsedStatus.isRightInEar
+                        )
+                        Log.d(TAG, "Ear state changed - Left: ${parsedStatus.isLeftInEar}, Right: ${parsedStatus.isRightInEar}")
+                    }
+
+                    if (parsedStatus.leftBattery != previousStatus.leftBattery ||
+                        parsedStatus.rightBattery != previousStatus.rightBattery ||
+                        parsedStatus.caseBattery != previousStatus.caseBattery) {
+                        listener.onBatteryChanged(parsedStatus)
+                        Log.d(TAG, "Battery changed - Left: ${parsedStatus.leftBattery}, Right: ${parsedStatus.rightBattery}, Case: ${parsedStatus.caseBattery}")
+                    }
+                }
+            }
+        } catch (t: Throwable) {
+            Log.e(TAG, "Error processing scan result", t)
+        }
+    }
+
+    private fun parseProximityMessageWithDecryption(address: String, data: ByteArray, decrypted: ByteArray): AirPodsStatus {
+        val paired = data[2].toInt() == 1
+        val modelId = ((data[3].toInt() and 0xFF) shl 8) or (data[4].toInt() and 0xFF)
+        val model = modelNames[modelId] ?: "Unknown ($modelId)"
+
+        val status = data[5].toInt() and 0xFF
+//        val flagsCase = data[7].toInt() and 0xFF
+        val lid = data[8].toInt() and 0xFF
+        val color = colorNames[data[9].toInt()] ?: "Unknown"
+        val conn = connStates[data[10].toInt()] ?: "Unknown (${data[10].toInt()})"
+
+        val primaryLeft = ((status shr 5) and 0x01) == 1
+        val thisInCase = ((status shr 6) and 0x01) == 1
+        val xorFactor = primaryLeft xor thisInCase
+
+        val isLeftInEar = if (xorFactor) (status and 0x08) != 0 else (status and 0x02) != 0
+        val isRightInEar = if (xorFactor) (status and 0x02) != 0 else (status and 0x08) != 0
+
+        val isFlipped = !primaryLeft
+
+        val leftByteIndex = if (isFlipped) 2 else 1
+        val rightByteIndex = if (isFlipped) 1 else 2
+
+        val (isLeftCharging, leftBattery) = formatBattery(decrypted[leftByteIndex].toInt() and 0xFF)
+        val (isRightCharging, rightBattery) = formatBattery(decrypted[rightByteIndex].toInt() and 0xFF)
+
+        val rawCaseBatteryByte = decrypted[3].toInt() and 0xFF
+        val (isCaseCharging, rawCaseBattery) = formatBattery(rawCaseBatteryByte)
+
+        val caseBattery = if (rawCaseBatteryByte == 0xFF || (isCaseCharging && rawCaseBattery == 127)) {
+            lastValidCaseBatteryMap[address]
+        } else {
+            lastValidCaseBatteryMap[address] = rawCaseBattery
+            rawCaseBattery
+        }
+
+        val lidOpen = ((lid shr 3) and 0x01) == 0
+
+        return AirPodsStatus(
+            address = address,
+            lastSeen = System.currentTimeMillis(),
+            paired = paired,
+            model = model,
+            leftBattery = leftBattery,
+            rightBattery = rightBattery,
+            caseBattery = caseBattery,
+            isLeftInEar = isLeftInEar,
+            isRightInEar = isRightInEar,
+            isLeftCharging = isLeftCharging,
+            isRightCharging = isRightCharging,
+            isCaseCharging = isCaseCharging,
+            lidOpen = lidOpen,
+            color = color,
+            connectionState = conn
+        )
+    }
+
+    private fun cleanupStaleDevices() {
+        val now = System.currentTimeMillis()
+        val staleCutoff = now - STALE_DEVICE_TIMEOUT_MS
+        val hadDevices = deviceStatusMap.isNotEmpty()
+
+        val staleDevices = deviceStatusMap.filter { it.value.lastSeen < staleCutoff }
+
+        for (device in staleDevices) {
+            deviceStatusMap.remove(device.key)
+            Log.d(TAG, "Removed stale device from tracking: ${device.key}")
+        }
+
+        if (hadDevices && deviceStatusMap.isEmpty()) {
+            airPodsStatusListener?.onDeviceDisappeared()
+        }
+    }
+
+    private fun checkLidStateTimeout() {
+        val currentTime = System.currentTimeMillis()
+        if (currentTime - lastBroadcastTime > LID_CLOSE_TIMEOUT_MS && currentGlobalLidState == true) {
+            Log.d(TAG, "No broadcasts for ${LID_CLOSE_TIMEOUT_MS}ms, forcing lid state to closed")
+            currentGlobalLidState = false
+            airPodsStatusListener?.onLidStateChanged(false)
+        }
+    }
+
+    @OptIn(ExperimentalEncodingApi::class)
+    private fun getIrkFromPreferences(): ByteArray? {
+        val irkBase64 = sharedPreferences.getString(AACPManager.Companion.ProximityKeyType.IRK.name, null)
+        return if (irkBase64 != null) {
+            try {
+                Base64.decode(irkBase64)
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to decode IRK", e)
+                null
+            }
+        } else {
+            null
+        }
+    }
+
+    private fun parseProximityMessage(address: String, data: ByteArray): AirPodsStatus {
+        val paired = data[2].toInt() == 1
+        val modelId = ((data[3].toInt() and 0xFF) shl 8) or (data[4].toInt() and 0xFF)
+        val model = modelNames[modelId] ?: "Unknown ($modelId)"
+
+        val status = data[5].toInt() and 0xFF
+        val podsBattery = data[6].toInt() and 0xFF
+        val flagsCase = data[7].toInt() and 0xFF
+        val lid = data[8].toInt() and 0xFF
+        val color = colorNames[data[9].toInt()] ?: "Unknown"
+        val conn = connStates[data[10].toInt()] ?: "Unknown (${data[10].toInt()})"
+
+        val primaryLeft = ((status shr 5) and 0x01) == 1
+        val thisInCase = ((status shr 6) and 0x01) == 1
+        val xorFactor = primaryLeft xor thisInCase
+
+        val isLeftInEar = if (xorFactor) (status and 0x08) != 0 else (status and 0x02) != 0
+        val isRightInEar = if (xorFactor) (status and 0x02) != 0 else (status and 0x08) != 0
+
+        val isFlipped = !primaryLeft
+
+        val leftBatteryNibble = if (isFlipped) (podsBattery shr 4) and 0x0F else podsBattery and 0x0F
+        val rightBatteryNibble = if (isFlipped) podsBattery and 0x0F else (podsBattery shr 4) and 0x0F
+
+        val caseBattery = flagsCase and 0x0F
+        val flags = (flagsCase shr 4) and 0x0F
+
+        val isLeftCharging = if (isFlipped) (flags and 0x02) != 0 else (flags and 0x01) != 0
+        val isRightCharging = if (isFlipped) (flags and 0x01) != 0 else (flags and 0x02) != 0
+        val isCaseCharging = (flags and 0x04) != 0
+
+        val lidOpen = ((lid shr 3) and 0x01) == 0
+
+        fun decodeBattery(n: Int): Int? = when (n) {
+            in 0x0..0x9 -> n * 10
+            in 0xA..0xE -> 100
+            0xF -> null
+            else -> null
+        }
+
+        return AirPodsStatus(
+            address = address,
+            lastSeen = System.currentTimeMillis(),
+            paired = paired,
+            model = model,
+            leftBattery = decodeBattery(leftBatteryNibble),
+            rightBattery = decodeBattery(rightBatteryNibble),
+            caseBattery = decodeBattery(caseBattery),
+            isLeftInEar = isLeftInEar,
+            isRightInEar = isRightInEar,
+            isLeftCharging = isLeftCharging,
+            isRightCharging = isRightCharging,
+            isCaseCharging = isCaseCharging,
+            lidOpen = lidOpen,
+            color = color,
+            connectionState = conn
+        )
+    }
+
+    companion object {
+        private const val TAG = "AirPodsBLE"
+        private const val CLEANUP_INTERVAL_MS = 10000L
+        private const val STALE_DEVICE_TIMEOUT_MS = 15000L
+        private const val LID_CLOSE_TIMEOUT_MS = 2500L
+    }
+}

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

@@ -0,0 +1,40 @@
+/*
+    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.BluetoothDevice
+import android.bluetooth.BluetoothSocket
+import android.util.Log
+
+object BluetoothConnectionManager {
+    private const val TAG = "BluetoothConnectionManager"
+
+    private var currentSocket: BluetoothSocket? = null
+    private var currentDevice: BluetoothDevice? = null
+
+    fun setCurrentConnection(socket: BluetoothSocket, device: BluetoothDevice) {
+        currentSocket = socket
+        currentDevice = device
+        Log.d(TAG, "Current connection set to device: ${device.address}")
+    }
+
+    fun getCurrentSocket(): BluetoothSocket? {
+        return currentSocket
+    }
+}

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

@@ -0,0 +1,277 @@
+/*
+    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

@@ -0,0 +1,70 @@
+/*
+    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/HearingAid.kt

@@ -0,0 +1,192 @@
+/*
+    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.util.Log
+import androidx.compose.runtime.MutableState
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.bluetooth.ATTHandles
+import me.kavishdevar.librepods.bluetooth.ATTManager
+import java.io.IOException
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+private const val TAG = "HearingAidUtils"
+
+data class HearingAidSettings(
+    val leftEQ: FloatArray,
+    val rightEQ: FloatArray,
+    val leftAmplification: Float,
+    val rightAmplification: Float,
+    val leftTone: Float,
+    val rightTone: Float,
+    val leftConversationBoost: Boolean,
+    val rightConversationBoost: Boolean,
+    val leftAmbientNoiseReduction: Float,
+    val rightAmbientNoiseReduction: Float,
+    val netAmplification: Float,
+    val balance: Float,
+    val ownVoiceAmplification: Float
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as HearingAidSettings
+
+        if (leftAmplification != other.leftAmplification) return false
+        if (rightAmplification != other.rightAmplification) return false
+        if (leftTone != other.leftTone) return false
+        if (rightTone != other.rightTone) return false
+        if (leftConversationBoost != other.leftConversationBoost) return false
+        if (rightConversationBoost != other.rightConversationBoost) return false
+        if (leftAmbientNoiseReduction != other.leftAmbientNoiseReduction) return false
+        if (rightAmbientNoiseReduction != other.rightAmbientNoiseReduction) return false
+        if (!leftEQ.contentEquals(other.leftEQ)) return false
+        if (!rightEQ.contentEquals(other.rightEQ)) return false
+        if (ownVoiceAmplification != other.ownVoiceAmplification) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = leftAmplification.hashCode()
+        result = 31 * result + rightAmplification.hashCode()
+        result = 31 * result + leftTone.hashCode()
+        result = 31 * result + rightTone.hashCode()
+        result = 31 * result + leftConversationBoost.hashCode()
+        result = 31 * result + rightConversationBoost.hashCode()
+        result = 31 * result + leftAmbientNoiseReduction.hashCode()
+        result = 31 * result + rightAmbientNoiseReduction.hashCode()
+        result = 31 * result + leftEQ.contentHashCode()
+        result = 31 * result + rightEQ.contentHashCode()
+        result = 31 * result + ownVoiceAmplification.hashCode()
+        return result
+    }
+}
+
+fun parseHearingAidSettingsResponse(data: ByteArray): HearingAidSettings? {
+    if (data.size < 104) return null
+    val buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+
+    buffer.get() // skip 0x02
+    buffer.get() // skip 0x02
+    buffer.getShort() // skip 0x60 0x00
+
+    val leftEQ = FloatArray(8)
+    for (i in 0..7) {
+        leftEQ[i] = buffer.float
+    }
+    val leftAmplification = buffer.float
+    val leftTone = buffer.float
+    val leftConvFloat = buffer.float
+    val leftConversationBoost = leftConvFloat > 0.5f
+    val leftAmbientNoiseReduction = buffer.float
+
+    val rightEQ = FloatArray(8)
+    for (i in 0..7) {
+        rightEQ[i] = buffer.float
+    }
+    val rightAmplification = buffer.float
+    val rightTone = buffer.float
+    val rightConvFloat = buffer.float
+    val rightConversationBoost = rightConvFloat > 0.5f
+    val rightAmbientNoiseReduction = buffer.float
+
+    val ownVoiceAmplification = buffer.float
+
+    val avg = (leftAmplification + rightAmplification) / 2
+    val amplification = avg.coerceIn(-1f, 1f)
+    val diff = rightAmplification - leftAmplification
+    val balance = diff.coerceIn(-1f, 1f)
+
+    return HearingAidSettings(
+        leftEQ = leftEQ,
+        rightEQ = rightEQ,
+        leftAmplification = leftAmplification,
+        rightAmplification = rightAmplification,
+        leftTone = leftTone,
+        rightTone = rightTone,
+        leftConversationBoost = leftConversationBoost,
+        rightConversationBoost = rightConversationBoost,
+        leftAmbientNoiseReduction = leftAmbientNoiseReduction,
+        rightAmbientNoiseReduction = rightAmbientNoiseReduction,
+        netAmplification = amplification,
+        balance = balance,
+        ownVoiceAmplification = ownVoiceAmplification
+    )
+}
+
+fun sendHearingAidSettings(
+    attManager: ATTManager,
+    hearingAidSettings: HearingAidSettings,
+    debounceJob: MutableState<Job?>
+) {
+    debounceJob.value?.cancel()
+    debounceJob.value = CoroutineScope(Dispatchers.IO).launch {
+        delay(100)
+        try {
+            val currentData = attManager.read(ATTHandles.HEARING_AID)
+            Log.d(TAG, "Current data before update: ${currentData.joinToString(" ") { String.format("%02X", it) }}")
+            if (currentData.size < 104) {
+                Log.w(TAG, "Current data size ${currentData.size} too small, cannot send settings")
+                return@launch
+            }
+            val buffer = ByteBuffer.wrap(currentData).order(ByteOrder.LITTLE_ENDIAN)
+
+            // for some reason
+            buffer.put(2, 0x64)
+
+            // Left EQ
+            for (i in 0..7) {
+                buffer.putFloat(4 + i * 4, hearingAidSettings.leftEQ[i])
+            }
+
+            // Left ear adjustments
+            buffer.putFloat(36, hearingAidSettings.leftAmplification)
+            buffer.putFloat(40, hearingAidSettings.leftTone)
+            buffer.putFloat(44, if (hearingAidSettings.leftConversationBoost) 1.0f else 0.0f)
+            buffer.putFloat(48, hearingAidSettings.leftAmbientNoiseReduction)
+
+            // Right EQ
+            for (i in 0..7) {
+                buffer.putFloat(52 + i * 4, hearingAidSettings.rightEQ[i])
+            }
+
+            // Right ear adjustments
+            buffer.putFloat(84, hearingAidSettings.rightAmplification)
+            buffer.putFloat(88, hearingAidSettings.rightTone)
+            buffer.putFloat(92, if (hearingAidSettings.rightConversationBoost) 1.0f else 0.0f)
+            buffer.putFloat(96, hearingAidSettings.rightAmbientNoiseReduction)
+
+            // Own voice amplification
+            buffer.putFloat(100, hearingAidSettings.ownVoiceAmplification)
+
+            Log.d(TAG, "Sending updated settings: ${currentData.joinToString(" ") { String.format("%02X", it) }}")
+
+            attManager.write(ATTHandles.HEARING_AID, currentData)
+        } catch (e: IOException) {
+            e.printStackTrace()
+        }
+    }
+}

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

@@ -0,0 +1,270 @@
+/*
+    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/data/StemAction.kt

@@ -0,0 +1,40 @@
+/*
+    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
+
+enum class StemAction {
+    PLAY_PAUSE,
+    PREVIOUS_TRACK,
+    NEXT_TRACK,
+    DIGITAL_ASSISTANT,
+    CYCLE_NOISE_CONTROL_MODES;
+    companion object {
+        fun fromString(action: String): StemAction? {
+            return entries.find { it.name == action }
+        }
+        val defaultActions: Map<AACPManager.Companion.StemPressType, StemAction> = mapOf(
+            AACPManager.Companion.StemPressType.SINGLE_PRESS to PLAY_PAUSE,
+            AACPManager.Companion.StemPressType.DOUBLE_PRESS to NEXT_TRACK,
+            AACPManager.Companion.StemPressType.TRIPLE_PRESS to PREVIOUS_TRACK,
+            AACPManager.Companion.StemPressType.LONG_PRESS to CYCLE_NOISE_CONTROL_MODES,
+        )
+    }
+}

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

@@ -0,0 +1,180 @@
+/*
+    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 kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.bluetooth.ATTHandles
+import java.io.IOException
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+data class TransparencySettings(
+    val enabled: Boolean,
+    val leftEQ: FloatArray,
+    val rightEQ: FloatArray,
+    val leftAmplification: Float,
+    val rightAmplification: Float,
+    val leftTone: Float,
+    val rightTone: Float,
+    val leftConversationBoost: Boolean,
+    val rightConversationBoost: Boolean,
+    val leftAmbientNoiseReduction: Float,
+    val rightAmbientNoiseReduction: Float,
+    val netAmplification: Float,
+    val balance: Float,
+    val ownVoiceAmplification: Float? = null
+) {
+    override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (javaClass != other?.javaClass) return false
+
+        other as TransparencySettings
+
+        if (enabled != other.enabled) return false
+        if (leftAmplification != other.leftAmplification) return false
+        if (rightAmplification != other.rightAmplification) return false
+        if (leftTone != other.leftTone) return false
+        if (rightTone != other.rightTone) return false
+        if (leftConversationBoost != other.leftConversationBoost) return false
+        if (rightConversationBoost != other.rightConversationBoost) return false
+        if (leftAmbientNoiseReduction != other.leftAmbientNoiseReduction) return false
+        if (rightAmbientNoiseReduction != other.rightAmbientNoiseReduction) return false
+        if (!leftEQ.contentEquals(other.leftEQ)) return false
+        if (!rightEQ.contentEquals(other.rightEQ)) return false
+        if (ownVoiceAmplification != other.ownVoiceAmplification) return false
+
+        return true
+    }
+
+    override fun hashCode(): Int {
+        var result = enabled.hashCode()
+        result = 31 * result + leftAmplification.hashCode()
+        result = 31 * result + rightAmplification.hashCode()
+        result = 31 * result + leftTone.hashCode()
+        result = 31 * result + rightTone.hashCode()
+        result = 31 * result + leftConversationBoost.hashCode()
+        result = 31 * result + rightConversationBoost.hashCode()
+        result = 31 * result + leftAmbientNoiseReduction.hashCode()
+        result = 31 * result + rightAmbientNoiseReduction.hashCode()
+        result = 31 * result + leftEQ.contentHashCode()
+        result = 31 * result + rightEQ.contentHashCode()
+        result = 31 * result + (ownVoiceAmplification?.hashCode() ?: 0)
+        return result
+    }
+}
+
+fun parseTransparencySettingsResponse(data: ByteArray): TransparencySettings {
+    val buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+
+    val enabled = buffer.float
+
+    val leftEQ = FloatArray(8)
+    for (i in 0..7) {
+        leftEQ[i] = buffer.float
+    }
+    val leftAmplification = buffer.float
+    val leftTone = buffer.float
+    val leftConvFloat = buffer.float
+    val leftConversationBoost = leftConvFloat > 0.5f
+    val leftAmbientNoiseReduction = buffer.float
+
+    val rightEQ = FloatArray(8)
+    for (i in 0..7) {
+        rightEQ[i] = buffer.float
+    }
+
+    val rightAmplification = buffer.float
+    val rightTone = buffer.float
+    val rightConvFloat = buffer.float
+    val rightConversationBoost = rightConvFloat > 0.5f
+    val rightAmbientNoiseReduction = buffer.float
+
+    val ownVoiceAmplification = if (buffer.remaining() >= 4) {
+        buffer.float
+    } else {
+        null
+    }
+
+    val avg = (leftAmplification + rightAmplification) / 2
+    val amplification = avg.coerceIn(-1f, 1f)
+    val diff = rightAmplification - leftAmplification
+    val balance = diff.coerceIn(-1f, 1f)
+
+    return TransparencySettings(
+        enabled = enabled > 0.5f,
+        leftEQ = leftEQ,
+        rightEQ = rightEQ,
+        leftAmplification = leftAmplification,
+        rightAmplification = rightAmplification,
+        leftTone = leftTone,
+        rightTone = rightTone,
+        leftConversationBoost = leftConversationBoost,
+        rightConversationBoost = rightConversationBoost,
+        leftAmbientNoiseReduction = leftAmbientNoiseReduction,
+        rightAmbientNoiseReduction = rightAmbientNoiseReduction,
+        netAmplification = amplification,
+        balance = balance,
+        ownVoiceAmplification = ownVoiceAmplification
+    )
+}
+
+private var debounceJob: Job? = null
+
+fun sendTransparencySettings(writer: (ATTHandles, ByteArray) -> Unit, transparencySettings: TransparencySettings) {
+    debounceJob?.cancel()
+    debounceJob = CoroutineScope(Dispatchers.IO).launch {
+        delay(100)
+        try {
+            val buffer = ByteBuffer.allocate(
+                if (transparencySettings.ownVoiceAmplification != null) 104 else 100
+            ).order(ByteOrder.LITTLE_ENDIAN)
+
+            buffer.putFloat(if (transparencySettings.enabled) 1.0f else 0.0f)
+
+            for (eq in transparencySettings.leftEQ) {
+                buffer.putFloat(eq)
+            }
+            buffer.putFloat(transparencySettings.leftAmplification)
+            buffer.putFloat(transparencySettings.leftTone)
+            buffer.putFloat(if (transparencySettings.leftConversationBoost) 1.0f else 0.0f)
+            buffer.putFloat(transparencySettings.leftAmbientNoiseReduction)
+
+            for (eq in transparencySettings.rightEQ) {
+                buffer.putFloat(eq)
+            }
+            buffer.putFloat(transparencySettings.rightAmplification)
+            buffer.putFloat(transparencySettings.rightTone)
+            buffer.putFloat(if (transparencySettings.rightConversationBoost) 1.0f else 0.0f)
+            buffer.putFloat(transparencySettings.rightAmbientNoiseReduction)
+
+            if (transparencySettings.ownVoiceAmplification != null) {
+                buffer.putFloat(transparencySettings.ownVoiceAmplification)
+            }
+
+            val data = buffer.array()
+            writer(ATTHandles.TRANSPARENCY, data)
+        } catch (e: IOException) {
+            e.printStackTrace()
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package me.kavishdevar.librepods.data
+
+interface XposedRemotePref {
+    fun isAvailable(): Boolean
+
+    fun getBoolean(key: String, def: Boolean): Boolean
+    fun putBoolean(key: String, value: Boolean)
+}

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

@@ -0,0 +1,5 @@
+package me.kavishdevar.librepods.data
+
+object XposedRemotePrefProvider {
+    fun create(): XposedRemotePref = XposedRemotePrefImpl()
+}

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

@@ -0,0 +1,206 @@
+/*
+    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

@@ -0,0 +1,193 @@
+/*
+    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

@@ -0,0 +1,182 @@
+/*
+    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/BatteryIndicator.kt

@@ -0,0 +1,214 @@
+/*
+    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.content.res.Configuration
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.tween
+import androidx.compose.foundation.Canvas
+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.Spacer
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.geometry.Rect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.StrokeCap
+import androidx.compose.ui.graphics.drawscope.Stroke
+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.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.data.BatteryStatus
+import kotlin.math.cos
+import kotlin.math.min
+import kotlin.math.sin
+import kotlin.math.sqrt
+
+@Composable
+fun BatteryIndicator(
+    batteryPercentage: Int,
+    status: Int,
+    prefix: String = "",
+    previousCharging: Boolean = false,
+) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val backgroundColor = if (isDarkTheme) Color.Black else Color(0xFFF2F2F7)
+    val batteryTextColor = if (isDarkTheme) Color.White else Color.Black
+    val batteryFillColor =
+        if (batteryPercentage > 25) if (isDarkTheme) Color(0xFF2ED158) else Color(0xFF35C759)
+        else if (isDarkTheme) Color(0xFFFC4244) else Color(0xFFfe373C)
+
+    val initialScale = if (previousCharging) 1f else 0f
+    val scaleAnim = remember { Animatable(initialScale) }
+    val charging = status == BatteryStatus.CHARGING || status == BatteryStatus.OPTIMIZED_CHARGING
+    val targetScale = if (charging) 1f else 0f
+
+    LaunchedEffect(previousCharging, charging) {
+        scaleAnim.animateTo(targetScale, animationSpec = tween(durationMillis = 250))
+    }
+
+    Column(
+        modifier = Modifier.background(backgroundColor).padding(4.dp), // just for haze to work
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        Box(
+            modifier = Modifier.padding(bottom = 4.dp), contentAlignment = Alignment.Center
+        ) {
+            val strokeWidthPx = with(LocalDensity.current) { 4.dp.toPx() }
+            val gapFromCenterPx = with(LocalDensity.current) { 8.sp.toPx() }
+
+            val trackColor = if (isDarkTheme) Color(0xFF272728) else Color(0xFFE3E3E8)
+            val optimizedLimit = 0.8f
+            val progress = batteryPercentage / 100f
+
+            Canvas(modifier = Modifier.size(34.dp)) {
+                val startAngle = -90f
+                val stroke = Stroke(width = strokeWidthPx, cap = StrokeCap.Round)
+                val inset = strokeWidthPx / 2
+                Rect(
+                    left = inset,
+                    top = inset,
+                    right = size.width - inset,
+                    bottom = size.height - inset
+                )
+                val radius = size.minDimension / 2
+
+                if (status == BatteryStatus.OPTIMIZED_CHARGING) {
+                    drawArc(
+                        color = trackColor,
+                        startAngle = startAngle,
+                        sweepAngle = 360f * optimizedLimit,
+                        useCenter = false,
+                        style = stroke
+                    )
+
+                    val sweep = 360f * min(progress, optimizedLimit)
+                    drawArc(
+                        color = batteryFillColor,
+                        startAngle = startAngle,
+                        sweepAngle = sweep,
+                        useCenter = false,
+                        style = stroke
+                    )
+
+                    // ---- PILL MARKER AT 80% ----
+                    val angleDeg = startAngle + 360f * optimizedLimit
+                    val angleRad = Math.toRadians(angleDeg.toDouble())
+
+                    val arcRadius = radius - strokeWidthPx
+
+                    val outerX = center.x + arcRadius * cos(angleRad).toFloat()
+                    val outerY = center.y + arcRadius * sin(angleRad).toFloat()
+
+                    val dirX = center.x - outerX
+                    val dirY = center.y - outerY
+                    val length = sqrt(dirX * dirX + dirY * dirY)
+
+                    val normX = dirX / length
+                    val normY = dirY / length
+
+                    val startX = outerX - normX * strokeWidthPx / 2
+                    val startY = outerY - normY * strokeWidthPx / 2
+
+                    val endX = center.x - normX * gapFromCenterPx
+                    val endY = center.y - normY * gapFromCenterPx
+
+                    drawLine(
+                        color = if (batteryPercentage >= 80) batteryFillColor else trackColor,
+                        start = Offset(startX, startY),
+                        end = Offset(endX, endY),
+                        strokeWidth = strokeWidthPx,
+                        cap = StrokeCap.Round
+                    )
+                } else {
+                    drawArc(
+                        color = trackColor,
+                        startAngle = 0f,
+                        sweepAngle = 360f,
+                        useCenter = false,
+                        style = stroke
+                    )
+
+                    drawArc(
+                        color = batteryFillColor,
+                        startAngle = startAngle,
+                        sweepAngle = 360f * progress,
+                        useCenter = false,
+                        style = stroke
+                    )
+                }
+            }
+
+            Text(
+                text = "\uDBC0\uDEE6", style = TextStyle(
+                    fontSize = 14.sp,
+                    fontFamily = FontFamily(Font(R.font.sf_pro)),
+                    color = batteryFillColor,
+                    textAlign = TextAlign.Center
+                ), modifier = Modifier.scale(scaleAnim.value)
+            )
+        }
+
+        Spacer(modifier = Modifier.height(4.dp))
+
+        Text(
+            text = "$prefix $batteryPercentage%",
+            color = batteryTextColor,
+            style = TextStyle(
+                fontSize = 14.sp,
+                fontFamily = FontFamily(Font(R.font.sf_pro)),
+                textAlign = TextAlign.Center
+            ),
+        )
+    }
+}
+
+@Preview(uiMode = Configuration.UI_MODE_NIGHT_YES)
+@Composable
+fun BatteryIndicatorPreview() {
+    val bg = if (isSystemInDarkTheme()) Color.Black else Color(0xFFF2F2F7)
+    Box(
+        modifier = Modifier.background(bg)
+    ) {
+        BatteryIndicator(
+            batteryPercentage = 50,
+            status = BatteryStatus.OPTIMIZED_CHARGING,
+            prefix = "\uDBC6\uDCE5",
+            previousCharging = false
+        )
+    }
+}

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

@@ -0,0 +1,177 @@
+/*
+    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

@@ -0,0 +1,432 @@
+/*
+    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

@@ -0,0 +1,179 @@
+/*
+    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

@@ -0,0 +1,75 @@
+/*
+    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

@@ -0,0 +1,106 @@
+/*
+    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

@@ -0,0 +1,242 @@
+/*
+    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

@@ -0,0 +1,235 @@
+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

@@ -0,0 +1,118 @@
+/*
+    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

@@ -0,0 +1,263 @@
+/*
+    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

@@ -0,0 +1,179 @@
+/*
+    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/NoiseControlButton.kt

@@ -0,0 +1,77 @@
+/*
+    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.clickable
+import androidx.compose.foundation.interaction.MutableInteractionSource
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.material3.Icon
+import androidx.compose.runtime.Composable
+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.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import me.kavishdevar.librepods.R
+
+@Composable
+fun NoiseControlButton(
+    icon: ImageBitmap,
+    onClick: () -> Unit,
+    textColor: Color,
+    modifier: Modifier = Modifier,
+    usePadding: Boolean = true
+) {
+    Column(
+        modifier = modifier
+            .fillMaxHeight()
+            .then(if (usePadding) Modifier.padding(horizontal = 4.dp, vertical = 4.dp) else Modifier)
+            .clickable(
+                onClick = onClick,
+                indication = null,
+                interactionSource = remember { MutableInteractionSource() }
+            ),
+        horizontalAlignment = Alignment.CenterHorizontally,
+        verticalArrangement = Arrangement.Center
+    ) {
+        Icon(
+            bitmap = icon,
+            contentDescription = null,
+            tint = textColor,
+            modifier = Modifier.size(40.dp)
+        )
+    }
+}
+
+@Preview
+@Composable
+fun NoiseControlButtonPreview() {
+    NoiseControlButton(
+        icon = ImageBitmap.imageResource(R.drawable.noise_cancellation),
+        onClick = {},
+        textColor = Color.White,
+    )
+}

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

@@ -0,0 +1,397 @@
+/*
+    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

@@ -0,0 +1,108 @@
+/*
+    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/StyledBottomSheet.kt

@@ -0,0 +1,87 @@
+package me.kavishdevar.librepods.presentation.components
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.ModalBottomSheet
+import androidx.compose.material3.SheetValue
+import androidx.compose.material3.rememberModalBottomSheetState
+import androidx.compose.runtime.Composable
+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.unit.dp
+import androidx.compose.ui.unit.lerp
+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
+
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun StyledBottomSheet(
+    visible: Boolean,
+    onDismiss: () -> Unit,
+    backdrop: LayerBackdrop,
+    content: @Composable (innerBackdrop: LayerBackdrop, progress: Float) -> Unit
+) {
+    if (!visible) return
+
+    val isDarkTheme = isSystemInDarkTheme()
+    val sheetState = rememberModalBottomSheetState(false) // move this to parent composable
+
+    val isExpanded =  sheetState.targetValue == SheetValue.Expanded
+
+    val progress by animateFloatAsState(
+        targetValue = if (isExpanded) 1f else 0f,
+        label = "sheetProgress"
+    )
+
+    val animatedCorner = lerp(48.dp, 42.dp, progress)
+
+    ModalBottomSheet(
+        onDismissRequest = onDismiss,
+        sheetState = sheetState,
+        containerColor = Color.Transparent,
+        dragHandle = { },
+        shape = RoundedCornerShape(animatedCorner),
+        scrimColor = Color.Transparent,
+        modifier = Modifier.padding(4.dp)
+    ) {
+        val innerBackdrop = rememberLayerBackdrop()
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clip(RoundedCornerShape(animatedCorner))
+                .drawBackdrop(
+                    backdrop = backdrop,
+                    exportedBackdrop = innerBackdrop,
+                    shape = { RoundedCornerShape(animatedCorner) },
+                    effects = {
+                        vibrancy()
+                        blur(4f.dp.toPx())
+                        lens(12f.dp.toPx(), 48f.dp.toPx(), true)
+                    },
+                    onDrawSurface = {
+                        drawRect(
+                            if (isDarkTheme) Color.DarkGray.copy(alpha = 0.3f) else Color(
+                                0xFFE0E0E0
+                            ).copy(alpha = 0.45f)
+                        )
+                    }
+                )
+                .padding(top = 24.dp)
+                .padding(horizontal = 16.dp)
+        ) {
+            content(innerBackdrop, progress)
+        }
+    }
+}

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

@@ -0,0 +1,329 @@
+/*
+    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

@@ -0,0 +1,259 @@
+/*
+    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

@@ -0,0 +1,306 @@
+/*
+    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

@@ -0,0 +1,154 @@
+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

@@ -0,0 +1,163 @@
+/*
+    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()
+        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

@@ -0,0 +1,187 @@
+/*
+    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.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
+                            .heightIn(min = 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

@@ -0,0 +1,631 @@
+/*
+    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/StyledSwitch.kt

@@ -0,0 +1,317 @@
+/*
+    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.content.res.Configuration
+import androidx.compose.animation.animateColorAsState
+import androidx.compose.animation.core.Animatable
+import androidx.compose.animation.core.FastOutSlowInEasing
+import androidx.compose.animation.core.spring
+import androidx.compose.animation.core.tween
+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.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.width
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+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.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.graphics.BlendMode
+import androidx.compose.ui.graphics.BlurEffect
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.Paint
+import androidx.compose.ui.graphics.TileMode
+import androidx.compose.ui.graphics.drawOutline
+import androidx.compose.ui.graphics.drawscope.drawIntoCanvas
+import androidx.compose.ui.graphics.drawscope.scale
+import androidx.compose.ui.graphics.drawscope.translate
+import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.layer.CompositingStrategy
+import androidx.compose.ui.graphics.layer.drawLayer
+import androidx.compose.ui.graphics.rememberGraphicsLayer
+import androidx.compose.ui.hapticfeedback.HapticFeedbackType
+import androidx.compose.ui.layout.onSizeChanged
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.platform.LocalHapticFeedback
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.util.fastCoerceIn
+import androidx.compose.ui.util.lerp
+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.lens
+import com.kyant.backdrop.highlight.Highlight
+import com.kyant.backdrop.shadow.Shadow
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.launch
+import kotlin.math.abs
+
+@Composable
+fun StyledSwitch(
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    enabled: Boolean = true,
+) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val haptics = LocalHapticFeedback.current
+
+    val onColor = if (enabled) Color(0xFF34C759) else if (isDarkTheme) Color(0xFF5B5B5E) else Color(0xFFD1D1D6)
+    val offColor = if (enabled) if (isDarkTheme) Color(0xFF5B5B5E) else Color(0xFFD1D1D6) else if (isDarkTheme) Color(
+        0x805B5B5E
+    ) else Color(0xFFD1D1D6)
+
+    val trackWidth = 64.dp
+    val trackHeight = 28.dp
+    val thumbHeight = 24.dp
+    val thumbWidth = 39.dp
+
+    val backdrop = rememberLayerBackdrop()
+    val switchBackdrop = rememberLayerBackdrop()
+    val fraction by remember {
+        derivedStateOf { if (checked) 1f else 0f }
+    }
+    val animatedFraction = remember { Animatable(fraction) }
+    val trackWidthPx = remember { mutableFloatStateOf(0f) }
+    val density = LocalDensity.current
+    val scope = rememberCoroutineScope()
+    val progressAnimationSpec = spring(0.5f, 300f, 0.001f)
+    val progressAnimation = remember { Animatable(0f) }
+    val innerShadowLayer = rememberGraphicsLayer().apply {
+        compositingStrategy = CompositingStrategy.Offscreen
+    }
+    val targetColor = if (checked) onColor else offColor
+    val animatedTrackColor by animateColorAsState(targetColor)
+    val totalDrag = remember { mutableFloatStateOf(0f) }
+    val tapThreshold = 10f
+    val isFirstComposition = remember { mutableStateOf(true) }
+    LaunchedEffect(checked) {
+        if (!isFirstComposition.value) {
+            if (checked) {
+                haptics.performHapticFeedback(HapticFeedbackType.ToggleOn)
+            } else {
+                haptics.performHapticFeedback(HapticFeedbackType.ToggleOff)
+            }
+            coroutineScope {
+                launch {
+                    val targetFrac = if (checked) 1f else 0f
+                    animatedFraction.animateTo(targetFrac, progressAnimationSpec)
+                }
+                if (progressAnimation.value > 0f) return@coroutineScope
+                launch {
+                    progressAnimation.animateTo(1f, tween(175, easing = FastOutSlowInEasing))
+                    progressAnimation.animateTo(0f, tween(175, easing = FastOutSlowInEasing))
+                }
+            }
+        }
+        isFirstComposition.value = false
+    }
+
+    Box(
+        modifier = Modifier
+            .width(trackWidth)
+            .height(trackHeight),
+        contentAlignment = Alignment.CenterStart
+    ) {
+        Box(
+            modifier = Modifier
+                .layerBackdrop(switchBackdrop)
+                .clip(RoundedCornerShape(trackHeight / 2))
+                .background(animatedTrackColor)
+                .width(trackWidth)
+                .height(trackHeight)
+                .onSizeChanged { trackWidthPx.floatValue = it.width.toFloat() }
+        )
+        Box(
+            modifier = Modifier
+                .padding(horizontal = 2.dp)
+                .graphicsLayer {
+                    translationX = animatedFraction.value * (trackWidthPx.floatValue - with(density) { thumbWidth.toPx() + 4.dp.toPx() })
+                }
+                .then(if (enabled) Modifier.draggable(
+                    rememberDraggableState { delta ->
+                        if (trackWidthPx.floatValue > 0f) {
+                            val oldFraction = animatedFraction.value
+                            val newFraction = (animatedFraction.value + delta / trackWidthPx.floatValue).fastCoerceIn(-0.3f, 1.3f)
+                            scope.launch {
+                                animatedFraction.snapTo(newFraction)
+                            }
+                            totalDrag.floatValue += abs(delta)
+                            val newChecked = newFraction >= 0.5f
+                            if (newChecked != checked) {
+                                onCheckedChange(newChecked)
+                            }
+                            if ((oldFraction < 0.5f && newFraction >= 0.5f) || (oldFraction >= 0.5f && newFraction < 0.5f)) {
+                                haptics.performHapticFeedback(HapticFeedbackType.SegmentTick)
+                            }
+                        }
+                    },
+                    Orientation.Horizontal,
+                    startDragImmediately = true,
+                    onDragStarted = {
+                        totalDrag.floatValue = 0f
+                        scope.launch {
+                            progressAnimation.animateTo(1f, progressAnimationSpec)
+                        }
+                    },
+                    onDragStopped = {
+                        scope.launch {
+                            if (totalDrag.floatValue < tapThreshold) {
+                                val newChecked = !checked
+                                onCheckedChange(newChecked)
+                                val snappedFraction = if (newChecked) 1f else 0f
+                                coroutineScope {
+                                    launch { progressAnimation.animateTo(0f, progressAnimationSpec) }
+                                    launch { animatedFraction.animateTo(snappedFraction, progressAnimationSpec) }
+                                }
+                            } else {
+                                val snappedFraction = if (animatedFraction.value >= 0.5f) 1f else 0f
+                                onCheckedChange(snappedFraction >= 0.5f)
+                                coroutineScope {
+                                    launch { progressAnimation.animateTo(0f, progressAnimationSpec) }
+                                    launch { animatedFraction.animateTo(snappedFraction, progressAnimationSpec) }
+                                }
+                            }
+                        }
+                    }
+                ) else Modifier)
+                .drawBackdrop(
+                    rememberCombinedBackdrop(backdrop, switchBackdrop),
+                    { RoundedCornerShape(thumbHeight / 2) },
+                    highlight = {
+                        val progress = progressAnimation.value
+                        Highlight.Ambient.copy(
+                            alpha = progress
+                        )
+                    },
+                    shadow = {
+                        Shadow(
+                            radius = 4f.dp,
+                            color = Color.Black.copy(0.05f)
+                        )
+                    },
+                    layerBlock = {
+                        val progress = progressAnimation.value
+                        val scale = lerp(1f, 1.5f, progress)
+                        scaleX = scale
+                        scaleY = scale
+                    },
+                    onDrawBackdrop = { drawScope ->
+                        drawIntoCanvas { canvas ->
+                            canvas.save()
+                            canvas.drawRect(
+                                left = 0f,
+                                top = 0f,
+                                right = size.width,
+                                bottom = size.height,
+                                paint = Paint().apply {
+                                    color = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFF2F2F7)
+                                }
+                            )
+                            scale(0.7f) {
+                                drawScope()
+                            }
+                        }
+                    },
+                    onDrawSurface = {
+                        val progress = progressAnimation.value.fastCoerceIn(0f, 1f)
+
+                        val shape = RoundedCornerShape(thumbHeight / 2)
+                        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)
+
+                        drawRect(Color.White.copy(1f - progress))
+                    },
+                    effects = {
+                        lens(
+                            refractionHeight = 6f.dp.toPx(),
+                            refractionAmount = size.height / 2f,
+                            depthEffect = true,
+                            chromaticAberration = true
+                        )
+                    }
+                )
+                .width(thumbWidth)
+                .height(thumbHeight)
+        )
+    }
+}
+
+@Preview(uiMode = Configuration.UI_MODE_NIGHT_NO)
+@Composable
+fun StyledSwitchPreview() {
+    val isDarkTheme = isSystemInDarkTheme()
+    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFF2F2F7)
+    Box(
+        modifier = Modifier
+            .background(backgroundColor)
+            .width(100.dp)
+            .height(150.dp),
+        contentAlignment = Alignment.Center
+    ) {
+        val checked = remember { mutableStateOf(true) }
+        StyledSwitch(
+            checked = checked.value,
+            onCheckedChange = {
+                checked.value = it
+            },
+            enabled = true,
+        )
+//        LaunchedEffect(Unit) {
+//            delay(1000)
+//            checked.value = false
+//            delay(1000)
+//            checked.value = true
+//        }
+    }
+}

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

@@ -0,0 +1,273 @@
+/*
+    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

@@ -0,0 +1,190 @@
+/*
+    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/overlays/IslandWindow.kt

@@ -0,0 +1,748 @@
+/*
+    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.overlays
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ObjectAnimator
+import android.animation.PropertyValuesHolder
+import android.animation.ValueAnimator
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.res.Resources
+import android.graphics.PixelFormat
+import android.graphics.drawable.GradientDrawable
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log.e
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.VelocityTracker
+import android.view.View
+import android.view.WindowManager
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.AnticipateOvershootInterpolator
+import android.view.animation.DecelerateInterpolator
+import android.view.animation.OvershootInterpolator
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.LinearLayout
+import android.widget.ProgressBar
+import android.widget.TextView
+import android.widget.VideoView
+import androidx.core.net.toUri
+import androidx.dynamicanimation.animation.DynamicAnimation
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import me.kavishdevar.librepods.R
+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.services.ServiceManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.abs
+
+enum class IslandType {
+    CONNECTED,
+    TAKING_OVER,
+    MOVED_TO_REMOTE,
+    MOVED_TO_OTHER_DEVICE,
+}
+
+class IslandWindow(private val context: Context) {
+    private val windowManager: WindowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    @SuppressLint("InflateParams")
+    private val islandView: View = LayoutInflater.from(context).inflate(R.layout.island_window, null)
+    private var isClosing = false
+    private var params: WindowManager.LayoutParams? = null
+
+    private var initialY = 0f
+    private var initialTouchY = 0f
+    private var lastTouchY = 0f
+    private var velocityTracker: VelocityTracker? = null
+    private var isBeingDragged = false
+    private var autoCloseHandler: Handler? = null
+    private var autoCloseRunnable: Runnable? = null
+    private var initialHeight = 0
+    private var screenHeight = 0
+    private var isDraggingDown = false
+    private var lastMoveTime = 0L
+    private var yMovement = 0f
+    private var dragDistance = 0f
+
+    private var initialConnectedTextY = 0f
+    private var initialDeviceTextY = 0f
+    private var initialBatteryViewY = 0f
+    private var initialVideoViewY = 0f
+    private var initialTextSeparation = 0f
+
+    private val containerView = FrameLayout(context)
+
+    private lateinit var springAnimation: SpringAnimation
+    private val flingAnimator = ValueAnimator()
+
+    private val batteryReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context?, intent: Intent?) {
+            if (intent?.action == AirPodsNotifications.BATTERY_DATA) {
+                val batteryList = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                    intent.getParcelableArrayListExtra("data", Battery::class.java)
+                } else {
+                    @Suppress("DEPRECATION")
+                    intent.getParcelableArrayListExtra("data")
+                }
+                updateBatteryDisplay(batteryList)
+            } else if (intent?.action == AirPodsNotifications.DISCONNECT_RECEIVERS) {
+                try {
+                    context?.unregisterReceiver(this)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    val isVisible: Boolean
+        get() = containerView.parent != null && containerView.visibility == View.VISIBLE
+
+    @SuppressLint("SetTextI18n")
+    private fun updateBatteryDisplay(batteryList: ArrayList<Battery>?) {
+        if (batteryList == null || batteryList.isEmpty()) return
+
+        val leftBattery = batteryList.find { it.component == BatteryComponent.LEFT }
+        val rightBattery = batteryList.find { it.component == BatteryComponent.RIGHT }
+
+        val leftLevel = leftBattery?.level ?: 0
+        val rightLevel = rightBattery?.level ?: 0
+        leftBattery?.status ?: BatteryStatus.DISCONNECTED
+        rightBattery?.status ?: BatteryStatus.DISCONNECTED
+
+        val batteryText = islandView.findViewById<TextView>(R.id.island_battery_text)
+        val batteryProgressBar = islandView.findViewById<ProgressBar>(R.id.island_battery_progress)
+
+        val displayBatteryLevel = when {
+            leftLevel > 0 && rightLevel > 0 -> minOf(leftLevel, rightLevel)
+            leftLevel > 0 -> leftLevel
+            rightLevel > 0 -> rightLevel
+            else -> null
+        }
+
+        if (displayBatteryLevel != null) {
+            batteryText.text = "$displayBatteryLevel%"
+            batteryProgressBar.progress = displayBatteryLevel
+            batteryProgressBar.isIndeterminate = false
+        } else {
+            batteryText.text = "?"
+            batteryProgressBar.progress = 0
+            batteryProgressBar.isIndeterminate = false
+        }
+    }
+
+    @SuppressLint("SetTextI18s", "ClickableViewAccessibility", "UnspecifiedRegisterReceiverFlag",
+        "SetTextI18n"
+    )
+    fun show(name: String, batteryPercentage: Int, context: Context, type: IslandType = IslandType.CONNECTED, reversed: Boolean = false, otherDeviceName: String? = null) {
+        if (ServiceManager.getService()?.islandOpen == true) return
+        else ServiceManager.getService()?.islandOpen = true
+
+        val displayMetrics = Resources.getSystem().displayMetrics
+        val width = (displayMetrics.widthPixels * 0.95).toInt()
+        screenHeight = displayMetrics.heightPixels
+
+        val batteryList = ServiceManager.getService()?.getBattery()
+        val batteryText = islandView.findViewById<TextView>(R.id.island_battery_text)
+        val batteryProgressBar = islandView.findViewById<ProgressBar>(R.id.island_battery_progress)
+
+        val displayBatteryLevel = if (batteryList != null) {
+            val leftBattery = batteryList.find { it.component == BatteryComponent.LEFT }
+            val rightBattery = batteryList.find { it.component == BatteryComponent.RIGHT }
+
+            when {
+                (leftBattery?.level ?: 0) > 0 && (rightBattery?.level ?: 0) > 0 ->
+                    minOf(leftBattery!!.level, rightBattery!!.level)
+                (leftBattery?.level ?: 0) > 0 -> leftBattery!!.level
+                (rightBattery?.level ?: 0) > 0 -> rightBattery!!.level
+                batteryPercentage > 0 -> batteryPercentage
+                else -> null
+            }
+        } else if (batteryPercentage > 0) {
+            batteryPercentage
+        } else {
+            null
+        }
+
+        if (displayBatteryLevel != null) {
+            batteryText.text = "$displayBatteryLevel%"
+            batteryProgressBar.progress = displayBatteryLevel
+        } else {
+            batteryText.text = "?"
+            batteryProgressBar.progress = 0
+        }
+
+        batteryProgressBar.isIndeterminate = false
+        islandView.findViewById<TextView>(R.id.island_device_name).text = name
+
+        val actionButton = islandView.findViewById<ImageButton>(R.id.island_action_button)
+        val batteryBg = islandView.findViewById<ProgressBar>(R.id.island_battery_bg)
+        if (type == IslandType.MOVED_TO_OTHER_DEVICE && !reversed) {
+            actionButton.visibility = View.VISIBLE
+            actionButton.setOnClickListener {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    ServiceManager.getService()?.takeOver("reverse")
+                }
+                close()
+            }
+            batteryText.visibility = View.GONE
+            batteryProgressBar.visibility = View.GONE
+            batteryBg.visibility = View.GONE
+        } else {
+            actionButton.visibility = View.GONE
+            batteryText.visibility = View.VISIBLE
+            batteryProgressBar.visibility = View.VISIBLE
+            batteryBg.visibility = View.VISIBLE
+        }
+
+        val batteryIntentFilter = IntentFilter(AirPodsNotifications.BATTERY_DATA)
+        batteryIntentFilter.addAction(AirPodsNotifications.DISCONNECT_RECEIVERS)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(batteryReceiver, batteryIntentFilter, Context.RECEIVER_EXPORTED)
+        } else {
+            context.registerReceiver(batteryReceiver, batteryIntentFilter)
+        }
+
+        ServiceManager.getService()?.sendBatteryBroadcast()
+
+        containerView.removeAllViews()
+        val containerParams = FrameLayout.LayoutParams(
+            FrameLayout.LayoutParams.MATCH_PARENT,
+            FrameLayout.LayoutParams.WRAP_CONTENT
+        )
+
+        containerView.addView(islandView, containerParams)
+
+        params = WindowManager.LayoutParams(
+            width,
+            WindowManager.LayoutParams.WRAP_CONTENT,
+            WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY,
+            WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or WindowManager.LayoutParams.FLAG_NOT_TOUCH_MODAL,
+            PixelFormat.TRANSLUCENT
+        ).apply {
+            gravity = Gravity.TOP or Gravity.CENTER_HORIZONTAL
+        }
+
+        islandView.visibility = View.VISIBLE
+        containerView.visibility = View.VISIBLE
+
+        containerView.setOnTouchListener { _, event ->
+            when (event.action) {
+                MotionEvent.ACTION_DOWN -> {
+                    autoCloseHandler?.removeCallbacks(autoCloseRunnable ?: return@setOnTouchListener false)
+                    flingAnimator.cancel()
+
+                    velocityTracker?.recycle()
+                    velocityTracker = VelocityTracker.obtain()
+                    velocityTracker?.addMovement(event)
+
+                    initialY = containerView.translationY
+                    initialTouchY = event.rawY
+                    lastTouchY = event.rawY
+                    initialHeight = islandView.height
+                    isBeingDragged = false
+                    isDraggingDown = false
+                    lastMoveTime = System.currentTimeMillis()
+                    dragDistance = 0f
+
+                    captureInitialPositions()
+
+                    true
+                }
+                MotionEvent.ACTION_MOVE -> {
+                    velocityTracker?.addMovement(event)
+                    val deltaY = event.rawY - initialTouchY
+                    val moveDelta = event.rawY - lastTouchY
+                    dragDistance += abs(moveDelta)
+
+                    isDraggingDown = moveDelta > 0
+
+                    val currentTime = System.currentTimeMillis()
+                    val timeDelta = currentTime - lastMoveTime
+                    if (timeDelta > 0) {
+                        yMovement = moveDelta / timeDelta * 10
+                    }
+                    lastMoveTime = currentTime
+
+                    if (abs(deltaY) > 5 || isBeingDragged) {
+                        isBeingDragged = true
+
+                        // Cancel auto close timer when dragging starts
+                        autoCloseHandler?.removeCallbacks(autoCloseRunnable ?: return@setOnTouchListener false)
+
+                        val dampedDeltaY = if (deltaY > 0) {
+                            initialY + (deltaY * 0.6f)
+                        } else {
+                            initialY + (deltaY * 0.9f)
+                        }
+                        containerView.translationY = dampedDeltaY
+
+                        if (isDraggingDown && deltaY > 0) {
+                            val stretchAmount = (deltaY * 0.5f).coerceAtMost(200f)
+                            applyCustomStretchEffect(stretchAmount)
+                        }
+                    }
+
+                    lastTouchY = event.rawY
+                    true
+                }
+                MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+                    velocityTracker?.addMovement(event)
+                    velocityTracker?.computeCurrentVelocity(1000)
+                    val yVelocity = velocityTracker?.yVelocity ?: 0f
+
+                    if (isBeingDragged) {
+                        val currentTranslationY = containerView.translationY
+                        abs(yVelocity) > 800
+                        val significantDrag = abs(dragDistance) > 80
+
+                        when {
+                            yVelocity < -1200 || (currentTranslationY < -80 && !isDraggingDown) -> {
+                                animateDismissWithInertia(yVelocity)
+                            }
+                            yVelocity > 1200 || (isDraggingDown && significantDrag) -> {
+                                animateExpandWithStretch(yVelocity)
+                            }
+                            else -> {
+                                springBackWithInertia(yVelocity)
+                            }
+                        }
+                    } else if (dragDistance < 10) {
+                        resetAutoCloseTimer()
+                    }
+
+                    velocityTracker?.recycle()
+                    velocityTracker = null
+                    isBeingDragged = false
+                    true
+                }
+                else -> false
+            }
+        }
+
+        when (type) {
+            IslandType.CONNECTED -> {
+                islandView.findViewById<TextView>(R.id.island_connected_text).text = context.getString(R.string.island_connected_text)
+            }
+            IslandType.TAKING_OVER -> {
+                islandView.findViewById<TextView>(R.id.island_connected_text).text = context.getString(R.string.island_taking_over_text)
+            }
+            IslandType.MOVED_TO_REMOTE -> {
+                islandView.findViewById<TextView>(R.id.island_connected_text).text = context.getString(R.string.island_moved_to_remote_text)
+            }
+            IslandType.MOVED_TO_OTHER_DEVICE -> {
+                if (otherDeviceName == null || otherDeviceName.isEmpty()) {
+                    e("IslandWindow", "Other device name is null or empty for MOVED_TO_OTHER_DEVICE type")
+                }
+                if (reversed) {
+                    islandView.findViewById<TextView>(R.id.island_connected_text).text = context.getString(R.string.island_moved_to_other_device_reversed_text)
+                } else {
+                    islandView.findViewById<TextView>(R.id.island_connected_text).text = context.getString(R.string.island_moved_to_other_device_text, otherDeviceName)
+                }
+            }
+        }
+
+        val videoView = islandView.findViewById<VideoView>(R.id.island_video_view)
+        val videoUri = "android.resource://me.kavishdevar.librepods/${R.raw.island}".toUri()
+        videoView.setVideoURI(videoUri)
+        videoView.setOnPreparedListener { mediaPlayer ->
+            mediaPlayer.isLooping = true
+            videoView.start()
+        }
+
+        try {
+            windowManager.addView(containerView, params)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+
+        islandView.post {
+            initialHeight = islandView.height
+            captureInitialPositions()
+        }
+
+        springAnimation = SpringAnimation(containerView, DynamicAnimation.TRANSLATION_Y, 0f).apply {
+            spring = SpringForce(0f)
+                .setDampingRatio(SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY)
+                .setStiffness(SpringForce.STIFFNESS_MEDIUM)
+        }
+
+        val scaleX = PropertyValuesHolder.ofFloat(View.SCALE_X, 0.5f, 1f)
+        val scaleY = PropertyValuesHolder.ofFloat(View.SCALE_Y, 0.5f, 1f)
+        val translationY = PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, -200f, 0f)
+        ObjectAnimator.ofPropertyValuesHolder(containerView, scaleX, scaleY, translationY).apply {
+            duration = 700
+            interpolator = AnticipateOvershootInterpolator()
+            start()
+        }
+
+        resetAutoCloseTimer()
+    }
+
+    private fun captureInitialPositions() {
+        val connectedText = islandView.findViewById<TextView>(R.id.island_connected_text)
+        val deviceText = islandView.findViewById<TextView>(R.id.island_device_name)
+        val batteryView = islandView.findViewById<FrameLayout>(R.id.island_battery_container)
+        val videoView = islandView.findViewById<VideoView>(R.id.island_video_view)
+
+        connectedText.post {
+            initialConnectedTextY = connectedText.y
+            initialDeviceTextY = deviceText.y
+            initialTextSeparation = deviceText.y - (connectedText.y + connectedText.height)
+
+            if (batteryView != null) initialBatteryViewY = batteryView.y
+            initialVideoViewY = videoView.y
+        }
+    }
+
+    private fun applyCustomStretchEffect(stretchAmount: Float) {
+        try {
+            val mainLayout = islandView.findViewById<LinearLayout>(R.id.island_window_layout)
+            islandView.findViewById<TextView>(R.id.island_connected_text)
+            val deviceText = islandView.findViewById<TextView>(R.id.island_device_name)
+            islandView.findViewById<FrameLayout>(R.id.island_battery_container)
+            islandView.findViewById<VideoView>(R.id.island_video_view)
+
+            val stretchFactor = 1f + (stretchAmount / 300f).coerceAtMost(4.0f)
+            val newMinHeight = (initialHeight * stretchFactor).toInt()
+            mainLayout.minimumHeight = newMinHeight
+
+            val textMarginIncrease = (stretchAmount * 0.8f).toInt()
+
+            val deviceTextParams = deviceText.layoutParams as LinearLayout.LayoutParams
+            deviceTextParams.topMargin = textMarginIncrease
+            deviceText.layoutParams = deviceTextParams
+
+            val background = mainLayout.background
+            if (background is GradientDrawable) {
+                val cornerRadius = 56f
+                background.cornerRadius = cornerRadius
+            }
+
+            if (params != null) {
+                params!!.height = screenHeight
+
+                val containerParams = containerView.layoutParams
+                containerParams.height = screenHeight
+                containerView.layoutParams = containerParams
+
+                try {
+                    windowManager.updateViewLayout(containerView, params)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun resetAutoCloseTimer() {
+        autoCloseHandler?.removeCallbacks(autoCloseRunnable ?: return)
+        autoCloseHandler = Handler(Looper.getMainLooper())
+        autoCloseRunnable = Runnable { close() }
+        autoCloseHandler?.postDelayed(autoCloseRunnable!!, 4500)
+    }
+
+    private fun springBackWithInertia(velocity: Float) {
+        springAnimation.cancel()
+        flingAnimator.cancel()
+
+        springAnimation.setStartVelocity(velocity)
+
+        val baseStiffness = SpringForce.STIFFNESS_MEDIUM
+        val dynamicStiffness = baseStiffness * (1f + (abs(velocity) / 3000f))
+        springAnimation.spring = SpringForce(0f)
+            .setDampingRatio(SpringForce.DAMPING_RATIO_MEDIUM_BOUNCY)
+            .setStiffness(dynamicStiffness)
+
+        resetStretchEffects()
+
+        if (params != null) {
+            params!!.height = WindowManager.LayoutParams.WRAP_CONTENT
+            try {
+                windowManager.updateViewLayout(containerView, params)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+        springAnimation.start()
+    }
+
+    private fun resetStretchEffects() {
+        try {
+            val mainLayout = islandView.findViewById<LinearLayout>(R.id.island_window_layout)
+            val deviceText = islandView.findViewById<TextView>(R.id.island_device_name)
+
+            val heightAnimator = ValueAnimator.ofInt(mainLayout.minimumHeight, initialHeight)
+            heightAnimator.duration = 300
+            heightAnimator.interpolator = OvershootInterpolator(1.5f)
+            heightAnimator.addUpdateListener { animation ->
+                mainLayout.minimumHeight = animation.animatedValue as Int
+            }
+
+            val deviceTextParams = deviceText.layoutParams as LinearLayout.LayoutParams
+            val textMarginAnimator = ValueAnimator.ofInt(deviceTextParams.topMargin, 0)
+            textMarginAnimator.duration = 300
+            textMarginAnimator.interpolator = OvershootInterpolator(1.5f)
+            textMarginAnimator.addUpdateListener { animation ->
+                deviceTextParams.topMargin = animation.animatedValue as Int
+                deviceText.layoutParams = deviceTextParams
+            }
+
+            heightAnimator.start()
+            textMarginAnimator.start()
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    private fun animateDismissWithInertia(velocity: Float) {
+        springAnimation.cancel()
+        flingAnimator.cancel()
+
+        val baseDistance = -screenHeight
+        val velocityFactor = (abs(velocity) / 2000f).coerceIn(0.5f, 2.0f)
+        val targetDistance = baseDistance * velocityFactor
+
+        val baseDuration = 400L
+        val velocityDurationFactor = (1500f / (abs(velocity) + 1500f))
+        val duration = (baseDuration * velocityDurationFactor).toLong().coerceIn(200L, 500L)
+
+        flingAnimator.setFloatValues(containerView.translationY, targetDistance)
+        flingAnimator.duration = duration
+        flingAnimator.addUpdateListener { animation ->
+            containerView.translationY = animation.animatedValue as Float
+
+            val progress = animation.animatedFraction
+            containerView.scaleX = 1f - (progress * 0.5f)
+            containerView.scaleY = 1f - (progress * 0.5f)
+
+            containerView.alpha = 1f - progress
+        }
+        flingAnimator.addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+                forceClose()
+            }
+        })
+
+        flingAnimator.interpolator = DecelerateInterpolator(1.2f)
+        flingAnimator.start()
+    }
+
+    private fun animateExpandWithStretch(velocity: Float) {
+        springAnimation.cancel()
+        flingAnimator.cancel()
+
+        val baseDuration = 600L
+        val velocityFactor = (1800f / (abs(velocity) + 1800f)).coerceIn(0.5f, 1.5f)
+        val expandDuration = (baseDuration * velocityFactor).toLong().coerceIn(300L, 700L)
+
+        if (params != null) {
+            params!!.height = screenHeight
+            try {
+                windowManager.updateViewLayout(containerView, params)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+        val containerAnimator = ValueAnimator.ofFloat(containerView.translationY, screenHeight * 0.6f)
+        containerAnimator.duration = expandDuration
+        containerAnimator.interpolator = DecelerateInterpolator(0.8f)
+        containerAnimator.addUpdateListener { animation ->
+            containerView.translationY = animation.animatedValue as Float
+        }
+
+        val stretchAnimator = ValueAnimator.ofFloat(0f, 1f)
+        stretchAnimator.duration = expandDuration
+        stretchAnimator.interpolator = OvershootInterpolator(0.5f)
+        stretchAnimator.addUpdateListener { animation ->
+            val progress = animation.animatedValue as Float
+            animateCustomStretch(progress)
+        }
+
+        val normalizeAnimator = ValueAnimator.ofFloat(1.0f, 0.0f)
+        normalizeAnimator.duration = 300
+        normalizeAnimator.startDelay = expandDuration - 150
+        normalizeAnimator.interpolator = AccelerateInterpolator(1.2f)
+        normalizeAnimator.addUpdateListener { animation ->
+            val progress = animation.animatedValue as Float
+            containerView.alpha = progress
+
+            if (progress < 0.7f) {
+                islandView.findViewById<VideoView>(R.id.island_video_view).visibility = View.GONE
+            }
+        }
+        normalizeAnimator.addListener(object : AnimatorListenerAdapter() {
+            override fun onAnimationEnd(animation: Animator) {
+                ServiceManager.getService()?.startMainActivity()
+                forceClose()
+            }
+        })
+
+        containerAnimator.start()
+        stretchAnimator.start()
+        normalizeAnimator.start()
+    }
+
+    private fun animateCustomStretch(progress: Float) {
+        try {
+            val mainLayout = islandView.findViewById<LinearLayout>(R.id.island_window_layout)
+            val connectedText = islandView.findViewById<TextView>(R.id.island_connected_text)
+            val deviceText = islandView.findViewById<TextView>(R.id.island_device_name)
+
+            val targetHeight = (screenHeight * 0.7f).toInt()
+            val currentHeight = initialHeight + ((targetHeight - initialHeight) * progress)
+            mainLayout.minimumHeight = currentHeight.toInt()
+
+            val mainLayoutParams = mainLayout.layoutParams
+            mainLayoutParams.height = LinearLayout.LayoutParams.MATCH_PARENT
+            mainLayout.layoutParams = mainLayoutParams
+
+            val targetMargin = (400 * progress).toInt()
+            val deviceTextParams = deviceText.layoutParams as LinearLayout.LayoutParams
+            deviceTextParams.topMargin = targetMargin
+            deviceText.layoutParams = deviceTextParams
+
+            val baseTextSize = 24f
+            deviceText.textSize = baseTextSize + (progress * 8f)
+
+            val baseSubTextSize = 16f
+            connectedText.textSize = baseSubTextSize + (progress * 4f)
+        } catch (e: Exception) {
+            e.printStackTrace()
+        }
+    }
+
+    fun close() {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            Handler(Looper.getMainLooper()).post { close() }
+            return
+        }
+        try {
+            if (isClosing) return
+            isClosing = true
+
+            try {
+                context.unregisterReceiver(batteryReceiver)
+            } catch (e: Exception) {
+//                e.printStackTrace()
+            }
+
+            ServiceManager.getService()?.islandOpen = false
+            autoCloseHandler?.removeCallbacks(autoCloseRunnable ?: return)
+
+            resetStretchEffects()
+
+            val videoView = islandView.findViewById<VideoView>(R.id.island_video_view)
+            try {
+                videoView.stopPlayback()
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+
+            val scaleX = PropertyValuesHolder.ofFloat(View.SCALE_X, containerView.scaleX, 0.5f)
+            val scaleY = PropertyValuesHolder.ofFloat(View.SCALE_Y, containerView.scaleY, 0.5f)
+            val translationY = PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, containerView.translationY, -200f)
+            ObjectAnimator.ofPropertyValuesHolder(containerView, scaleX, scaleY, translationY).apply {
+                duration = 700
+                interpolator = AnticipateOvershootInterpolator()
+                addListener(object : AnimatorListenerAdapter() {
+                    override fun onAnimationEnd(animation: Animator) {
+                        cleanupAndRemoveView()
+                    }
+                })
+                start()
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            // Even if animation fails, ensure we cleanup
+            cleanupAndRemoveView()
+        }
+    }
+
+    private fun cleanupAndRemoveView() {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            Handler(Looper.getMainLooper()).post { cleanupAndRemoveView() }
+            return
+        }
+        try {
+            containerView.visibility = View.GONE
+        } catch (e: Exception) {
+            e("IslandWindow", "Error setting visibility: $e")
+        }
+        try {
+            if (containerView.parent != null) {
+                windowManager.removeView(containerView)
+            }
+        } catch (e: Exception) {
+            e("IslandWindow", "Error removing view: $e")
+        }
+        isClosing = false
+        // Make sure all animations are canceled
+        springAnimation.cancel()
+        flingAnimator.cancel()
+    }
+
+    fun forceClose() {
+        if (Looper.myLooper() != Looper.getMainLooper()) {
+            Handler(Looper.getMainLooper()).post { forceClose() }
+            return
+        }
+        try {
+            if (isClosing) return
+            isClosing = true
+
+            try {
+                context.unregisterReceiver(batteryReceiver)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+
+            ServiceManager.getService()?.islandOpen = false
+            autoCloseHandler?.removeCallbacks(autoCloseRunnable ?: return)
+
+            // Cancel all ongoing animations
+            springAnimation.cancel()
+            flingAnimator.cancel()
+
+            // Immediately remove the view without animations
+            cleanupAndRemoveView()
+        } catch (e: Exception) {
+            e.printStackTrace()
+            isClosing = false
+        }
+    }
+}

android/app/src/main/java/me/kavishdevar/librepods/presentation/overlays/PopupWindow.kt

@@ -0,0 +1,288 @@
+/*
+    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.overlays
+
+import android.animation.Animator
+import android.animation.AnimatorListenerAdapter
+import android.animation.ObjectAnimator
+import android.animation.PropertyValuesHolder
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.PixelFormat
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.Gravity
+import android.view.LayoutInflater
+import android.view.MotionEvent
+import android.view.View
+import android.view.WindowManager
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
+import android.widget.ImageButton
+import android.widget.LinearLayout
+import android.widget.TextView
+import android.widget.VideoView
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.data.AirPodsNotifications
+import me.kavishdevar.librepods.data.Battery
+import me.kavishdevar.librepods.data.BatteryComponent
+import me.kavishdevar.librepods.data.BatteryStatus
+
+@SuppressLint("InflateParams", "ClickableViewAccessibility")
+class PopupWindow(
+    private val context: Context,
+    private val onCloseCallback: () -> Unit = {}
+) {
+    private val mView: View
+    private var isClosing = false
+    private var autoCloseHandler = Handler(Looper.getMainLooper())
+    private var autoCloseRunnable: Runnable? = null
+    private var batteryUpdateReceiver: BroadcastReceiver? = null
+
+    @Suppress("DEPRECATION")
+    private val mParams: WindowManager.LayoutParams = WindowManager.LayoutParams().apply {
+        height = WindowManager.LayoutParams.WRAP_CONTENT
+        val displayMetrics = context.resources.displayMetrics
+        val screenWidthDp = displayMetrics.widthPixels / displayMetrics.density
+        width = if (screenWidthDp >= 600) {
+            (400 * displayMetrics.density).toInt()
+        } else {
+            WindowManager.LayoutParams.MATCH_PARENT
+        }
+        type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+        format = PixelFormat.TRANSLUCENT
+        gravity = Gravity.BOTTOM or Gravity.CENTER_HORIZONTAL
+        dimAmount = 0.3f
+        flags = WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS or
+            WindowManager.LayoutParams.FLAG_FULLSCREEN or
+            WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or
+            WindowManager.LayoutParams.FLAG_DIM_BEHIND or
+            WindowManager.LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH
+    }
+
+    private val mWindowManager: WindowManager
+
+    init {
+        val layoutInflater = context.getSystemService(Context.LAYOUT_INFLATER_SERVICE) as LayoutInflater
+        mView = layoutInflater.inflate(R.layout.popup_window, null)
+        mParams.x = 0
+        mParams.y = 0
+
+        mView.setOnClickListener {
+            close()
+        }
+
+        mView.findViewById<ImageButton>(R.id.close_button).setOnClickListener {
+            close()
+        }
+
+        val ll = mView.findViewById<LinearLayout>(R.id.linear_layout)
+        ll.setOnClickListener {
+            close()
+        }
+
+        @Suppress("DEPRECATION")
+        mView.systemUiVisibility = View.SYSTEM_UI_FLAG_LAYOUT_STABLE or
+            View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION or
+            View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN or
+            View.SYSTEM_UI_FLAG_HIDE_NAVIGATION or
+            View.SYSTEM_UI_FLAG_FULLSCREEN or
+            View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY
+
+        mView.setOnTouchListener { _, event ->
+            if (event.action == MotionEvent.ACTION_DOWN) {
+                val touchY = event.rawY
+                val popupTop = mView.top
+                if (touchY < popupTop) {
+                    close()
+                    true
+                } else {
+                    false
+                }
+            } else {
+                false
+            }
+        }
+        mWindowManager = context.getSystemService(Context.WINDOW_SERVICE) as WindowManager
+    }
+
+    @SuppressLint("InlinedApi", "SetTextI18s")
+    fun open(name: String = "AirPods Pro", batteryNotification: AirPodsNotifications.BatteryNotification) {
+        try {
+            if (mView.windowToken == null && mView.parent == null && !isClosing) {
+                mView.findViewById<TextView>(R.id.name).text = name
+
+                updateBatteryStatus(batteryNotification)
+
+                val vid = mView.findViewById<VideoView>(R.id.video)
+                vid.setVideoPath("android.resource://me.kavishdevar.librepods/" + R.raw.connected)
+                vid.resolveAdjustedSize(vid.width, vid.height)
+                vid.start()
+                vid.setOnCompletionListener {
+                    vid.start()
+                }
+
+                try {
+                    mWindowManager.addView(mView, mParams)
+                } catch (e: Exception) {
+                    e.printStackTrace()
+                }
+
+                val displayMetrics = mView.context.resources.displayMetrics
+                val screenHeight = displayMetrics.heightPixels
+
+                mView.translationY = screenHeight.toFloat()
+                mView.alpha = 1f
+
+                val translationY = PropertyValuesHolder.ofFloat(View.TRANSLATION_Y, screenHeight.toFloat(), 0f)
+
+                ObjectAnimator.ofPropertyValuesHolder(mView, translationY).apply {
+                    duration = 500
+                    interpolator = DecelerateInterpolator()
+                    start()
+                }
+
+                registerBatteryUpdateReceiver()
+
+                autoCloseRunnable = Runnable { close() }
+                autoCloseHandler.postDelayed(autoCloseRunnable!!, 12000)
+            }
+        } catch (e: Exception) {
+            Log.e("PopupWindow", "Error opening popup: ${e.message}")
+            onCloseCallback()
+        }
+    }
+
+    @SuppressLint("UnspecifiedRegisterReceiverFlag")
+    private fun registerBatteryUpdateReceiver() {
+        batteryUpdateReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent?.action == AirPodsNotifications.BATTERY_DATA) {
+                    val batteryList = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                        intent.getParcelableArrayListExtra("data", Battery::class.java)
+                    } else {
+                        @Suppress("DEPRECATION")
+                        intent.getParcelableArrayListExtra("data")
+                    }
+                    if (batteryList != null) {
+                        updateBatteryStatusFromList(batteryList)
+                    }
+                }
+            }
+        }
+
+        val filter = IntentFilter(AirPodsNotifications.BATTERY_DATA)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(batteryUpdateReceiver, filter, Context.RECEIVER_EXPORTED)
+        } else {
+            context.registerReceiver(batteryUpdateReceiver, filter)
+        }
+    }
+
+    private fun unregisterBatteryUpdateReceiver() {
+        batteryUpdateReceiver?.let {
+            try {
+                context.unregisterReceiver(it)
+                batteryUpdateReceiver = null
+            } catch (e: Exception) {
+                Log.e("PopupWindow", "Error unregistering battery receiver: ${e.message}")
+            }
+        }
+    }
+
+    private fun updateBatteryStatusFromList(batteryList: List<Battery>) {
+        val batteryLeftText = mView.findViewById<TextView>(R.id.left_battery)
+        val batteryRightText = mView.findViewById<TextView>(R.id.right_battery)
+        val batteryCaseText = mView.findViewById<TextView>(R.id.case_battery)
+
+        batteryLeftText.text = batteryList.find { it.component == BatteryComponent.LEFT }?.let {
+            if (it.status != BatteryStatus.DISCONNECTED) {
+                "\uDBC3\uDC8E    ${it.level}%"
+            } else {
+                ""
+            }
+        } ?: ""
+
+        batteryRightText.text = batteryList.find { it.component == BatteryComponent.RIGHT }?.let {
+            if (it.status != BatteryStatus.DISCONNECTED) {
+                "\uDBC3\uDC8D    ${it.level}%"
+            } else {
+                ""
+            }
+        } ?: ""
+
+        batteryCaseText.text = batteryList.find { it.component == BatteryComponent.CASE }?.let {
+            if (it.status != BatteryStatus.DISCONNECTED) {
+                "\uDBC3\uDE6C    ${it.level}%"
+            } else {
+                ""
+            }
+        } ?: ""
+    }
+
+    @SuppressLint("SetTextI18s")
+    fun updateBatteryStatus(batteryNotification: AirPodsNotifications.BatteryNotification) {
+        val batteryStatus = batteryNotification.getBattery()
+        updateBatteryStatusFromList(batteryStatus)
+    }
+
+    fun close() {
+        try {
+            if (isClosing) return
+            isClosing = true
+
+            autoCloseRunnable?.let { autoCloseHandler.removeCallbacks(it) }
+            unregisterBatteryUpdateReceiver()
+
+            val vid = mView.findViewById<VideoView>(R.id.video)
+            vid.stopPlayback()
+
+            ObjectAnimator.ofFloat(mView, "translationY", mView.height.toFloat()).apply {
+                duration = 500
+                interpolator = AccelerateInterpolator()
+                addListener(object : AnimatorListenerAdapter() {
+                    override fun onAnimationEnd(animation: Animator) {
+                        try {
+                            mView.visibility = View.GONE
+                            if (mView.parent != null) {
+                                mWindowManager.removeView(mView)
+                            }
+                        } catch (e: Exception) {
+                            Log.e("PopupWindow", "Error removing view: ${e.message}")
+                        } finally {
+                            isClosing = false
+                            onCloseCallback()
+                        }
+                    }
+                })
+                start()
+            }
+        } catch (e: Exception) {
+            Log.e("PopupWindow", "Error closing popup: ${e.message}")
+            isClosing = false
+            onCloseCallback()
+        }
+    }
+}

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

@@ -0,0 +1,844 @@
+/*
+    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

@@ -0,0 +1,130 @@
+/*
+    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.presentation.components.StyledButton
+import me.kavishdevar.librepods.presentation.components.StyledScaffold
+import me.kavishdevar.librepods.presentation.components.StyledSlider
+import me.kavishdevar.librepods.bluetooth.AACPManager
+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(
+                    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

@@ -0,0 +1,537 @@
+/*
+    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.SharedPreferences
+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.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.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.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.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 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()
+    }
+
+    isSystemInDarkTheme()
+    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 = "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 = bytes[1] == 0x02.toByte()
+                    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_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_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))
+                }
+                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

@@ -0,0 +1,686 @@
+/*
+    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.os.Build
+import android.widget.Toast
+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.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
+
+@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.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.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 intent = Intent(
+                            Intent.ACTION_VIEW,
+                            "https://github.com/kavishdevar/librepods/issues".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
+                       )
+                   )
+                   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

@@ -0,0 +1,111 @@
+/*
+    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

@@ -0,0 +1,523 @@
+/*
+    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

@@ -0,0 +1,756 @@
+/*
+    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.services.ServiceManager
+import me.kavishdevar.librepods.utils.HeadTracking
+import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
+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) }
+        Column(
+            modifier = Modifier
+                .fillMaxWidth(),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            Column (
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .hazeSource(state = hazeState)
+                    .layerBackdrop(backdrop)
+                    .padding(top = 8.dp)
+                    .padding(horizontal = 16.dp)
+                    .verticalScroll(scrollState)
+            ) {
+                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,
+                    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/HearingAidAdjustmentsScreen.kt

@@ -0,0 +1,292 @@
+/*
+    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 android.util.Log
+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.foundation.rememberScrollState
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.collectAsState
+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.ui.Modifier
+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 dev.chrisbanes.haze.HazeState
+import dev.chrisbanes.haze.hazeSource
+import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import me.kavishdevar.librepods.R
+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.services.ServiceManager
+import me.kavishdevar.librepods.bluetooth.AACPManager
+import me.kavishdevar.librepods.bluetooth.ATTHandles
+import me.kavishdevar.librepods.data.HearingAidSettings
+import me.kavishdevar.librepods.data.parseHearingAidSettingsResponse
+import me.kavishdevar.librepods.data.sendHearingAidSettings
+import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
+import java.io.IOException
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+private var debounceJob: MutableState<Job?> = mutableStateOf(null)
+private const val TAG = "HearingAidAdjustments"
+
+@SuppressLint("DefaultLocale")
+@ExperimentalHazeMaterialsApi
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalEncodingApi::class)
+@Composable
+fun HearingAidAdjustmentsScreen(viewModel: AirPodsViewModel) {
+    isSystemInDarkTheme()
+    val verticalScrollState = rememberScrollState()
+    val hazeState = remember { HazeState() }
+    val attManager = ServiceManager.getService()?.attManager ?: throw IllegalStateException("ATTManager not available")
+
+    val state by viewModel.uiState.collectAsState()
+
+    val backdrop = rememberLayerBackdrop()
+    StyledScaffold(
+        title = stringResource(R.string.adjustments)
+    ) { spacerHeight ->
+        Column(
+            modifier = Modifier
+                .hazeSource(hazeState)
+                .fillMaxSize()
+                .layerBackdrop(backdrop)
+                .verticalScroll(verticalScrollState)
+                .padding(horizontal = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            Spacer(modifier = Modifier.height(spacerHeight))
+
+            val amplificationSliderValue = remember { mutableFloatStateOf(0.5f) }
+            val balanceSliderValue = remember { mutableFloatStateOf(0.5f) }
+            val toneSliderValue = remember { mutableFloatStateOf(0.5f) }
+            val ambientNoiseReductionSliderValue = remember { mutableFloatStateOf(0.0f) }
+            val conversationBoostEnabled = remember { mutableStateOf(false) }
+            val leftEQ = remember { mutableStateOf(FloatArray(8)) }
+            val rightEQ = remember { mutableStateOf(FloatArray(8)) }
+            val ownVoiceAmplification = remember { mutableFloatStateOf(0.5f) }
+
+            val initialLoadComplete = remember { mutableStateOf(false) }
+
+            val initialReadSucceeded = remember { mutableStateOf(false) }
+            val initialReadAttempts = remember { mutableIntStateOf(0) }
+
+            val hearingAidSettings = remember {
+                mutableStateOf(
+                    HearingAidSettings(
+                        leftEQ = leftEQ.value,
+                        rightEQ = rightEQ.value,
+                        leftAmplification = amplificationSliderValue.floatValue + (0.5f - balanceSliderValue.floatValue) * amplificationSliderValue.floatValue * 2,
+                        rightAmplification = amplificationSliderValue.floatValue + (balanceSliderValue.floatValue - 0.5f) * amplificationSliderValue.floatValue * 2,
+                        leftTone = toneSliderValue.floatValue,
+                        rightTone = toneSliderValue.floatValue,
+                        leftConversationBoost = conversationBoostEnabled.value,
+                        rightConversationBoost = conversationBoostEnabled.value,
+                        leftAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                        rightAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                        netAmplification = amplificationSliderValue.floatValue,
+                        balance = balanceSliderValue.floatValue,
+                        ownVoiceAmplification = ownVoiceAmplification.floatValue
+                    )
+                )
+            }
+
+            val hearingAidATTListener = remember {
+                object : (ByteArray) -> Unit {
+                    override fun invoke(value: ByteArray) {
+                        val parsed = parseHearingAidSettingsResponse(value)
+                        if (parsed != null) {
+                            amplificationSliderValue.floatValue = parsed.netAmplification
+                            balanceSliderValue.floatValue = parsed.balance
+                            toneSliderValue.floatValue = parsed.leftTone
+                            ambientNoiseReductionSliderValue.floatValue = parsed.leftAmbientNoiseReduction
+                            conversationBoostEnabled.value = parsed.leftConversationBoost
+                            leftEQ.value = parsed.leftEQ.copyOf()
+                            rightEQ.value = parsed.rightEQ.copyOf()
+                            ownVoiceAmplification.floatValue = parsed.ownVoiceAmplification
+                            Log.d(TAG, "Updated hearing aid settings from notification")
+                        } else {
+                            Log.w(TAG, "Failed to parse hearing aid settings from notification")
+                        }
+                    }
+                }
+            }
+
+            LaunchedEffect(amplificationSliderValue.floatValue, balanceSliderValue.floatValue, toneSliderValue.floatValue, conversationBoostEnabled.value, ambientNoiseReductionSliderValue.floatValue, ownVoiceAmplification.floatValue, initialLoadComplete.value, initialReadSucceeded.value) {
+                if (!initialLoadComplete.value) {
+                    Log.d(TAG, "Initial device load not complete - skipping send")
+                    return@LaunchedEffect
+                }
+
+                if (!initialReadSucceeded.value) {
+                    Log.d(TAG, "Initial device read not successful yet - skipping send until read succeeds")
+                    return@LaunchedEffect
+                }
+
+                hearingAidSettings.value = HearingAidSettings(
+                    leftEQ = leftEQ.value,
+                    rightEQ = rightEQ.value,
+                    leftAmplification = amplificationSliderValue.floatValue + if (balanceSliderValue.floatValue < 0) -balanceSliderValue.floatValue else 0f,
+                    rightAmplification = amplificationSliderValue.floatValue + if (balanceSliderValue.floatValue > 0) balanceSliderValue.floatValue else 0f,
+                    leftTone = toneSliderValue.floatValue,
+                    rightTone = toneSliderValue.floatValue,
+                    leftConversationBoost = conversationBoostEnabled.value,
+                    rightConversationBoost = conversationBoostEnabled.value,
+                    leftAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                    rightAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                    netAmplification = amplificationSliderValue.floatValue,
+                    balance = balanceSliderValue.floatValue,
+                    ownVoiceAmplification = ownVoiceAmplification.floatValue
+                )
+                Log.d(TAG, "Updated settings: ${hearingAidSettings.value}")
+                sendHearingAidSettings(attManager, hearingAidSettings.value, debounceJob)
+            }
+
+            LaunchedEffect(Unit) {
+                Log.d(TAG, "Connecting to ATT...")
+                try {
+                    attManager.enableNotifications(ATTHandles.HEARING_AID)
+                    attManager.registerListener(ATTHandles.HEARING_AID, hearingAidATTListener)
+
+                    var parsedSettings: HearingAidSettings? = null
+                    for (attempt in 1..3) {
+                        initialReadAttempts.intValue = attempt
+                        try {
+                            val data = attManager.read(ATTHandles.HEARING_AID)
+                            parsedSettings = parseHearingAidSettingsResponse(data = data)
+                            if (parsedSettings != null) {
+                                Log.d(TAG, "Parsed settings on attempt $attempt")
+                                break
+                            } else {
+                                Log.d(TAG, "Parsing returned null on attempt $attempt")
+                            }
+                        } catch (e: Exception) {
+                            Log.w(TAG, "Read attempt $attempt failed: ${e.message}")
+                        }
+                        delay(200)
+                    }
+
+                    if (parsedSettings != null) {
+                        Log.d(TAG, "Initial hearing aid settings: $parsedSettings")
+                        amplificationSliderValue.floatValue = parsedSettings.netAmplification
+                        balanceSliderValue.floatValue = parsedSettings.balance
+                        toneSliderValue.floatValue = parsedSettings.leftTone
+                        ambientNoiseReductionSliderValue.floatValue = parsedSettings.leftAmbientNoiseReduction
+                        conversationBoostEnabled.value = parsedSettings.leftConversationBoost
+                        leftEQ.value = parsedSettings.leftEQ.copyOf()
+                        rightEQ.value = parsedSettings.rightEQ.copyOf()
+                        ownVoiceAmplification.floatValue = parsedSettings.ownVoiceAmplification
+                        initialReadSucceeded.value = true
+                    } else {
+                        Log.d(TAG, "Failed to read/parse initial hearing aid settings after ${initialReadAttempts.intValue} attempts")
+                    }
+                } catch (e: IOException) {
+                    e.printStackTrace()
+                } finally {
+                    initialLoadComplete.value = true
+                }
+            }
+
+            StyledSlider(
+                label = stringResource(R.string.amplification),
+                valueRange = -1f..1f,
+                value = amplificationSliderValue.floatValue,
+                onValueChange = {
+                    amplificationSliderValue.floatValue = it
+                },
+                startIcon = "􀊥",
+                endIcon = "􀊩",
+                independent = true,
+            )
+
+
+            StyledToggle(
+                label = stringResource(R.string.swipe_to_control_amplification),
+                checked = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.HPS_GAIN_SWIPE]?.getOrNull(0) == 0x01.toByte(),
+                onCheckedChange = { viewModel.setControlCommandBoolean(AACPManager.Companion.ControlCommandIdentifiers.HPS_GAIN_SWIPE, it) },
+                description = stringResource(R.string.swipe_amplification_description)
+            )
+
+            StyledSlider(
+                label = stringResource(R.string.balance),
+                valueRange = -1f..1f,
+                value = balanceSliderValue.floatValue,
+                onValueChange = {
+                    balanceSliderValue.floatValue = it
+                },
+                snapPoints = listOf(-1f, 0f, 1f),
+                startLabel = stringResource(R.string.left),
+                endLabel = stringResource(R.string.right),
+                independent = true,
+            )
+
+            StyledSlider(
+                label = stringResource(R.string.tone),
+                valueRange = -1f..1f,
+                value = toneSliderValue.floatValue,
+                onValueChange = {
+                    toneSliderValue.floatValue = it
+                },
+                startLabel = stringResource(R.string.darker),
+                endLabel = stringResource(R.string.brighter),
+                independent = true,
+            )
+
+            StyledSlider(
+                label = stringResource(R.string.ambient_noise_reduction),
+                valueRange = 0f..1f,
+                value = ambientNoiseReductionSliderValue.floatValue,
+                onValueChange = {
+                    ambientNoiseReductionSliderValue.floatValue = it
+                },
+                startLabel = stringResource(R.string.less),
+                endLabel = stringResource(R.string.more),
+                independent = true,
+            )
+
+            StyledToggle(
+                label = stringResource(R.string.conversation_boost),
+                checked = conversationBoostEnabled.value,
+                onCheckedChange = { conversationBoostEnabled.value = it },
+                independent = true,
+                description = stringResource(R.string.conversation_boost_description)
+            )
+        }
+    }
+}

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

@@ -0,0 +1,276 @@
+/*
+    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 android.util.Log
+import androidx.compose.foundation.background
+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.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.SnackbarHostState
+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.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.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.launch
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.bluetooth.AACPManager
+import me.kavishdevar.librepods.data.parseTransparencySettingsResponse
+import me.kavishdevar.librepods.data.sendTransparencySettings
+import me.kavishdevar.librepods.presentation.components.ConfirmationDialog
+import me.kavishdevar.librepods.presentation.components.NavigationButton
+import me.kavishdevar.librepods.presentation.components.StyledScaffold
+import me.kavishdevar.librepods.presentation.components.StyledToggle
+import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+private const val TAG = "AccessibilitySettings"
+
+@SuppressLint("DefaultLocale")
+@ExperimentalHazeMaterialsApi
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalEncodingApi::class)
+@Composable
+fun HearingAidScreen(viewModel: AirPodsViewModel, navController: NavController) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+    val verticalScrollState  = rememberScrollState()
+    val snackbarHostState = remember { SnackbarHostState() }
+
+    val showDialog = remember { mutableStateOf(false) }
+    val backdrop = rememberLayerBackdrop()
+    val initialLoad = remember { mutableStateOf(true) }
+
+    val state by viewModel.uiState.collectAsState()
+
+    val hearingAidEnabled = remember {
+        val aidStatus = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID]
+        val assistStatus = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.HEARING_ASSIST_CONFIG]
+        mutableStateOf((aidStatus?.getOrNull(1) == 0x01.toByte()) && (assistStatus?.getOrNull(0) == 0x01.toByte()))
+    }
+
+    val hazeStateS = remember { mutableStateOf(HazeState()) } // dont question this. i could possibly use something other than initializing it with an empty state and then replacing it with the the one provided by the scaffold
+
+    StyledScaffold(
+        title = stringResource(R.string.hearing_aid),
+        snackbarHostState = snackbarHostState,
+    ) { topPadding, hazeState, bottomPadding ->
+        Column(
+            modifier = Modifier
+                .layerBackdrop(backdrop)
+                .hazeSource(hazeState)
+                .fillMaxSize()
+                .verticalScroll(verticalScrollState)
+                .padding(horizontal = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(8.dp)
+        ) {
+            hazeStateS.value = hazeState
+            Spacer(modifier = Modifier.height(topPadding))
+
+//            val mediaAssistEnabled = remember { mutableStateOf(false) }
+//            val adjustMediaEnabled = remember { mutableStateOf(false) }
+//            val adjustPhoneEnabled = remember { mutableStateOf(false) }
+
+            LaunchedEffect(hearingAidEnabled.value) {
+                if (hearingAidEnabled.value && !initialLoad.value) {
+                    showDialog.value = true
+                } else if (!hearingAidEnabled.value && !initialLoad.value) {
+                    viewModel.setControlCommandValue(AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID, byteArrayOf(0x01, 0x02))
+                    viewModel.setControlCommandByte(AACPManager.Companion.ControlCommandIdentifiers.HEARING_ASSIST_CONFIG, 0x02.toByte())
+                    hearingAidEnabled.value = false
+                }
+                initialLoad.value = false
+            }
+
+//            fun onAdjustPhoneChange(value: Boolean) {
+//                // TODO
+//            }
+
+//            fun onAdjustMediaChange(value: Boolean) {
+//                // TODO
+//            }
+
+            Text(
+                text = stringResource(R.string.hearing_aid),
+                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)
+            )
+
+            val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .background(backgroundColor, RoundedCornerShape(28.dp))
+                    .clip(
+                        RoundedCornerShape(28.dp)
+                    )
+            ) {
+                StyledToggle(
+                    label = stringResource(R.string.hearing_aid),
+                    checked = hearingAidEnabled.value,
+                    onCheckedChange = { hearingAidEnabled.value = it },
+                    independent = false
+                )
+                HorizontalDivider(
+                    thickness = 1.dp,
+                    color = Color(0x40888888),
+                    modifier = Modifier
+                        .padding(horizontal = 12.dp)
+                )
+                NavigationButton(
+                    to = "hearing_aid_adjustments",
+                    name = stringResource(R.string.adjustments),
+                    navController = navController,
+                    independent = false
+                )
+            }
+            Text(
+                text = stringResource(R.string.hearing_aid_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 = 16.dp)
+            )
+            Spacer(modifier = Modifier.height(16.dp))
+
+            NavigationButton(
+                to = "update_hearing_test",
+                name = stringResource(R.string.update_hearing_test),
+                navController = navController,
+                independent = true
+            )
+
+            // not implemented yet
+
+            // StyledToggle(
+            //     title = stringResource(R.string.media_assist),
+            //     label = stringResource(R.string.media_assist),
+            //     checkedState = mediaAssistEnabled,
+            //     independent = true,
+            //     description = stringResource(R.string.media_assist_description)
+            // )
+
+            // Spacer(modifier = Modifier.height(8.dp))
+
+            // Column (
+            //     modifier = Modifier
+            //         .fillMaxWidth()
+            //         .background(backgroundColor, RoundedCornerShape(28.dp))
+            // ) {
+            //     StyledToggle(
+            //         label = stringResource(R.string.adjust_media),
+            //         checkedState = adjustMediaEnabled,
+            //         onCheckedChange = { onAdjustMediaChange(it) },
+            //         independent = false
+            //     )
+            //     HorizontalDivider(
+            //         thickness = 1.dp,
+            //         color = Color(0x40888888),
+            //         modifier = Modifier
+            //             .padding(horizontal = 12.dp)
+            //     )
+
+            //     StyledToggle(
+            //         label = stringResource(R.string.adjust_calls),
+            //         checkedState = adjustPhoneEnabled,
+            //         onCheckedChange = { onAdjustPhoneChange(it) },
+            //         independent = false
+            //     )
+            // }
+            Spacer(modifier = Modifier.height(bottomPadding))
+        }
+    }
+    ConfirmationDialog(
+        showDialog = showDialog,
+        title = "Enable Hearing Aid",
+        message = "Enabling Hearing Aid will disable Headphone Accommodation and Customized Transparency Mode.",
+        confirmText = "Enable",
+        dismissText = "Cancel",
+        onConfirm = {
+            showDialog.value = false
+            val enrolled = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID]?.getOrNull(0) == 0x01.toByte()
+            if (!enrolled) {
+                viewModel.setControlCommandValue(AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID, byteArrayOf(0x01, 0x01))
+            } else {
+                viewModel.setControlCommandValue(AACPManager.Companion.ControlCommandIdentifiers.HEARING_AID, byteArrayOf(0x01, 0x01))
+            }
+            viewModel.setControlCommandByte(AACPManager.Companion.ControlCommandIdentifiers.HEARING_ASSIST_CONFIG, 0x01.toByte())
+            hearingAidEnabled.value = true
+            CoroutineScope(Dispatchers.IO).launch {
+                try {
+                    if (state.hearingAidData.isEmpty()) {
+                        Log.w(TAG, "read failed")
+                        return@launch
+                    }
+                    val parsed = parseTransparencySettingsResponse(state.hearingAidData)
+                    val disabledSettings = parsed.copy(enabled = false)
+                    sendTransparencySettings(viewModel::setATTCharacteristicValue, disabledSettings)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error disabling transparency: ${e.message}")
+                }
+            }
+        },
+        onDismiss = {
+            hearingAidEnabled.value = false
+            showDialog.value = false
+        },
+//        hazeState = hazeStateS.value,
+         backdrop = backdrop
+    )
+}

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

@@ -0,0 +1,120 @@
+/*
+    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.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.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 me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.bluetooth.AACPManager
+import me.kavishdevar.librepods.bluetooth.ATTHandles
+import me.kavishdevar.librepods.presentation.components.StyledButton
+import me.kavishdevar.librepods.presentation.components.StyledScaffold
+import me.kavishdevar.librepods.presentation.components.StyledToggle
+import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
+
+@Composable
+fun HearingProtectionScreen(viewModel: AirPodsViewModel, navController: NavController) {
+    val backdrop = rememberLayerBackdrop()
+    val state by viewModel.uiState.collectAsState()
+    StyledScaffold(
+        title = stringResource(R.string.hearing_protection),
+    ) { spacerHeight ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .layerBackdrop(backdrop)
+                .padding(horizontal = 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
+                        ),
+                    )
+                }
+            }
+            if (state.vendorIdHook) {
+                StyledToggle(
+                    title = stringResource(R.string.environmental_noise),
+                    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,
+                            byteArrayOf(if (it) 1.toByte() else 0.toByte())
+                        )
+                    },
+                    enabled = state.isPremium
+                )
+
+                Spacer(modifier = Modifier.height(12.dp))
+            }
+            StyledToggle(
+                title = stringResource(R.string.workspace_use),
+                label = stringResource(R.string.ppe),
+                description = stringResource(R.string.workspace_use_description),
+                checked = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.PPE_TOGGLE_CONFIG]?.getOrNull(
+                    0
+                )?.toInt() == 1,
+                onCheckedChange = {
+                    viewModel.setControlCommandBoolean(
+                        AACPManager.Companion.ControlCommandIdentifiers.PPE_TOGGLE_CONFIG, it
+                    )
+                },
+                enabled = state.isPremium
+            )
+        }
+    }
+}

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

@@ -0,0 +1,82 @@
+/*
+    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

@@ -0,0 +1,303 @@
+/*
+    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.content.Context
+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.runtime.mutableIntStateOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+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.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.core.content.edit
+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.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.data.StemAction
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.bluetooth.AACPManager
+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 context = LocalContext.current
+    val sharedPreferences = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    val prefKey = if (name.lowercase() == "left") "left_long_press_action" else "right_long_press_action"
+    val longPressActionPref = sharedPreferences.getString(prefKey, StemAction.CYCLE_NOISE_CONTROL_MODES.name)
+    Log.d("PressAndHoldSettingsScreen", "Long press action preference ($prefKey): $longPressActionPref")
+    var longPressAction by remember { mutableStateOf(StemAction.valueOf(longPressActionPref ?: StemAction.CYCLE_NOISE_CONTROL_MODES.name)) }
+    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 = {
+                        longPressAction = StemAction.CYCLE_NOISE_CONTROL_MODES
+                        sharedPreferences.edit { putString(prefKey, StemAction.CYCLE_NOISE_CONTROL_MODES.name) }
+                    }
+                ),
+                SelectItem(
+                    name = stringResource(R.string.digital_assistant),
+                    selected = longPressAction == StemAction.DIGITAL_ASSISTANT,
+                    onClick = {
+                        longPressAction = StemAction.DIGITAL_ASSISTANT
+                        sharedPreferences.edit { putString(prefKey, StemAction.DIGITAL_ASSISTANT.name) }
+                    },
+                    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 offListeningModeValue = ServiceManager.getService()!!.aacpManager.controlCommandStatusList.find {
+                    it.identifier == AACPManager.Companion.ControlCommandIdentifiers.ALLOW_OFF_OPTION
+                }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+                Log.d("PressAndHoldSettingsScreen", "Allow Off state: $offListeningModeValue")
+                val allowOff = offListeningModeValue == 1.toByte()
+                Log.d("PressAndHoldSettingsScreen", "Allow Off option: $allowOff")
+
+                val initialByte = state.controlStates[AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS]
+                    ?.get(0)?.toInt()
+                    ?: sharedPreferences.getInt("long_press_byte", 0b0101)
+
+                var currentByte by remember { mutableIntStateOf(initialByte) }
+
+                val listeningModeItems = mutableListOf<SelectItem>()
+                if (allowOff) {
+                    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 = {
+                                val bit = 0x01
+                                val newValue = if ((currentByte and bit) != 0) {
+                                    val temp = currentByte and bit.inv()
+                                    if (countEnabledModes(temp) >= 2) temp else currentByte
+                                } else {
+                                    currentByte or bit
+                                }
+                                viewModel.setControlCommandByte(
+                                    AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS,
+                                    newValue.toByte()
+                                )
+                                sharedPreferences.edit {
+                                    putInt("long_press_byte", newValue)
+                                }
+                                currentByte = newValue
+                            }
+                        )
+                    )
+                }
+                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 = {
+                            val bit = 0x04
+                            val newValue = if ((currentByte and bit) != 0) {
+                                val temp = currentByte and bit.inv()
+                                if (countEnabledModes(temp) >= 2) temp else currentByte
+                            } else {
+                                currentByte or bit
+                            }
+                            viewModel.setControlCommandByte(
+                                AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS,
+                                newValue.toByte()
+                            )
+                            sharedPreferences.edit {
+                                putInt("long_press_byte", newValue)
+                            }
+                            currentByte = newValue
+                        }
+                    ),
+                    SelectItem(
+                        name = stringResource(R.string.adaptive),
+                        description = stringResource(R.string.listening_mode_adaptive_description),
+                        iconRes = R.drawable.adaptive,
+                        selected = (currentByte and 0x08) != 0,
+                        onClick = {
+                            val bit = 0x08
+                            val newValue = if ((currentByte and bit) != 0) {
+                                val temp = currentByte and bit.inv()
+                                if (countEnabledModes(temp) >= 2) temp else currentByte
+                            } else {
+                                currentByte or bit
+                            }
+                            viewModel.setControlCommandByte(
+                                AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS,
+                                newValue.toByte()
+                            )
+                            sharedPreferences.edit {
+                                putInt("long_press_byte", newValue)
+                            }
+                            currentByte = newValue
+                        }
+                    ),
+                    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 = {
+                            val bit = 0x02
+                            val newValue = if ((currentByte and bit) != 0) {
+                                val temp = currentByte and bit.inv()
+                                if (countEnabledModes(temp) >= 2) temp else currentByte
+                            } else {
+                                currentByte or bit
+                            }
+                            viewModel.setControlCommandByte(
+                                AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS,
+                                newValue.toByte()
+                            )
+                            sharedPreferences.edit {
+                                putInt("long_press_byte", newValue)
+                            }
+                            currentByte = newValue
+                        }
+                    )
+                ))
+                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)
+                )
+            }
+        }
+    }
+    Log.d("PressAndHoldSettingsScreen", "Current byte: ${modesByte.toString(2)}")
+}
+
+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
+}

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

@@ -0,0 +1,528 @@
+/*
+    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.BuildConfig
+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
+
+@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 (BuildConfig.FLAVOR == "xposed") {
+                        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/RenameScreen.kt

@@ -0,0 +1,84 @@
+/*
+    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 android.content.Context
+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.foundation.text.input.rememberTextFieldState
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.remember
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.focus.FocusRequester
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.unit.dp
+import androidx.core.content.edit
+import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.presentation.components.StyledInputField
+import me.kavishdevar.librepods.presentation.components.StyledScaffold
+import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalHazeMaterialsApi::class)
+@Composable
+fun RenameScreen(viewModel: AirPodsViewModel) {
+    val sharedPreferences = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    val focusRequester = remember { FocusRequester() }
+    val keyboardController = LocalSoftwareKeyboardController.current
+
+    LaunchedEffect(Unit) {
+        focusRequester.requestFocus()
+        keyboardController?.show()
+    }
+
+    StyledScaffold(
+        title = stringResource(R.string.name),
+    ) { spacerHeight ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(horizontal = 16.dp)
+        ) {
+            Spacer(modifier = Modifier.height(spacerHeight))
+
+            val textFieldState = rememberTextFieldState()
+            textFieldState.edit { sharedPreferences.getString("name", "") ?: "" }
+            LaunchedEffect(textFieldState.text) {
+                sharedPreferences.edit {putString("name", textFieldState.text as String?)}
+                viewModel.setName(textFieldState.text.toString())
+            }
+
+            StyledInputField(
+                textFieldState,
+                focusRequester
+            )
+        }
+    }
+}

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

@@ -0,0 +1,416 @@
+/*
+    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.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.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Slider
+import androidx.compose.material3.SliderDefaults
+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.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+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.shadow
+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 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.presentation.components.StyledScaffold
+import me.kavishdevar.librepods.presentation.components.StyledSlider
+import me.kavishdevar.librepods.presentation.components.StyledToggle
+import me.kavishdevar.librepods.data.TransparencySettings
+import me.kavishdevar.librepods.data.parseTransparencySettingsResponse
+import me.kavishdevar.librepods.data.sendTransparencySettings
+import me.kavishdevar.librepods.presentation.viewmodel.AirPodsViewModel
+import java.io.IOException
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+private const val TAG = "TransparencySettings"
+
+@SuppressLint("DefaultLocale")
+@ExperimentalHazeMaterialsApi
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalEncodingApi::class)
+@Composable
+fun TransparencySettingsScreen(viewModel: AirPodsViewModel) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+    val verticalScrollState = rememberScrollState()
+
+    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)
+
+    val backdrop = rememberLayerBackdrop()
+
+
+    val state by viewModel.uiState.collectAsState()
+
+    StyledScaffold(
+        title = stringResource(R.string.customize_transparency_mode)
+    ){ topPadding, hazeState, bottomPadding ->
+        Column(
+            modifier = Modifier
+                .hazeSource(hazeState)
+                .layerBackdrop(backdrop)
+                .fillMaxSize()
+                .verticalScroll(verticalScrollState)
+                .padding(horizontal = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            Spacer(modifier = Modifier.height(topPadding))
+            val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+
+            val enabled = remember { mutableStateOf(false) }
+            val amplificationSliderValue = remember { mutableFloatStateOf(0.5f) }
+            val balanceSliderValue = remember { mutableFloatStateOf(0.5f) }
+            val toneSliderValue = remember { mutableFloatStateOf(0.5f) }
+            val ambientNoiseReductionSliderValue = remember { mutableFloatStateOf(0.0f) }
+            val conversationBoostEnabled = remember { mutableStateOf(false) }
+            val eq = remember { mutableStateOf(FloatArray(8)) }
+            val phoneMediaEQ = remember { mutableStateOf(FloatArray(8) { 0.5f }) }
+
+            val initialLoadComplete = remember { mutableStateOf(false) }
+
+            val initialReadSucceeded = remember { mutableStateOf(false) }
+            val initialReadAttempts = remember { mutableIntStateOf(0) }
+
+            val transparencySettings = remember {
+                mutableStateOf(
+                    TransparencySettings(
+                        enabled = enabled.value,
+                        leftEQ = eq.value,
+                        rightEQ = eq.value,
+                        leftAmplification = amplificationSliderValue.floatValue + (0.5f - balanceSliderValue.floatValue) * amplificationSliderValue.floatValue * 2,
+                        rightAmplification = amplificationSliderValue.floatValue + (balanceSliderValue.floatValue - 0.5f) * amplificationSliderValue.floatValue * 2,
+                        leftTone = toneSliderValue.floatValue,
+                        rightTone = toneSliderValue.floatValue,
+                        leftConversationBoost = conversationBoostEnabled.value,
+                        rightConversationBoost = conversationBoostEnabled.value,
+                        leftAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                        rightAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                        netAmplification = amplificationSliderValue.floatValue,
+                        balance = balanceSliderValue.floatValue
+                    )
+                )
+            }
+
+            LaunchedEffect(
+                enabled.value,
+                amplificationSliderValue.floatValue,
+                balanceSliderValue.floatValue,
+                toneSliderValue.floatValue,
+                conversationBoostEnabled.value,
+                ambientNoiseReductionSliderValue.floatValue,
+                eq.value,
+                initialLoadComplete.value,
+                initialReadSucceeded.value
+            ) {
+                if (!initialLoadComplete.value) {
+                    Log.d(TAG, "Initial device load not complete - skipping send")
+                    return@LaunchedEffect
+                }
+
+                if (!initialReadSucceeded.value) {
+                    Log.d(
+                        TAG,
+                        "Initial device read not successful yet - skipping send until read succeeds"
+                    )
+                    return@LaunchedEffect
+                }
+
+                transparencySettings.value = TransparencySettings(
+                    enabled = enabled.value,
+                    leftEQ = eq.value,
+                    rightEQ = eq.value,
+                    leftAmplification = amplificationSliderValue.floatValue + if (balanceSliderValue.floatValue < 0) -balanceSliderValue.floatValue else 0f,
+                    rightAmplification = amplificationSliderValue.floatValue + if (balanceSliderValue.floatValue > 0) balanceSliderValue.floatValue else 0f,
+                    leftTone = toneSliderValue.floatValue,
+                    rightTone = toneSliderValue.floatValue,
+                    leftConversationBoost = conversationBoostEnabled.value,
+                    rightConversationBoost = conversationBoostEnabled.value,
+                    leftAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                    rightAmbientNoiseReduction = ambientNoiseReductionSliderValue.floatValue,
+                    netAmplification = amplificationSliderValue.floatValue,
+                    balance = balanceSliderValue.floatValue
+                )
+                Log.d("TransparencySettings", "Updated settings: ${transparencySettings.value}")
+                sendTransparencySettings(viewModel::setATTCharacteristicValue, transparencySettings.value)
+            }
+
+            LaunchedEffect(Unit) {
+                Log.d(TAG, "Connecting to ATT...")
+                try {
+                    // If we have an AACP manager, prefer its EQ data to populate EQ controls first
+                    try {
+                        Log.d(TAG, "Found AACPManager, reading cached EQ data")
+                        val aacpEQ = state.eqData
+                        if (aacpEQ.isNotEmpty()) {
+                            eq.value = aacpEQ.copyOf()
+                            phoneMediaEQ.value = aacpEQ.copyOf()
+                            Log.d(TAG, "Populated EQ from AACPManager: ${aacpEQ.toList()}")
+                        } else {
+                            Log.d(TAG, "AACPManager EQ data empty")
+                        }
+                    } catch (e: Exception) {
+                        Log.w(TAG, "Error reading EQ from AACPManager: ${e.message}")
+                    }
+
+                    var parsedSettings: TransparencySettings? = null
+                    for (attempt in 1..3) {
+                        initialReadAttempts.intValue = attempt
+                        try {
+                            val data = state.transparencyData
+                            parsedSettings = parseTransparencySettingsResponse(data = data)
+                            Log.d(TAG, "Parsed settings on attempt $attempt")
+                        } catch (e: Exception) {
+                            Log.w(TAG, "Read attempt $attempt failed: ${e.message}")
+                        }
+                        delay(200)
+                    }
+
+                    if (parsedSettings != null) {
+                        Log.d(TAG, "Initial transparency settings: $parsedSettings")
+                        enabled.value = parsedSettings.enabled
+                        amplificationSliderValue.floatValue = parsedSettings.netAmplification
+                        balanceSliderValue.floatValue = parsedSettings.balance
+                        toneSliderValue.floatValue = parsedSettings.leftTone
+                        ambientNoiseReductionSliderValue.floatValue =
+                            parsedSettings.leftAmbientNoiseReduction
+                        conversationBoostEnabled.value = parsedSettings.leftConversationBoost
+                        eq.value = parsedSettings.leftEQ.copyOf()
+                        initialReadSucceeded.value = true
+                    } else {
+                        Log.d(
+                            TAG,
+                            "Failed to read/parse initial transparency settings after ${initialReadAttempts.intValue} attempts"
+                        )
+                    }
+                } catch (e: IOException) {
+                    e.printStackTrace()
+                } finally {
+                    initialLoadComplete.value = true
+                }
+            }
+
+            if (state.vendorIdHook) {
+                StyledToggle(
+                    label = stringResource(R.string.transparency_mode),
+                    checked = enabled.value,
+                    independent = true,
+                    description = stringResource(R.string.customize_transparency_mode_description),
+                    onCheckedChange = { enabled.value = it }
+                )
+                Spacer(modifier = Modifier.height(4.dp))
+                StyledSlider(
+                    label = stringResource(R.string.amplification),
+                    valueRange = -1f..1f,
+                    value = amplificationSliderValue.floatValue,
+                    onValueChange = {
+                        amplificationSliderValue.floatValue = it
+                    },
+                    startIcon = "􀊥",
+                    endIcon = "􀊩",
+                    independent = true
+                )
+
+                StyledSlider(
+                    label = stringResource(R.string.balance),
+                    valueRange = -1f..1f,
+                    value = balanceSliderValue.floatValue,
+                    onValueChange = {
+                        balanceSliderValue.floatValue = it
+                    },
+                    snapPoints = listOf(-1f, 0f, 1f),
+                    startLabel = stringResource(R.string.left),
+                    endLabel = stringResource(R.string.right),
+                    independent = true,
+                )
+
+                StyledSlider(
+                    label = stringResource(R.string.tone),
+                    valueRange = -1f..1f,
+                    value = toneSliderValue.floatValue,
+                    onValueChange = {
+                        toneSliderValue.floatValue = it
+                    },
+                    startLabel = stringResource(R.string.darker),
+                    endLabel = stringResource(R.string.brighter),
+                    independent = true,
+                )
+
+                StyledSlider(
+                    label = stringResource(R.string.ambient_noise_reduction),
+                    valueRange = 0f..1f,
+                    value = ambientNoiseReductionSliderValue.floatValue,
+                    onValueChange = {
+                        ambientNoiseReductionSliderValue.floatValue = it
+                    },
+                    startLabel = stringResource(R.string.less),
+                    endLabel = stringResource(R.string.more),
+                    independent = true,
+                )
+
+                StyledToggle(
+                    label = stringResource(R.string.conversation_boost),
+                    checked = conversationBoostEnabled.value,
+                    independent = true,
+                    description = stringResource(R.string.conversation_boost_description),
+                    onCheckedChange = { conversationBoostEnabled.value = it }
+                )
+
+                Text(
+                    text = stringResource(R.string.equalizer),
+                    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)
+                )
+
+                Column(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .background(backgroundColor, RoundedCornerShape(28.dp))
+                        .padding(16.dp),
+                    horizontalAlignment = Alignment.CenterHorizontally,
+                    verticalArrangement = Arrangement.SpaceBetween
+                ) {
+                    for (i in 0 until 8) {
+                        val eqValue = remember(eq.value[i]) { mutableFloatStateOf(eq.value[i]) }
+                        Row(
+                            horizontalArrangement = Arrangement.SpaceBetween,
+                            verticalAlignment = Alignment.CenterVertically,
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .height(38.dp)
+                        ) {
+                            Text(
+                                text = String.format("%.2f", eqValue.floatValue),
+                                fontSize = 12.sp,
+                                color = textColor,
+                                modifier = Modifier.padding(bottom = 4.dp)
+                            )
+
+                            Slider(
+                                value = eqValue.floatValue,
+                                onValueChange = { newVal ->
+                                    eqValue.floatValue = newVal
+                                    val newEQ = eq.value.copyOf()
+                                    newEQ[i] = eqValue.floatValue
+                                    eq.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(eqValue.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(16.dp))
+            }
+
+            Spacer(modifier = Modifier.height(bottomPadding))
+        }
+    }
+}

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

@@ -0,0 +1,918 @@
+/*
+    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/UpdateHearingTestScreen.kt

@@ -0,0 +1,358 @@
+/*
+    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.util.Log
+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.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.text.KeyboardOptions
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material3.OutlinedTextField
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableFloatStateOf
+import androidx.compose.runtime.mutableIntStateOf
+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.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.input.KeyboardType
+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 dev.chrisbanes.haze.hazeSource
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.presentation.components.StyledScaffold
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.bluetooth.ATTHandles
+import me.kavishdevar.librepods.data.HearingAidSettings
+import me.kavishdevar.librepods.data.parseHearingAidSettingsResponse
+import me.kavishdevar.librepods.data.sendHearingAidSettings
+import java.io.IOException
+
+private var debounceJob: MutableState<Job?> = mutableStateOf(null)
+private const val TAG = "HearingAidAdjustments"
+
+@Composable
+fun UpdateHearingTestScreen() {
+    val verticalScrollState = rememberScrollState()
+    val attManager = ServiceManager.getService()?.attManager
+    if (attManager == null) {
+        Text(
+            text = stringResource(R.string.att_manager_is_null_try_reconnecting),
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(16.dp),
+            textAlign = TextAlign.Center
+        )
+        return
+    }
+
+    val backdrop = rememberLayerBackdrop()
+    StyledScaffold(
+        title = stringResource(R.string.hearing_test)
+    ) { topPadding, hazeState, bottomPadding ->
+        Column(
+            modifier = Modifier
+                .hazeSource(hazeState)
+                .fillMaxSize()
+                .layerBackdrop(backdrop)
+                .verticalScroll(verticalScrollState)
+                .padding(horizontal = 16.dp),
+            verticalArrangement = Arrangement.spacedBy(16.dp)
+        ) {
+            val textColor = if (isSystemInDarkTheme()) Color.White else Color.Black
+
+            Spacer(modifier = Modifier.height(topPadding))
+
+            Text(
+                text = stringResource(R.string.hearing_test_value_instruction),
+                modifier = Modifier.fillMaxWidth(),
+                style = TextStyle(
+                    fontSize = 16.sp,
+                    color = textColor,
+                    fontFamily = FontFamily(Font(R.font.sf_pro))
+                ),
+                textAlign = TextAlign.Center,
+            )
+            val tone = remember { mutableFloatStateOf(0.5f) }
+            val ambientNoiseReduction = remember { mutableFloatStateOf(0.0f) }
+            val ownVoiceAmplification = remember { mutableFloatStateOf(0.5f) }
+            val leftAmplification = remember { mutableFloatStateOf(0.5f) }
+            val rightAmplification = remember { mutableFloatStateOf(0.5f) }
+            val conversationBoostEnabled = remember { mutableStateOf(false) }
+            val leftEQ = remember { mutableStateOf(FloatArray(8)) }
+            val rightEQ = remember { mutableStateOf(FloatArray(8)) }
+
+            val initialLoadComplete = remember { mutableStateOf(false) }
+            val initialReadSucceeded = remember { mutableStateOf(false) }
+            val initialReadAttempts = remember { mutableIntStateOf(0) }
+
+            val hearingAidSettings = remember {
+                mutableStateOf(
+                    HearingAidSettings(
+                        leftEQ = leftEQ.value,
+                        rightEQ = rightEQ.value,
+                        leftAmplification = leftAmplification.floatValue,
+                        rightAmplification = rightAmplification.floatValue,
+                        leftTone = tone.floatValue,
+                        rightTone = tone.floatValue,
+                        leftConversationBoost = conversationBoostEnabled.value,
+                        rightConversationBoost = conversationBoostEnabled.value,
+                        leftAmbientNoiseReduction = ambientNoiseReduction.floatValue,
+                        rightAmbientNoiseReduction = ambientNoiseReduction.floatValue,
+                        netAmplification = leftAmplification.floatValue + rightAmplification.floatValue / 2,
+                        balance = 0.5f + (rightAmplification.floatValue - leftAmplification.floatValue) / 2,
+                        ownVoiceAmplification = ownVoiceAmplification.floatValue
+                    )
+                )
+            }
+
+            val hearingAidATTListener = remember {
+                object : (ByteArray) -> Unit {
+                    override fun invoke(value: ByteArray) {
+                        val parsed = parseHearingAidSettingsResponse(value)
+                        if (parsed != null) {
+                            leftEQ.value = parsed.leftEQ.copyOf()
+                            rightEQ.value = parsed.rightEQ.copyOf()
+                            conversationBoostEnabled.value = parsed.leftConversationBoost
+                            tone.floatValue = parsed.leftTone
+                            ambientNoiseReduction.floatValue = parsed.leftAmbientNoiseReduction
+                            ownVoiceAmplification.floatValue = parsed.ownVoiceAmplification
+                            leftAmplification.floatValue = parsed.leftAmplification
+                            rightAmplification.floatValue = parsed.rightAmplification
+                            Log.d(TAG, "Updated hearing aid settings from notification")
+                        } else {
+                            Log.w(TAG, "Failed to parse hearing aid settings from notification")
+                        }
+                    }
+                }
+            }
+
+
+            DisposableEffect(Unit) {
+                onDispose {
+                    attManager.unregisterListener(ATTHandles.HEARING_AID, hearingAidATTListener)
+                }
+            }
+
+            LaunchedEffect(
+                leftEQ.value,
+                rightEQ.value,
+                conversationBoostEnabled.value,
+                initialLoadComplete.value,
+                initialReadSucceeded.value,
+                leftAmplification.floatValue,
+                rightAmplification.floatValue,
+                tone.floatValue,
+                ambientNoiseReduction.floatValue,
+                ownVoiceAmplification.floatValue
+            ) {
+                if (!initialLoadComplete.value) {
+                    Log.d(TAG, "Initial device load not complete - skipping send")
+                    return@LaunchedEffect
+                }
+
+                if (!initialReadSucceeded.value) {
+                    Log.d(
+                        TAG,
+                        "Initial device read not successful yet - skipping send until read succeeds"
+                    )
+                    return@LaunchedEffect
+                }
+
+                hearingAidSettings.value = HearingAidSettings(
+                    leftEQ = leftEQ.value,
+                    rightEQ = rightEQ.value,
+                    leftAmplification = leftAmplification.floatValue,
+                    rightAmplification = rightAmplification.floatValue,
+                    leftTone = tone.floatValue,
+                    rightTone = tone.floatValue,
+                    leftConversationBoost = conversationBoostEnabled.value,
+                    rightConversationBoost = conversationBoostEnabled.value,
+                    leftAmbientNoiseReduction = ambientNoiseReduction.floatValue,
+                    rightAmbientNoiseReduction = ambientNoiseReduction.floatValue,
+                    netAmplification = leftAmplification.floatValue + rightAmplification.floatValue / 2,
+                    balance = 0.5f + (rightAmplification.floatValue - leftAmplification.floatValue) / 2,
+                    ownVoiceAmplification = ownVoiceAmplification.floatValue
+                )
+                Log.d(TAG, "Updated settings: ${hearingAidSettings.value}")
+                sendHearingAidSettings(attManager, hearingAidSettings.value, debounceJob)
+            }
+
+            LaunchedEffect(Unit) {
+                Log.d(TAG, "Connecting to ATT...")
+                try {
+                    attManager.enableNotifications(ATTHandles.HEARING_AID)
+                    attManager.registerListener(ATTHandles.HEARING_AID, hearingAidATTListener)
+
+                    var parsedSettings: HearingAidSettings? = null
+                    for (attempt in 1..3) {
+                        initialReadAttempts.intValue = attempt
+                        try {
+                            val data = attManager.read(ATTHandles.HEARING_AID)
+                            parsedSettings = parseHearingAidSettingsResponse(data = data)
+                            if (parsedSettings != null) {
+                                Log.d(TAG, "Parsed settings on attempt $attempt")
+                                break
+                            } else {
+                                Log.d(TAG, "Parsing returned null on attempt $attempt")
+                            }
+                        } catch (e: Exception) {
+                            Log.w(TAG, "Read attempt $attempt failed: ${e.message}")
+                        }
+                        delay(200)
+                    }
+
+                    if (parsedSettings != null) {
+                        Log.d(TAG, "Initial hearing aid settings: $parsedSettings")
+                        leftEQ.value = parsedSettings.leftEQ.copyOf()
+                        rightEQ.value = parsedSettings.rightEQ.copyOf()
+                        conversationBoostEnabled.value = parsedSettings.leftConversationBoost
+                        tone.floatValue = parsedSettings.leftTone
+                        ambientNoiseReduction.floatValue = parsedSettings.leftAmbientNoiseReduction
+                        ownVoiceAmplification.floatValue = parsedSettings.ownVoiceAmplification
+                        leftAmplification.floatValue = parsedSettings.leftAmplification
+                        rightAmplification.floatValue = parsedSettings.rightAmplification
+                        initialReadSucceeded.value = true
+                    } else {
+                        Log.d(
+                            TAG,
+                            "Failed to read/parse initial hearing aid settings after ${initialReadAttempts.intValue} attempts"
+                        )
+                    }
+                } catch (e: IOException) {
+                    e.printStackTrace()
+                } finally {
+                    initialLoadComplete.value = true
+                }
+            }
+
+            val frequencies =
+                listOf("250Hz", "500Hz", "1kHz", "2kHz", "3kHz", "4kHz", "6kHz", "8kHz")
+
+            Row(
+                modifier = Modifier.fillMaxWidth(),
+                horizontalArrangement = Arrangement.spacedBy(8.dp)
+            ) {
+                Spacer(modifier = Modifier.width(60.dp))
+                Text(
+                    text = stringResource(R.string.left),
+                    modifier = Modifier.weight(1f),
+                    textAlign = TextAlign.Center,
+                    style = TextStyle(
+                        fontSize = 18.sp,
+                        fontFamily = FontFamily(Font(R.font.sf_pro)),
+                        color = textColor
+                    )
+                )
+                Text(
+                    text = stringResource(R.string.right),
+                    modifier = Modifier.weight(1f),
+                    textAlign = TextAlign.Center,
+                    style = TextStyle(
+                        fontSize = 18.sp,
+                        fontFamily = FontFamily(Font(R.font.sf_pro)),
+                        color = textColor
+                    )
+                )
+            }
+
+            frequencies.forEachIndexed { index, freq ->
+                Row(
+                    modifier = Modifier.fillMaxWidth(),
+                    horizontalArrangement = Arrangement.spacedBy(8.dp)
+                ) {
+                    Text(
+                        text = freq,
+                        modifier = Modifier
+                            .width(60.dp)
+                            .align(Alignment.CenterVertically),
+                        textAlign = TextAlign.End,
+                        style = TextStyle(
+                            color = textColor,
+                            fontSize = 16.sp,
+                            fontFamily = FontFamily(Font(R.font.sf_pro))
+                        ),
+                    )
+                    OutlinedTextField(
+                        value = leftEQ.value[index].toString(),
+                        onValueChange = { newValue ->
+                            val parsed = newValue.toFloatOrNull()
+                            if (parsed != null) {
+                                val newArray = leftEQ.value.copyOf()
+                                newArray[index] = parsed
+                                leftEQ.value = newArray
+                                Log.d(TAG, "Left EQ updated at index $index to $parsed")
+                            }
+                        },
+//                        label = { Text("Value", fontSize = 14.sp, fontFamily = FontFamily(Font(R.font.sf_pro))) },
+                        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                        textStyle = TextStyle(
+                            fontFamily = FontFamily(Font(R.font.sf_pro)),
+                            fontSize = 14.sp
+                        ),
+                        modifier = Modifier.weight(1f)
+                    )
+                    OutlinedTextField(
+                        value = rightEQ.value[index].toString(),
+                        onValueChange = { newValue ->
+                            val parsed = newValue.toFloatOrNull()
+                            if (parsed != null) {
+                                val newArray = rightEQ.value.copyOf()
+                                newArray[index] = parsed
+                                rightEQ.value = newArray
+                                Log.d(TAG, "Right EQ updated at index $index to $parsed")
+                            }
+                        },
+//                        label = { Text("Value", fontSize = 14.sp, fontFamily = FontFamily(Font(R.font.sf_pro))) },
+                        keyboardOptions = KeyboardOptions(keyboardType = KeyboardType.Decimal),
+                        textStyle = TextStyle(
+                            fontFamily = FontFamily(Font(R.font.sf_pro)),
+                            fontSize = 14.sp
+                        ),
+                        modifier = Modifier.weight(1f)
+                    )
+                }
+            }
+            Spacer(modifier = Modifier.height(bottomPadding))
+        }
+    }
+}

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

@@ -0,0 +1,180 @@
+/*
+    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/Color.kt

@@ -0,0 +1,30 @@
+/*
+    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.ui.graphics.Color
+
+val Purple80 = Color(0xFFD0BCFF)
+val PurpleGrey80 = Color(0xFFCCC2DC)
+val Pink80 = Color(0xFFEFB8C8)
+
+val Purple40 = Color(0xFF6650a4)
+val PurpleGrey40 = Color(0xFF625b71)
+val Pink40 = Color(0xFF7D5260)