add A16QPR3 constructor

this was mostly generated, but it works

.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}]
+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,100 @@
+name: Build APK and root module (and create nightly release)
+
+on:
+  push:
+    branches:
+      - '*'
+    paths:
+      - 'android/**'
+  workflow_dispatch:
+    inputs:
+      release:
+        description: 'Create a nightly release'
+        required: true
+        type: boolean
+        default: false
+      custom_notes:
+        description: 'Custom updates to add to What''s Changed section'
+        required: false
+        type: string
+  workflow_call:
+
+jobs:
+  build-debug-apk:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - uses: actions/setup-java@v4
+        with:
+          distribution: 'zulu'
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v4
+      - name: Build debug APK
+        run: ./gradlew assembleDebug
+        working-directory: android
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: Debug APK
+          path: android/app/build/outputs/apk/**/*.apk
+  nightly-release:
+    runs-on: ubuntu-latest
+    if: github.event_name == 'push' && github.ref == 'refs/heads/release-nightly' || github.event_name == 'workflow_dispatch' && github.event.inputs.release == 'true'
+    needs: build-debug-apk
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/download-artifact@v4
+      - name: Export APK_NAME for later use
+        run: echo "APK_NAME=LibrePods-$(echo ${{ github.sha }} | cut -c1-7).apk" >> $GITHUB_ENV
+      - name: Rename .apk file
+        run: mv "./Debug APK/debug/"*.apk "./$APK_NAME"
+      - name: Decode keystore file
+        run: echo "${{ secrets.DEBUG_KEYSTORE_FILE }}" | base64 --decode > debug.keystore
+      - name: Install apksigner
+        run: sudo apt-get update && sudo apt-get install -y apksigner
+      - name: Sign APK
+        run: |
+          apksigner sign --ks debug.keystore --ks-key-alias androiddebugkey --ks-pass pass:android --key-pass pass:android "./$APK_NAME"
+      - name: Verify APK
+        run: apksigner verify "./$APK_NAME"
+      - name: Fetch the latest non-nightly release tag
+        id: fetch-tag
+        run: echo "::set-output name=tag::$(git describe --tags $(git rev-list --tags --max-count=1))"
+      - name: Retrieve commits since the last release
+        id: get-commits
+        run: |
+          COMMITS=$(git log ${{ steps.fetch-tag.outputs.tag }}..HEAD --pretty=format:"- %s (%h)" --abbrev-commit)
+          echo "::set-output name=commits::${COMMITS}"
+      - name: Prepare release notes
+        id: release-notes
+        run: |
+          # Create a temporary file for release notes
+          NOTES_FILE=$(mktemp)
+          
+          # Process custom notes if they exist
+          if [ "${{ github.event_name }}" == "workflow_dispatch" ] && [ -n "${{ github.event.inputs.custom_notes }}" ]; then
+            CUSTOM_NOTES="${{ github.event.inputs.custom_notes }}"
+            
+            # Check if custom notes already have bullet points or GitHub-style formatting
+            if echo "$CUSTOM_NOTES" | grep -q "^\*\|^- \|http.*commit\|in #[0-9]\+"; then
+              # Already formatted, use as is
+              echo "$CUSTOM_NOTES" > "$NOTES_FILE"
+            else
+              # Add bullet point formatting
+              echo "- $CUSTOM_NOTES" > "$NOTES_FILE"
+            fi
+          fi
+          
+          echo "notes_file=$NOTES_FILE" >> $GITHUB_OUTPUT
+      - name: Zip root-module directory
+        run: sh ./build-magisk-module.sh
+      - name: Delete release if exist then create release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh release view "nightly" && gh release delete "nightly" -y --cleanup-tag
+          gh release create "nightly" "./$APK_NAME" "./btl2capfix.zip" -p -t "Nightly Release" --notes-file "${{ steps.release-notes.outputs.notes_file }}" --generate-notes

.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,17 @@
+root-module/radare2-5.9.9-android-aarch64.tar.gz
+wak.toml
+log.txt
+btl2capfix.zip
+root-module-manual
+.vscode
 testing.py
 .DS_Store
+CMakeLists.txt.user*
+
 # Android Template
 
+
+### Android ###
 # Gradle files
 .gradle/
 build/
@@ -36,19 +46,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 +371,6 @@ cover/
 *.pot
 
 # Django stuff:
-*.log
 local_settings.py
 db.sqlite3
 db.sqlite3-journal
@@ -146,10 +420,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 +472,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
@@ -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,34 +261,72 @@ 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
+
+```
+52 18 00
+For left bud
+[Enabled]
+[EQ1][EQ2][EQ3][EQ4][EQ5][EQ6][EQ7][EQ8]
+[Amplification]
+[Tone]
+[Conversation Boost]
+[Ambient Noise Reduction]
+00 0080 3F
+<same for the right bud>
+```
+
+<!-- demo packet
+52 18 00 00 00 00 00 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 00 00 80 3f 00 00 80 3f 00 00 80 3f 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 62 10 DA 41 00 00 80 3f 00 00 80 3f 00 00 80 3f
+
+-->
+<!-- 
+5218 0000 0080 3F62 10DA 413D 0AF0 4160
+E50C 42AC 9C1E 421B 2F29 429E 6F33 4293
+1846 4293 1846 4206 9476 BF00 576E BB00
+0080 3F00 0080 3F62 10DA 413D 0AF0 4160
+E50C 42AC 9C1E 421B 2F29 429E 6F33 4293
+1846 4293 1846 4200 0080 BF00 576E BB00
+0080 3F00 0080 3F
+-->
+
+<!-- 
+5218 0000 0000 0062 10DA 413D 0AF0 4160
+E50C 42AC 9C1E 421B 2F29 429E 6F33 4293
+1846 4293 1846 4206 9476 BF00 576E BB00
+0080 3F00 0080 3F62 10DA 413D 0AF0 4160
+E50C 42AC 9C1E 421B 2F29 429E 6F33 4293
+1846 4293 1846 4200 0080 BF00 576E BB00
+0080 3F00 0080 3F
+ -->
+
+All values are formatted as Little Endian from float values.
+| Data                | Type          | Value range |
+|---------------------|---------------|-------------|
+| Enabled             | Little Endian | 0 or 1      |
+| EQ                  | Little Endian | 0 to 100    |
+| Amplification       | Little Endian | -1 to 1     |
+| Tone                | Little Endian | -1 to 1     |
+| Conversation Boost  | Little Endian | 0 or 1      |
+
+> [!IMPORTANT]
+> Also send the [Headphone Accomodation](#headphone-accomodation) after this.
 
-# Miscellaneous/Unknown
 
 ## Configure Stem Long Press
 
@@ -310,21 +398,48 @@ 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              |
+
+# LICENSE
+
+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 Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License.
+
+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 Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.

CHANGELOG.md

@@ -0,0 +1,4 @@
+## btl2capfix v0.0.3
+- ([#34](https://github.com/kavishdevar/librepods/pull/34)) @devnoname120 Add on-device libbluetooth patcher using a Magisk/KernelSU module (arm64-only)
+
+_[See more here](https://github.com/kavishdevar/librepods/releases)_

CONTRIBUTING.md

@@ -1,6 +1,6 @@
-# Welcome to AirPods Like Normal contributing guide <!-- omit in toc -->
+# Welcome to LibrePods contributing guide <!-- omit in toc -->
 
-Thank you for considering a contribution to AirPods Like Normal! Your support helps bring Apple-exclusive AirPods features to Linux and Android.
+Thank you for considering a contribution to LibrePods! Your support helps bring Apple-exclusive AirPods features to Linux and Android.
 
 Read our [Code of Conduct](./CODE_OF_CONDUCT.md) to keep our community approachable and respectful.
 
@@ -25,11 +25,11 @@ To develop for the Android App, Android Studio is the preferred IDE. And you can
 
 #### Create a new issue
 
-If you find a bug or want to suggest a feature, check if an issue already exists by searching through our [existing issues](https://github.com/username/AirPods-Like-Normal/issues). If no relevant issue exists, open a new one and fill in the details.
+If you find a bug or want to suggest a feature, check if an issue already exists by searching through our [existing issues](https://github.com/kavishdevar/librepods/issues). If no relevant issue exists, open a new one and fill in the details.
 
 #### Solve an issue
 
-Browse our [issues list](https://github.com/username/AirPods-Like-Normal/issues) to find an interesting issue to work on. Use labels to filter issues and pick one that matches your expertise. If you’d like to work on an issue, open a PR with your solution.
+Browse our [issues list](https://github.com/kavishdevar/librepods/issues) to find an interesting issue to work on. Use labels to filter issues and pick one that matches your expertise. If you’d like to work on an issue, open a PR with your solution.
 
 ### Make Changes
 
@@ -37,7 +37,7 @@ Browse our [issues list](https://github.com/username/AirPods-Like-Normal/issues)
 
 1. Fork the repository and clone it to your local environment.
 ```
-git clone https://github.com/your-username/AirPods-Like-Normal.git
+git clone https://github.com/kavishdevar/librepods.git
 cd AirPods-Like-Normal
 ```
 2. Create a working branch to start your changes.
@@ -67,4 +67,4 @@ Once your PR is open, a team member will review it. They may ask questions or re
 
 ### Your PR is merged!
 
-Congratulations! :tada: Once merged, your contributions will be publicly available in AirPodsLikeNormal.
+Congratulations! :tada: Once merged, your contributions will be publicly available in LibrePods.

FUNDING.yml

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

LICENSE

@@ -1,5 +1,5 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
 
  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
@@ -7,17 +7,15 @@
 
                             Preamble
 
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
 
   The licenses for most software and other practical works are designed
 to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
+our General Public Licenses are intended to guarantee your freedom to
 share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
+software for all its users.
 
   When we speak of free software, we are referring to freedom, not
 price.  Our General Public Licenses are designed to make sure that you
@@ -26,44 +24,34 @@ them if you wish), that you receive source code or can get it if you
 want it, that you can change the software or use pieces of it in new
 free programs, and that you know you can do these things.
 
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
 
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
 
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
 
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
@@ -72,7 +60,7 @@ modification follow.
 
   0. Definitions.
 
-  "This License" refers to version 3 of the GNU General Public License.
+  "This License" refers to version 3 of the GNU Affero General Public License.
 
   "Copyright" also means copyright-like laws that apply to other kinds of
 works, such as semiconductor masks.
@@ -549,35 +537,45 @@ to collect a royalty for further conveying from those to whom you convey
 the Program, the only way you could satisfy both those terms and this
 License would be to refrain entirely from conveying the Program.
 
-  13. Use with the GNU Affero General Public License.
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
 
   Notwithstanding any other provision of this License, you have
 permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
+under version 3 of the GNU General Public License into a single
 combined work, and to convey the resulting work.  The terms of this
 License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
 
   14. Revised Versions of this License.
 
   The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
 address new problems or concerns.
 
   Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
+Program specifies that a certain numbered version of the GNU Affero General
 Public License "or any later version" applies to it, you have the
 option of following the terms and conditions either of that numbered
 version or of any later version published by the Free Software
 Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
+GNU Affero General Public License, you may choose any version ever published
 by the Free Software Foundation.
 
   If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
+versions of the GNU Affero General Public License can be used, that proxy's
 public statement of acceptance of a version permanently authorizes you
 to choose that version for the Program.
 
@@ -631,44 +629,33 @@ 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 Affero 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 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 Affero 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 Affero 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.
 
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
 
   You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.

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,123 +1,151 @@
-# ALN - AirPods like Normal
-*Access AirPods' Apple-exclusive features on linux and android!*
-### Check out the packet definitions at [AAP Definitions](/AAP%20Definitions.md)
+![LibrePods Banner](/imgs/banner.png)
 
-## Tested device(s)
-- AirPods Pro 2
+[![XDA Thread](https://img.shields.io/badge/XDA_Forums-Thread-orange)](https://xdaforums.com/t/app-root-for-now-airpodslikenormal-unlock-apple-exclusive-airpods-features-on-android.4707585/)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/kavishdevar/librepods)](https://github.com/kavishdevar/librepods/releases/latest)
+[![GitHub all releases](https://img.shields.io/github/downloads/kavishdevar/librepods/total)](https://github.com/kavishdevar/librepods/releases)
+[![GitHub stars](https://img.shields.io/github/stars/kavishdevar/librepods)](https://github.com/kavishdevar/librepods/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/kavishdevar/librepods)](https://github.com/kavishdevar/librepods/issues)
+[![GitHub license](https://img.shields.io/github/license/kavishdevar/librepods)](https://github.com/kavishdevar/librepods/blob/main/LICENSE)
+[![GitHub contributors](https://img.shields.io/github/contributors/kavishdevar/librepods)](https://github.com/kavishdevar/librepods/graphs/contributors)
 
-Other devices might work too! Features like ear detection and battery should be available for any AirPods! Although the app will show unsupported features/settings! I will not be able test any other devices than the ones I already have (i.e. the AirPods Pro 2).
+## What is LibrePods?
 
-## Implemented Features
+LibrePods unlocks Apple's exclusive AirPods features on non-Apple devices. Get access to noise control modes, adaptive transparency, ear detection, battery status, and more - all the premium features you paid for but Apple locked to their ecosystem.
 
-| Feature | Linux | Android |
-| --- | --- | --- |
-| Ear Detection | ✅ | ✅ |
-| Conversational Awareness | ✅ | ✅ |
-| Setting Noise Control | ✅ | ✅ |
-| Battery Level | ✅ | ✅ |
-| Rename AirPods | ❌ | ✅ |
-| Adjust Adaptive Audio | ❌ | ✅ |
-| Loud Sound Reduction | ❌ | ✅ |
+## Device Compatibility
 
-## Linux
-Check out the README file in [linux](/linux) folder for more info.
+| Status | Device | Features |
+|--------|--------|----------|
+| ✅ | AirPods Pro (2nd Gen) | Fully supported and tested |
+| ⚠️ | Other AirPods models | Basic features (battery status, ear detection) should work |
 
-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.
+Most features should work with any AirPods. Currently, testing is only performed with AirPods Pro 2.
 
-![Tray Battery App](/linux/imgs/tray-icon-hover.png)
-![Tray Noise Control Mode Menu](/linux/imgs/tray-icon-menu.png)
+## Key Features
 
-## Android
+- **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
+- **Other customizations**:
+  - Rename your AirPods
+  - Customize long-press actions
+  - Few accessibility features
+  - And more!
 
-Currently, there's a [bug in the Android Bluetooth stack](https://issuetracker.google.com/issues/371713238) that prevents the app from working `(upvote the issue - click the '+1' icon on the top right corner of IssueTracker)`. This repository provides a workaround for the bug, specifically tested on Android 14 and Android 15 (stock versions). 
+See our [pinned issue](https://github.com/kavishdevar/librepods/issues/20) for a complete feature list and roadmap.
 
-**This workaround requires root access** to implement and it might not work on other android OEM skins. Try at your own risk!!
+## Platform Support
 
-### Workaround
+### Linux
 
-#### Step 1: Download the Required Files
-- Go to the [Releases](https://github.com/kavishdevar/aln/releases) section.
-- Download the required files depending upon your Android version - `bt.sh`, `module.prop`, and `libbluetooth_jni-a14.so` (for android 14) or `libbluetooth_jni-a15.so` (for android 15).
+The Linux version runs as a system tray app. Connect your AirPods and enjoy:
 
-#### Step 2: Set Up the Directory Structure
+- Battery monitoring
+- Automatic Ear detection
+- Conversational Awareness
+- Switching Noise Control modes
+- Device renaming
 
-- Use a file manager with root access (eg. Solid FIle Explorer or MT manager) or a shell (using adb, or a terminal app like Termux) and create a folder structure like this (`upper` and `work` are also folders):
+> [!NOTE]
+> Work in progress, but core functionality is stable and usable.
 
-```
-/data/local/tmp/overlay:
-upper
-work
-```
-- Rename the appropriate file to `libbluetooth_jni.so` and place it in the `upper` folder
-```
-/data/local/tmp/overlay/upper:
-libbluetooth_jni.so
-```
-- Create a duplicate of the overlay folder inside tmp  and name it overlay2.
+For installation and detailed info, see the [Linux README](/linux/README.md).
 
-#### Step 3: Add the Boot Script
+### Android
 
-- Place the `bt.sh` script in `/data/adb/post-fs-data.d/`.
-- This script ensures the fix is applied during system startup.
-
-#### Step 4: Create a Magisk Module
-- Create a `btl2capfix` folder in `/data/adb/modules/` and copy the `module.prop`into the folder.
-```
-/data/adb/modules/btl2capfix:
-module.prop
-```
-- Create `system/lib64` under `btl2capfix` and copy the `libbluetooth_jni.so` into `lib64`
-```
-/data/adb/modules/btl2capfix/system/lib64:
-libbluetooth_jni.so
-```
-
-#### Step 5: Verify the Fix
-- Reboot your device.
-- The Bluetooth bug should now be resolved.
-  
-Once the issue is resolved by Google developers or you've addressed it through the above root-based method, download and install the `app-release.apk` from the releases, and you're good to go!
-
-### Features
-
-#### Renaming the Airpods
-When you rename the Airpods using the app, you'll need to re-pair it with your phone. Currently, user-level apps cannot directly rename a Bluetooth device. After re-pairing, your phone will display the updated name!
-
-#### Noise Control Modes
-- Active Noise Cancellation (ANC): Blocks external sounds using microphones and advanced algorithms for an immersive audio experience; ideal for noisy environments.
-- Transparency Mode: Allows external sounds to blend with audio for situational awareness; best for environments where you need to stay alert.
-- Off Mode: Disables noise control for a natural listening experience, conserving battery in quiet settings.
-- Adaptive Transparency: Dynamically reduces sudden loud noises while maintaining environmental awareness, adjusting seamlessly to fluctuating noise levels.
-
-#### Conversational Awareness
-Automatically lowers audio volume and enhances voices when you start speaking, making it easier to engage in conversations without removing your AirPods.
-
-#### Automatic Ear Detection
- Recognizes when the AirPods are in your ears to automatically play or pause audio and adjust functionality accordingly.
-
-#### Planned Features
-Quick Tile to toggle Conversational Awareness and to switch Noise Control modes, and Battery Widget (App and AndroidSystemIntelligence)/Notification coming soon!!
-
-
-### Screenshots of the app
+#### Screenshots
 
 | | | |
 |-------------------|-------------------|-------------------|
 | ![Settings 1](/android/imgs/settings-1.png) | ![Settings 2](/android/imgs/settings-2.png) | ![Debug Screen](/android/imgs/debug.png) |
-| ![Battery Notification](/android/imgs/notification.png) | ![Popup](/android/imgs/popup.png) | ![QuickSetting Tile](/android/imgs/qstile.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](/android/imgs/customizations.png) |
+| ![audio-popup](/android/imgs/audio-connected-island.png) | | |
+
+#### Root Requirement
+
+> [!CAUTION]
+> **You must have a rooted device to use LibrePods on Android.** This is due to a [bug in the Android Bluetooth stack](https://issuetracker.google.com/issues/371713238). Please upvote the issue by clicking the '+1' icon on the IssueTracker page.
+> 
+> There are **no exceptions** to the root requirement until Google merges the fix.
+
+#### Installation Methods
+
+##### Method 1: Xposed Module (Recommended)
+This method is less intrusive and should be tried first:
+
+1. Install LSPosed, or another Xposed provider on your rooted device
+2. Download the LibrePods app from the releases section, and install it.
+3. Enable the Xposed module for the bluetooth app in your Xposed manager
+4. Follow the instructions in the app to set up the module.
+5. Open the app and connect your AirPods
+
+##### Method 2: Root Module (Backup Option)
+If the Xposed method doesn't work for you:
+
+1. Download the `btl2capfix.zip` module from the releases section
+2. Install it using your preferred root manager (KernelSU, Apatch, or Magisk).
+3. Reboot your device
+4. Connect your AirPods
+
+##### Method 3: Patching it yourself
+If you prefer to patch the Bluetooth stack yourself, follow these steps:
+
+1. Look for the library in use by running `lsof | grep libbluetooth`
+2. Find the library path (e.g., `/system/lib64/libbluetooth_jni.so`)
+3. Find the `l2c_fcr_chk_chan_modes` function in the library
+4. Patch the function to always return `1` (true)
+5. Repack the library and push it back to the device. You can do this by creating a root module yourself.
+6. Reboot your device
+
+If you're unfamiliar with these steps, search for tutorials online or ask in Android rooting communities.
+
+#### 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, louds 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.
+
+## Development Resources
+
+For developers interested in the protocol details, check out the [AAP Definitions](/AAP%20Definitions.md) documentation.
+
+## CrossDevice Stuff
+
+> [!IMPORTANT]
+> This feature is still in early development and might not work as expected. No support is provided for this feature yet.
+
+### Features in Development
+
+- **Battery Status Sync**: Get battery status on any device when you connect your AirPods to one of them
+- **Cross-device Controls**: Control your AirPods from either device when connected to one
+- **Automatic Device Switching**: Seamlessly switch between Linux and Android devices based on active audio sources
+
+Check out the demo below:
+
+https://github.com/user-attachments/assets/d08f8a51-cd52-458b-8e55-9b44f4d5f3ab
+
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=kavishdevar/librepods&type=Date)](https://star-history.com/#kavishdevar/librepods&Date)
+
 # 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.
+it under the terms of the GNU Affero General Public License as published
+by the Free Software Foundation, either version 3 of the License.
 
 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.
+GNU Affero General Public License for more details.
 
-You should have received a copy of the GNU General Public License
+You should have received a copy of the GNU Affero General Public License
 along with this program over [here](/LICENSE). If not, see <https://www.gnu.org/licenses/>.

android/app/build.gradle.kts

@@ -6,17 +6,15 @@ plugins {
 }
 
 android {
-    namespace = "me.kavishdevar.aln"
+    namespace = "me.kavishdevar.librepods"
     compileSdk = 35
 
     defaultConfig {
-        applicationId = "me.kavishdevar.aln"
+        applicationId = "me.kavishdevar.librepods"
         minSdk = 28
         targetSdk = 35
-        versionCode = 1
-        versionName = "0.0.2"
-
-        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        versionCode = 7
+        versionName = "0.1.0-rc.4"
     }
 
     buildTypes {
@@ -39,6 +37,12 @@ android {
         compose = true
         viewBinding = true
     }
+    externalNativeBuild {
+        cmake {
+            path = file("src/main/cpp/CMakeLists.txt")
+            version = "3.22.1"
+        }
+    }
 }
 
 dependencies {
@@ -57,11 +61,6 @@ dependencies {
     implementation(libs.androidx.constraintlayout)
     implementation(libs.haze)
     implementation(libs.haze.materials)
-    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.dynamicanimation)
+    compileOnly(fileTree(mapOf("dir" to "libs", "include" to listOf("*.aar"))))
+}

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,19 +2,39 @@
 <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_CONNECTED_DEVICE" />
+    <uses-permission android:name="android.permission.INTERACT_ACROSS_USERS"
+        tools:ignore="ProtectedPermissions" />
+    <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.SYSTEM_ALERT_WINDOW" />
     <uses-permission
         android:name="android.permission.BLUETOOTH_PRIVILEGED"
         tools:ignore="ProtectedPermissions" />
-    <uses-permission
-        android:name="android.permission.BLUETOOTH_ADMIN"
-        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.WRITE_EXTERNAL_STORAGE"
+        tools:ignore="ScopedStorage" />
+
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"
+        android:maxSdkVersion="30" />
+
+    <protected-broadcast android:name="batterywidget.impl.action.update_bluetooth_data" />
 
     <application
         android:allowBackup="true"
@@ -25,11 +45,23 @@
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
-        android:theme="@style/Theme.ALN"
+        android:theme="@style/Theme.LibrePods"
+        android:description="@string/app_description"
         tools:ignore="UnusedAttribute"
         tools:targetApi="31">
         <receiver
-            android:name=".BatteryWidget"
+            android:name=".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=".widgets.BatteryWidget"
             android:exported="false">
             <intent-filter>
                 <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
@@ -44,7 +76,7 @@
             android:name=".CustomDevice"
             android:exported="true"
             android:label="@string/title_activity_custom_device"
-            android:theme="@style/Theme.ALN">
+            android:theme="@style/Theme.LibrePods">
             <intent-filter>
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
@@ -52,7 +84,7 @@
         <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" />
 
@@ -60,14 +92,23 @@
             </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" />
         <service
-            android:name=".AirPodsQSService"
+            android:name=".services.AirPodsQSService"
             android:exported="true"
             android:icon="@drawable/airpods"
             android:label="ANC Mode"
@@ -78,7 +119,7 @@
         </service>
 
         <receiver
-            android:name=".BootReceiver"
+            android:name=".receivers.BootReceiver"
             android:enabled="true"
             android:exported="true"
             android:label="@string/app_name">
@@ -87,6 +128,16 @@
                 <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,34 @@
+cmake_minimum_required(VERSION 3.22.1)
+
+project("l2c_fcr_hook")
+set(CMAKE_CXX_STANDARD 23)
+
+add_library(l2c_fcr_hook SHARED
+        l2c_fcr_hook.cpp
+
+        xz/xz_crc32.c
+        xz/xz_crc64.c
+        xz/xz_sha256.c
+        xz/xz_dec_stream.c
+        xz/xz_dec_lzma2.c
+        xz/xz_dec_bcj.c
+)
+
+target_include_directories(l2c_fcr_hook PRIVATE
+        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)

android/app/src/main/cpp/l2c_fcr_hook.cpp

@@ -0,0 +1,290 @@
+/*
+    LibrePods - AirPods liberated from Apple’s ecosystem
+    Copyright (C) 2025 LibrePods contributors
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+
+#include <android/log.h>
+#include <cstring>
+#include <string>
+#include <vector>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <elf.h>
+
+#include "l2c_fcr_hook.h"
+
+extern "C" {
+    #include "xz.h"
+}
+
+#define LOG_TAG "LibrePods"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+static HookFunType hook_func = nullptr;
+
+static uint8_t (*original_l2c_fcr_chk_chan_modes)(void*) = nullptr;
+
+uint8_t fake_l2c_fcr_chk_chan_modes(void* p_ccb) {
+    LOGI("l2c_fcr_chk_chan_modes hooked");
+    uint8_t orig = 0;
+    if (original_l2c_fcr_chk_chan_modes)
+        orig = original_l2c_fcr_chk_chan_modes(p_ccb);
+
+    LOGI("Original returned %d, forcing 1", orig);
+    return 1;
+}
+
+static bool decompressXZ(
+        const uint8_t* input,
+        size_t input_size,
+        std::vector<uint8_t>& output) {
+
+    xz_crc32_init();
+#ifdef XZ_USE_CRC64
+    xz_crc64_init();
+#endif
+
+    struct xz_dec* dec = xz_dec_init(XZ_DYNALLOC, 64U << 20);
+    if (!dec) return false;
+
+    struct xz_buf buf{};
+    buf.in = input;
+    buf.in_pos = 0;
+    buf.in_size = input_size;
+
+    output.resize(input_size * 8);
+
+    buf.out = output.data();
+    buf.out_pos = 0;
+    buf.out_size = output.size();
+
+    while (true) {
+        enum xz_ret ret = xz_dec_run(dec, &buf);
+
+        if (ret == XZ_STREAM_END)
+            break;
+
+        if (ret != XZ_OK) {
+            xz_dec_end(dec);
+            return false;
+        }
+
+        if (buf.out_pos == buf.out_size) {
+            size_t old = output.size();
+            output.resize(old * 2);
+            buf.out = output.data();
+            buf.out_size = output.size();
+        }
+    }
+
+    output.resize(buf.out_pos);
+    xz_dec_end(dec);
+    return true;
+}
+
+static bool getLibraryPath(const char* name, std::string& out) {
+    FILE* fp = fopen("/proc/self/maps", "r");
+    if (!fp) return false;
+
+    char line[1024];
+
+    while (fgets(line, sizeof(line), fp)) {
+        if (strstr(line, name)) {
+            char* path = strchr(line, '/');
+            if (path) {
+                out = path;
+                out.erase(out.find('\n'));
+                fclose(fp);
+                return true;
+            }
+        }
+    }
+
+    fclose(fp);
+    return false;
+}
+
+static uintptr_t getModuleBase(const char* name) {
+    FILE* fp = fopen("/proc/self/maps", "r");
+    if (!fp) return 0;
+
+    char line[1024];
+    uintptr_t base = 0;
+
+    while (fgets(line, sizeof(line), fp)) {
+        if (strstr(line, name)) {
+            base = strtoull(line, nullptr, 16);
+            break;
+        }
+    }
+
+    fclose(fp);
+    return base;
+}
+
+static uint64_t findSymbolOffset(
+        const std::vector<uint8_t>& elf,
+        const char* symbol_substring) {
+
+    auto* eh = reinterpret_cast<const Elf64_Ehdr*>(elf.data());
+    auto* shdr = reinterpret_cast<const Elf64_Shdr*>(
+            elf.data() + eh->e_shoff);
+
+    const char* shstr =
+            reinterpret_cast<const char*>(
+                    elf.data() + shdr[eh->e_shstrndx].sh_offset);
+
+    const Elf64_Shdr* symtab = nullptr;
+    const Elf64_Shdr* strtab = nullptr;
+
+    for (int i = 0; i < eh->e_shnum; ++i) {
+        const char* secname = shstr + shdr[i].sh_name;
+        if (!strcmp(secname, ".symtab"))
+            symtab = &shdr[i];
+        if (!strcmp(secname, ".strtab"))
+            strtab = &shdr[i];
+    }
+
+    if (!symtab || !strtab)
+        return 0;
+
+    auto* symbols = reinterpret_cast<const Elf64_Sym*>(
+            elf.data() + symtab->sh_offset);
+
+    const char* strings =
+            reinterpret_cast<const char*>(
+                    elf.data() + strtab->sh_offset);
+
+    size_t count = symtab->sh_size / sizeof(Elf64_Sym);
+
+    for (size_t i = 0; i < count; ++i) {
+        const char* name = strings + symbols[i].st_name;
+
+        if (strstr(name, symbol_substring) &&
+            ELF64_ST_TYPE(symbols[i].st_info) == STT_FUNC) {
+
+            LOGI("Resolved %s at 0x%lx",
+                 name,
+                 (unsigned long)symbols[i].st_value);
+
+            return symbols[i].st_value;
+        }
+    }
+
+    return 0;
+}
+
+static bool hookLibrary(const char* libname) {
+
+    if (!hook_func) {
+        LOGE("hook_func not initialized");
+        return false;
+    }
+
+    std::string path;
+    if (!getLibraryPath(libname, path)) {
+        LOGE("Failed to locate %s", libname);
+        return false;
+    }
+
+    int fd = open(path.c_str(), O_RDONLY);
+    if (fd < 0) return false;
+
+    struct stat st{};
+    if (fstat(fd, &st) != 0) {
+        close(fd);
+        return false;
+    }
+
+    std::vector<uint8_t> file(st.st_size);
+    read(fd, file.data(), st.st_size);
+    close(fd);
+
+    auto* eh = reinterpret_cast<Elf64_Ehdr*>(file.data());
+    auto* shdr = reinterpret_cast<Elf64_Shdr*>(
+            file.data() + eh->e_shoff);
+
+    const char* shstr =
+            reinterpret_cast<const char*>(
+                    file.data() + shdr[eh->e_shstrndx].sh_offset);
+
+    for (int i = 0; i < eh->e_shnum; ++i) {
+
+        if (!strcmp(shstr + shdr[i].sh_name, ".gnu_debugdata")) {
+
+            std::vector<uint8_t> compressed(
+                    file.begin() + shdr[i].sh_offset,
+                    file.begin() + shdr[i].sh_offset + shdr[i].sh_size);
+
+            std::vector<uint8_t> decompressed;
+
+            if (!decompressXZ(
+                    compressed.data(),
+                    compressed.size(),
+                    decompressed))
+                return false;
+
+            uintptr_t base = getModuleBase(libname);
+            if (!base) return false;
+
+            uint64_t chk_offset =
+                    findSymbolOffset(decompressed,
+                                     "l2c_fcr_chk_chan_modes");
+
+            if (chk_offset) {
+                void* target =
+                        reinterpret_cast<void*>(base + chk_offset);
+
+                hook_func(target,
+                          (void*)fake_l2c_fcr_chk_chan_modes,
+                          (void**)&original_l2c_fcr_chk_chan_modes);
+
+                LOGI("Hooked l2c_fcr_chk_chan_modes");
+            }
+
+            return true;
+        }
+    }
+
+    return false;
+}
+
+static void on_library_loaded(const char* name, void*) {
+
+    if (strstr(name, "libbluetooth_jni.so")) {
+        LOGI("Bluetooth JNI loaded");
+        hookLibrary("libbluetooth_jni.so");
+    }
+
+    if (strstr(name, "libbluetooth_qti.so")) {
+        LOGI("Bluetooth QTI loaded");
+        hookLibrary("libbluetooth_qti.so");
+    }
+}
+
+extern "C"
+[[gnu::visibility("default")]]
+[[gnu::used]]
+NativeOnModuleLoaded native_init(const NativeAPIEntries* entries) {
+
+    LOGI("LibrePods initialized");
+
+    hook_func = (HookFunType)entries->hook_func;
+
+    return on_library_loaded;
+}

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

@@ -0,0 +1,32 @@
+/*
+    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/>.
+*/
+
+#pragma once
+#include <cstdint>
+
+typedef int (*HookFunType)(void *func, void *replace, void **backup);
+
+typedef void (*NativeOnModuleLoaded)(const char *name, void *handle);
+
+typedef struct {
+    uint32_t version;
+    void* hook_func;
+    void* unhook_func;
+} NativeAPIEntries;
+
+typedef NativeOnModuleLoaded (*NativeInit)(const NativeAPIEntries *entries);

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

@@ -0,0 +1,448 @@
+/* SPDX-License-Identifier: 0BSD */
+
+/*
+ * XZ decompressor
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <https://7-zip.org/>
+ */
+
+#ifndef XZ_H
+#define XZ_H
+
+#ifdef __KERNEL__
+#	include <linux/stddef.h>
+#	include <linux/types.h>
+#else
+#	include <stddef.h>
+#	include <stdint.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* "#define XZ_EXTERN static" can be used to make extern functions static. */
+#ifndef XZ_EXTERN
+#	define XZ_EXTERN extern
+#endif
+
+/**
+ * enum xz_mode - Operation mode
+ *
+ * @XZ_SINGLE:              Single-call mode. This uses less RAM than
+ *                          multi-call modes, because the LZMA2
+ *                          dictionary doesn't need to be allocated as
+ *                          part of the decoder state. All required data
+ *                          structures are allocated at initialization,
+ *                          so xz_dec_run() cannot return XZ_MEM_ERROR.
+ * @XZ_PREALLOC:            Multi-call mode with preallocated LZMA2
+ *                          dictionary buffer. All data structures are
+ *                          allocated at initialization, so xz_dec_run()
+ *                          cannot return XZ_MEM_ERROR.
+ * @XZ_DYNALLOC:            Multi-call mode. The LZMA2 dictionary is
+ *                          allocated once the required size has been
+ *                          parsed from the stream headers. If the
+ *                          allocation fails, xz_dec_run() will return
+ *                          XZ_MEM_ERROR.
+ *
+ * It is possible to enable support only for a subset of the above
+ * modes at compile time by defining XZ_DEC_SINGLE, XZ_DEC_PREALLOC,
+ * or XZ_DEC_DYNALLOC. The xz_dec kernel module is always compiled
+ * with support for all operation modes, but the preboot code may
+ * be built with fewer features to minimize code size.
+ */
+enum xz_mode {
+	XZ_SINGLE,
+	XZ_PREALLOC,
+	XZ_DYNALLOC
+};
+
+/**
+ * enum xz_ret - Return codes
+ * @XZ_OK:                  Everything is OK so far. More input or more
+ *                          output space is required to continue. This
+ *                          return code is possible only in multi-call mode
+ *                          (XZ_PREALLOC or XZ_DYNALLOC).
+ * @XZ_STREAM_END:          Operation finished successfully.
+ * @XZ_UNSUPPORTED_CHECK:   Integrity check type is not supported. Decoding
+ *                          is still possible in multi-call mode by simply
+ *                          calling xz_dec_run() again.
+ *                          Note that this return value is used only if
+ *                          XZ_DEC_ANY_CHECK was defined at build time,
+ *                          which is not used in the kernel. Unsupported
+ *                          check types return XZ_OPTIONS_ERROR if
+ *                          XZ_DEC_ANY_CHECK was not defined at build time.
+ * @XZ_MEM_ERROR:           Allocating memory failed. This return code is
+ *                          possible only if the decoder was initialized
+ *                          with XZ_DYNALLOC. The amount of memory that was
+ *                          tried to be allocated was no more than the
+ *                          dict_max argument given to xz_dec_init().
+ * @XZ_MEMLIMIT_ERROR:      A bigger LZMA2 dictionary would be needed than
+ *                          allowed by the dict_max argument given to
+ *                          xz_dec_init(). This return value is possible
+ *                          only in multi-call mode (XZ_PREALLOC or
+ *                          XZ_DYNALLOC); the single-call mode (XZ_SINGLE)
+ *                          ignores the dict_max argument.
+ * @XZ_FORMAT_ERROR:        File format was not recognized (wrong magic
+ *                          bytes).
+ * @XZ_OPTIONS_ERROR:       This implementation doesn't support the requested
+ *                          compression options. In the decoder this means
+ *                          that the header CRC32 matches, but the header
+ *                          itself specifies something that we don't support.
+ * @XZ_DATA_ERROR:          Compressed data is corrupt.
+ * @XZ_BUF_ERROR:           Cannot make any progress. Details are slightly
+ *                          different between multi-call and single-call
+ *                          mode; more information below.
+ *
+ * In multi-call mode, XZ_BUF_ERROR is returned when two consecutive calls
+ * to XZ code cannot consume any input and cannot produce any new output.
+ * This happens when there is no new input available, or the output buffer
+ * is full while at least one output byte is still pending. Assuming your
+ * code is not buggy, you can get this error only when decoding a compressed
+ * stream that is truncated or otherwise corrupt.
+ *
+ * In single-call mode, XZ_BUF_ERROR is returned only when the output buffer
+ * is too small or the compressed input is corrupt in a way that makes the
+ * decoder produce more output than the caller expected. When it is
+ * (relatively) clear that the compressed input is truncated, XZ_DATA_ERROR
+ * is used instead of XZ_BUF_ERROR.
+ */
+enum xz_ret {
+	XZ_OK,
+	XZ_STREAM_END,
+	XZ_UNSUPPORTED_CHECK,
+	XZ_MEM_ERROR,
+	XZ_MEMLIMIT_ERROR,
+	XZ_FORMAT_ERROR,
+	XZ_OPTIONS_ERROR,
+	XZ_DATA_ERROR,
+	XZ_BUF_ERROR
+};
+
+/**
+ * struct xz_buf - Passing input and output buffers to XZ code
+ * @in:         Beginning of the input buffer. This may be NULL if and only
+ *              if in_pos is equal to in_size.
+ * @in_pos:     Current position in the input buffer. This must not exceed
+ *              in_size.
+ * @in_size:    Size of the input buffer
+ * @out:        Beginning of the output buffer. This may be NULL if and only
+ *              if out_pos is equal to out_size.
+ * @out_pos:    Current position in the output buffer. This must not exceed
+ *              out_size.
+ * @out_size:   Size of the output buffer
+ *
+ * Only the contents of the output buffer from out[out_pos] onward, and
+ * the variables in_pos and out_pos are modified by the XZ code.
+ */
+struct xz_buf {
+	const uint8_t *in;
+	size_t in_pos;
+	size_t in_size;
+
+	uint8_t *out;
+	size_t out_pos;
+	size_t out_size;
+};
+
+/*
+ * struct xz_dec - Opaque type to hold the XZ decoder state
+ */
+struct xz_dec;
+
+/**
+ * xz_dec_init() - Allocate and initialize a XZ decoder state
+ * @mode:       Operation mode
+ * @dict_max:   Maximum size of the LZMA2 dictionary (history buffer) for
+ *              multi-call decoding. This is ignored in single-call mode
+ *              (mode == XZ_SINGLE). LZMA2 dictionary is always 2^n bytes
+ *              or 2^n + 2^(n-1) bytes (the latter sizes are less common
+ *              in practice), so other values for dict_max don't make sense.
+ *              In the kernel, dictionary sizes of 64 KiB, 128 KiB, 256 KiB,
+ *              512 KiB, and 1 MiB are probably the only reasonable values,
+ *              except for kernel and initramfs images where a bigger
+ *              dictionary can be fine and useful.
+ *
+ * Single-call mode (XZ_SINGLE): xz_dec_run() decodes the whole stream at
+ * once. The caller must provide enough output space or the decoding will
+ * fail. The output space is used as the dictionary buffer, which is why
+ * there is no need to allocate the dictionary as part of the decoder's
+ * internal state.
+ *
+ * Because the output buffer is used as the workspace, streams encoded using
+ * a big dictionary are not a problem in single-call mode. It is enough that
+ * the output buffer is big enough to hold the actual uncompressed data; it
+ * can be smaller than the dictionary size stored in the stream headers.
+ *
+ * Multi-call mode with preallocated dictionary (XZ_PREALLOC): dict_max bytes
+ * of memory is preallocated for the LZMA2 dictionary. This way there is no
+ * risk that xz_dec_run() could run out of memory, since xz_dec_run() will
+ * never allocate any memory. Instead, if the preallocated dictionary is too
+ * small for decoding the given input stream, xz_dec_run() will return
+ * XZ_MEMLIMIT_ERROR. Thus, it is important to know what kind of data will be
+ * decoded to avoid allocating excessive amount of memory for the dictionary.
+ *
+ * Multi-call mode with dynamically allocated dictionary (XZ_DYNALLOC):
+ * dict_max specifies the maximum allowed dictionary size that xz_dec_run()
+ * may allocate once it has parsed the dictionary size from the stream
+ * headers. This way excessive allocations can be avoided while still
+ * limiting the maximum memory usage to a sane value to prevent running the
+ * system out of memory when decompressing streams from untrusted sources.
+ *
+ * On success, xz_dec_init() returns a pointer to struct xz_dec, which is
+ * ready to be used with xz_dec_run(). If memory allocation fails,
+ * xz_dec_init() returns NULL.
+ */
+XZ_EXTERN struct xz_dec *xz_dec_init(enum xz_mode mode, uint32_t dict_max);
+
+/**
+ * xz_dec_run() - Run the XZ decoder for a single XZ stream
+ * @s:          Decoder state allocated using xz_dec_init()
+ * @b:          Input and output buffers
+ *
+ * The possible return values depend on build options and operation mode.
+ * See enum xz_ret for details.
+ *
+ * Note that if an error occurs in single-call mode (return value is not
+ * XZ_STREAM_END), b->in_pos and b->out_pos are not modified and the
+ * contents of the output buffer from b->out[b->out_pos] onward are
+ * undefined. This is true even after XZ_BUF_ERROR, because with some filter
+ * chains, there may be a second pass over the output buffer, and this pass
+ * cannot be properly done if the output buffer is truncated. Thus, you
+ * cannot give the single-call decoder a too small buffer and then expect to
+ * get that amount valid data from the beginning of the stream. You must use
+ * the multi-call decoder if you don't want to uncompress the whole stream.
+ *
+ * Use xz_dec_run() when XZ data is stored inside some other file format.
+ * The decoding will stop after one XZ stream has been decompressed. To
+ * decompress regular .xz files which might have multiple concatenated
+ * streams, use xz_dec_catrun() instead.
+ */
+XZ_EXTERN enum xz_ret xz_dec_run(struct xz_dec *s, struct xz_buf *b);
+
+/**
+ * xz_dec_catrun() - Run the XZ decoder with support for concatenated streams
+ * @s:          Decoder state allocated using xz_dec_init()
+ * @b:          Input and output buffers
+ * @finish:     This is an int instead of bool to avoid requiring stdbool.h.
+ *              As long as more input might be coming, finish must be false.
+ *              When the caller knows that it has provided all the input to
+ *              the decoder (some possibly still in b->in), it must set finish
+ *              to true. Only when finish is true can this function return
+ *              XZ_STREAM_END to indicate successful decompression of the
+ *              file. In single-call mode (XZ_SINGLE) finish is assumed to
+ *              always be true; the caller-provided value is ignored.
+ *
+ * This is like xz_dec_run() except that this makes it easy to decode .xz
+ * files with multiple streams (multiple .xz files concatenated as is).
+ * The rarely-used Stream Padding feature is supported too, that is, there
+ * can be null bytes after or between the streams. The number of null bytes
+ * must be a multiple of four.
+ *
+ * When finish is false and b->in_pos == b->in_size, it is possible that
+ * XZ_BUF_ERROR isn't returned even when no progress is possible (XZ_OK is
+ * returned instead). This shouldn't matter because in this situation a
+ * reasonable caller will attempt to provide more input or set finish to
+ * true for the next xz_dec_catrun() call anyway.
+ *
+ * For any struct xz_dec that has been initialized for multi-call mode:
+ * Once decoding has been started with xz_dec_run() or xz_dec_catrun(),
+ * the same function must be used until xz_dec_reset() or xz_dec_end().
+ * Switching between the two decoding functions without resetting results
+ * in undefined behavior.
+ *
+ * xz_dec_catrun() is only available if XZ_DEC_CONCATENATED was defined
+ * at compile time.
+ */
+XZ_EXTERN enum xz_ret xz_dec_catrun(struct xz_dec *s, struct xz_buf *b,
+				    int finish);
+
+/**
+ * xz_dec_reset() - Reset an already allocated decoder state
+ * @s:          Decoder state allocated using xz_dec_init()
+ *
+ * This function can be used to reset the multi-call decoder state without
+ * freeing and reallocating memory with xz_dec_end() and xz_dec_init().
+ *
+ * In single-call mode, xz_dec_reset() is always called in the beginning of
+ * xz_dec_run(). Thus, explicit call to xz_dec_reset() is useful only in
+ * multi-call mode.
+ */
+XZ_EXTERN void xz_dec_reset(struct xz_dec *s);
+
+/**
+ * xz_dec_end() - Free the memory allocated for the decoder state
+ * @s:          Decoder state allocated using xz_dec_init(). If s is NULL,
+ *              this function does nothing.
+ */
+XZ_EXTERN void xz_dec_end(struct xz_dec *s);
+
+/**
+ * DOC: MicroLZMA decompressor
+ *
+ * This MicroLZMA header format was created for use in EROFS but may be used
+ * by others too. **In most cases one needs the XZ APIs above instead.**
+ *
+ * The compressed format supported by this decoder is a raw LZMA stream
+ * whose first byte (always 0x00) has been replaced with bitwise-negation
+ * of the LZMA properties (lc/lp/pb) byte. For example, if lc/lp/pb is
+ * 3/0/2, the first byte is 0xA2. This way the first byte can never be 0x00.
+ * Just like with LZMA2, lc + lp <= 4 must be true. The LZMA end-of-stream
+ * marker must not be used. The unused values are reserved for future use.
+ */
+
+/*
+ * struct xz_dec_microlzma - Opaque type to hold the MicroLZMA decoder state
+ */
+struct xz_dec_microlzma;
+
+/**
+ * xz_dec_microlzma_alloc() - Allocate memory for the MicroLZMA decoder
+ * @mode:       XZ_SINGLE or XZ_PREALLOC
+ * @dict_size:  LZMA dictionary size. This must be at least 4 KiB and
+ *              at most 3 GiB.
+ *
+ * In contrast to xz_dec_init(), this function only allocates the memory
+ * and remembers the dictionary size. xz_dec_microlzma_reset() must be used
+ * before calling xz_dec_microlzma_run().
+ *
+ * The amount of allocated memory is a little less than 30 KiB with XZ_SINGLE.
+ * With XZ_PREALLOC also a dictionary buffer of dict_size bytes is allocated.
+ *
+ * On success, xz_dec_microlzma_alloc() returns a pointer to
+ * struct xz_dec_microlzma. If memory allocation fails or
+ * dict_size is invalid, NULL is returned.
+ */
+XZ_EXTERN struct xz_dec_microlzma *xz_dec_microlzma_alloc(enum xz_mode mode,
+							  uint32_t dict_size);
+
+/**
+ * xz_dec_microlzma_reset() - Reset the MicroLZMA decoder state
+ * @s:          Decoder state allocated using xz_dec_microlzma_alloc()
+ * @comp_size:  Compressed size of the input stream
+ * @uncomp_size:  Uncompressed size of the input stream. A value smaller
+ *              than the real uncompressed size of the input stream can
+ *              be specified if uncomp_size_is_exact is set to false.
+ *              uncomp_size can never be set to a value larger than the
+ *              expected real uncompressed size because it would eventually
+ *              result in XZ_DATA_ERROR.
+ * @uncomp_size_is_exact:  This is an int instead of bool to avoid
+ *              requiring stdbool.h. This should normally be set to true.
+ *              When this is set to false, error detection is weaker.
+ */
+XZ_EXTERN void xz_dec_microlzma_reset(struct xz_dec_microlzma *s,
+				      uint32_t comp_size, uint32_t uncomp_size,
+				      int uncomp_size_is_exact);
+
+/**
+ * xz_dec_microlzma_run() - Run the MicroLZMA decoder
+ * @s:          Decoder state initialized using xz_dec_microlzma_reset()
+ * @b:          Input and output buffers
+ *
+ * This works similarly to xz_dec_run() with a few important differences.
+ * Only the differences are documented here.
+ *
+ * The only possible return values are XZ_OK, XZ_STREAM_END, and
+ * XZ_DATA_ERROR. This function cannot return XZ_BUF_ERROR: if no progress
+ * is possible due to lack of input data or output space, this function will
+ * keep returning XZ_OK. Thus, the calling code must be written so that it
+ * will eventually provide input and output space matching (or exceeding)
+ * comp_size and uncomp_size arguments given to xz_dec_microlzma_reset().
+ * If the caller cannot do this (for example, if the input file is truncated
+ * or otherwise corrupt), the caller must detect this error by itself to
+ * avoid an infinite loop.
+ *
+ * If the compressed data seems to be corrupt, XZ_DATA_ERROR is returned.
+ * This can happen also when incorrect dictionary, uncompressed, or
+ * compressed sizes have been specified.
+ *
+ * With XZ_PREALLOC only: As an extra feature, b->out may be NULL to skip over
+ * uncompressed data. This way the caller doesn't need to provide a temporary
+ * output buffer for the bytes that will be ignored.
+ *
+ * With XZ_SINGLE only: In contrast to xz_dec_run(), the return value XZ_OK
+ * is also possible and thus XZ_SINGLE is actually a limited multi-call mode.
+ * After XZ_OK the bytes decoded so far may be read from the output buffer.
+ * It is possible to continue decoding but the variables b->out and b->out_pos
+ * MUST NOT be changed by the caller. Increasing the value of b->out_size is
+ * allowed to make more output space available; one doesn't need to provide
+ * space for the whole uncompressed data on the first call. The input buffer
+ * may be changed normally like with XZ_PREALLOC. This way input data can be
+ * provided from non-contiguous memory.
+ */
+XZ_EXTERN enum xz_ret xz_dec_microlzma_run(struct xz_dec_microlzma *s,
+					   struct xz_buf *b);
+
+/**
+ * xz_dec_microlzma_end() - Free the memory allocated for the decoder state
+ * @s:          Decoder state allocated using xz_dec_microlzma_alloc().
+ *              If s is NULL, this function does nothing.
+ */
+XZ_EXTERN void xz_dec_microlzma_end(struct xz_dec_microlzma *s);
+
+/*
+ * Standalone build (userspace build or in-kernel build for boot time use)
+ * needs a CRC32 implementation. For normal in-kernel use, kernel's own
+ * CRC32 module is used instead, and users of this module don't need to
+ * care about the functions below.
+ */
+#ifndef XZ_INTERNAL_CRC32
+#	ifdef __KERNEL__
+#		define XZ_INTERNAL_CRC32 0
+#	else
+#		define XZ_INTERNAL_CRC32 1
+#	endif
+#endif
+
+/*
+ * If CRC64 support has been enabled with XZ_USE_CRC64, a CRC64
+ * implementation is needed too.
+ */
+#ifndef XZ_USE_CRC64
+#	undef XZ_INTERNAL_CRC64
+#	define XZ_INTERNAL_CRC64 0
+#endif
+#ifndef XZ_INTERNAL_CRC64
+#	ifdef __KERNEL__
+#		error Using CRC64 in the kernel has not been implemented.
+#	else
+#		define XZ_INTERNAL_CRC64 1
+#	endif
+#endif
+
+#if XZ_INTERNAL_CRC32
+/*
+ * This must be called before any other xz_* function to initialize
+ * the CRC32 lookup table.
+ */
+XZ_EXTERN void xz_crc32_init(void);
+
+/*
+ * Update CRC32 value using the polynomial from IEEE-802.3. To start a new
+ * calculation, the third argument must be zero. To continue the calculation,
+ * the previously returned value is passed as the third argument.
+ */
+XZ_EXTERN uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc);
+#endif
+
+#if XZ_INTERNAL_CRC64
+/*
+ * This must be called before any other xz_* function (except xz_crc32_init())
+ * to initialize the CRC64 lookup table.
+ */
+XZ_EXTERN void xz_crc64_init(void);
+
+/*
+ * Update CRC64 value using the polynomial from ECMA-182. To start a new
+ * calculation, the third argument must be zero. To continue the calculation,
+ * the previously returned value is passed as the third argument.
+ */
+XZ_EXTERN uint64_t xz_crc64(const uint8_t *buf, size_t size, uint64_t crc);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

android/app/src/main/cpp/xz/xz_config.h

@@ -0,0 +1,138 @@
+/* SPDX-License-Identifier: 0BSD */
+
+/*
+ * Private includes and definitions for userspace use of XZ Embedded
+ *
+ * Author: Lasse Collin <lasse.collin@tukaani.org>
+ */
+
+#ifndef XZ_CONFIG_H
+#define XZ_CONFIG_H
+
+/* Uncomment to enable building of xz_dec_catrun(). */
+/* #define XZ_DEC_CONCATENATED */
+
+/* Uncomment to enable CRC64 support. */
+/* #define XZ_USE_CRC64 */
+
+/* Uncomment as needed to enable BCJ filter decoders. */
+/* #define XZ_DEC_X86 */
+/* #define XZ_DEC_ARM */
+/* #define XZ_DEC_ARMTHUMB */
+/* #define XZ_DEC_ARM64 */
+/* #define XZ_DEC_RISCV */
+/* #define XZ_DEC_POWERPC */
+/* #define XZ_DEC_IA64 */
+/* #define XZ_DEC_SPARC */
+
+/*
+ * Visual Studio 2013 update 2 supports only __inline, not inline.
+ * MSVC v19.0 / VS 2015 and newer support both.
+ */
+#if defined(_MSC_VER) && _MSC_VER < 1900 && !defined(inline)
+#	define inline __inline
+#endif
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "xz.h"
+
+#define kmalloc(size, flags) malloc(size)
+#define kfree(ptr) free(ptr)
+#define vmalloc(size) malloc(size)
+#define vfree(ptr) free(ptr)
+
+#define memeq(a, b, size) (memcmp(a, b, size) == 0)
+#define memzero(buf, size) memset(buf, 0, size)
+
+#ifndef min
+#	define min(x, y) ((x) < (y) ? (x) : (y))
+#endif
+#define min_t(type, x, y) min(x, y)
+
+#ifndef fallthrough
+#	if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 202311
+#		define fallthrough [[fallthrough]]
+#	elif (defined(__GNUC__) && __GNUC__ >= 7) \
+			|| (defined(__clang_major__) && __clang_major__ >= 10)
+#		define fallthrough __attribute__((__fallthrough__))
+#	else
+#		define fallthrough do {} while (0)
+#	endif
+#endif
+
+/*
+ * Some functions have been marked with __always_inline to keep the
+ * performance reasonable even when the compiler is optimizing for
+ * small code size. You may be able to save a few bytes by #defining
+ * __always_inline to plain inline, but don't complain if the code
+ * becomes slow.
+ *
+ * NOTE: System headers on GNU/Linux may #define this macro already,
+ * so if you want to change it, you need to #undef it first.
+ */
+#ifndef __always_inline
+#	ifdef __GNUC__
+#		define __always_inline \
+			inline __attribute__((__always_inline__))
+#	else
+#		define __always_inline inline
+#	endif
+#endif
+
+/* Inline functions to access unaligned unsigned 32-bit integers */
+#ifndef get_unaligned_le32
+static inline uint32_t get_unaligned_le32(const uint8_t *buf)
+{
+	return (uint32_t)buf[0]
+			| ((uint32_t)buf[1] << 8)
+			| ((uint32_t)buf[2] << 16)
+			| ((uint32_t)buf[3] << 24);
+}
+#endif
+
+#ifndef get_unaligned_be32
+static inline uint32_t get_unaligned_be32(const uint8_t *buf)
+{
+	return (uint32_t)((uint32_t)buf[0] << 24)
+			| ((uint32_t)buf[1] << 16)
+			| ((uint32_t)buf[2] << 8)
+			| (uint32_t)buf[3];
+}
+#endif
+
+#ifndef put_unaligned_le32
+static inline void put_unaligned_le32(uint32_t val, uint8_t *buf)
+{
+	buf[0] = (uint8_t)val;
+	buf[1] = (uint8_t)(val >> 8);
+	buf[2] = (uint8_t)(val >> 16);
+	buf[3] = (uint8_t)(val >> 24);
+}
+#endif
+
+#ifndef put_unaligned_be32
+static inline void put_unaligned_be32(uint32_t val, uint8_t *buf)
+{
+	buf[0] = (uint8_t)(val >> 24);
+	buf[1] = (uint8_t)(val >> 16);
+	buf[2] = (uint8_t)(val >> 8);
+	buf[3] = (uint8_t)val;
+}
+#endif
+
+/*
+ * To keep things simpler, use the generic unaligned methods also for
+ * aligned access. The only place where performance could matter is
+ * SHA-256 but files using SHA-256 aren't common.
+ */
+#ifndef get_le32
+#	define get_le32 get_unaligned_le32
+#endif
+#ifndef get_be32
+#	define get_be32 get_unaligned_be32
+#endif
+
+#endif

android/app/src/main/cpp/xz/xz_crc32.c

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: 0BSD
+
+/*
+ * CRC32 using the polynomial from IEEE-802.3
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <https://7-zip.org/>
+ */
+
+/*
+ * This is not the fastest implementation, but it is pretty compact.
+ * The fastest versions of xz_crc32() on modern CPUs without hardware
+ * accelerated CRC instruction are 3-5 times as fast as this version,
+ * but they are bigger and use more memory for the lookup table.
+ */
+
+#include "xz_private.h"
+
+/*
+ * STATIC_RW_DATA is used in the pre-boot environment on some architectures.
+ * See <linux/decompress/mm.h> for details.
+ */
+#ifndef STATIC_RW_DATA
+#	define STATIC_RW_DATA static
+#endif
+
+STATIC_RW_DATA uint32_t xz_crc32_table[256];
+
+XZ_EXTERN void xz_crc32_init(void)
+{
+	const uint32_t poly = 0xEDB88320;
+
+	uint32_t i;
+	uint32_t j;
+	uint32_t r;
+
+	for (i = 0; i < 256; ++i) {
+		r = i;
+		for (j = 0; j < 8; ++j)
+			r = (r >> 1) ^ (poly & ~((r & 1) - 1));
+
+		xz_crc32_table[i] = r;
+	}
+
+	return;
+}
+
+XZ_EXTERN uint32_t xz_crc32(const uint8_t *buf, size_t size, uint32_t crc)
+{
+	crc = ~crc;
+
+	while (size != 0) {
+		crc = xz_crc32_table[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8);
+		--size;
+	}
+
+	return ~crc;
+}

android/app/src/main/cpp/xz/xz_crc64.c

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: 0BSD
+
+/*
+ * CRC64 using the polynomial from ECMA-182
+ *
+ * This file is similar to xz_crc32.c. See the comments there.
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <https://7-zip.org/>
+ */
+
+#include "xz_private.h"
+
+#ifndef STATIC_RW_DATA
+#	define STATIC_RW_DATA static
+#endif
+
+STATIC_RW_DATA uint64_t xz_crc64_table[256];
+
+XZ_EXTERN void xz_crc64_init(void)
+{
+	/*
+	 * The ULL suffix is needed for -std=gnu89 compatibility
+	 * on 32-bit platforms.
+	 */
+	const uint64_t poly = 0xC96C5795D7870F42ULL;
+
+	uint32_t i;
+	uint32_t j;
+	uint64_t r;
+
+	for (i = 0; i < 256; ++i) {
+		r = i;
+		for (j = 0; j < 8; ++j)
+			r = (r >> 1) ^ (poly & ~((r & 1) - 1));
+
+		xz_crc64_table[i] = r;
+	}
+
+	return;
+}
+
+XZ_EXTERN uint64_t xz_crc64(const uint8_t *buf, size_t size, uint64_t crc)
+{
+	crc = ~crc;
+
+	while (size != 0) {
+		crc = xz_crc64_table[*buf++ ^ (crc & 0xFF)] ^ (crc >> 8);
+		--size;
+	}
+
+	return ~crc;
+}

android/app/src/main/cpp/xz/xz_dec_bcj.c

@@ -0,0 +1,738 @@
+// SPDX-License-Identifier: 0BSD
+
+/*
+ * Branch/Call/Jump (BCJ) filter decoders
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <https://7-zip.org/>
+ */
+
+#include "xz_private.h"
+
+/*
+ * The rest of the file is inside this ifdef. It makes things a little more
+ * convenient when building without support for any BCJ filters.
+ */
+#ifdef XZ_DEC_BCJ
+
+struct xz_dec_bcj {
+	/* Type of the BCJ filter being used */
+	enum {
+		BCJ_X86 = 4,        /* x86 or x86-64 */
+		BCJ_POWERPC = 5,    /* Big endian only */
+		BCJ_IA64 = 6,       /* Big or little endian */
+		BCJ_ARM = 7,        /* Little endian only */
+		BCJ_ARMTHUMB = 8,   /* Little endian only */
+		BCJ_SPARC = 9,      /* Big or little endian */
+		BCJ_ARM64 = 10,     /* AArch64 */
+		BCJ_RISCV = 11      /* RV32GQC_Zfh, RV64GQC_Zfh */
+	} type;
+
+	/*
+	 * Return value of the next filter in the chain. We need to preserve
+	 * this information across calls, because we must not call the next
+	 * filter anymore once it has returned XZ_STREAM_END.
+	 */
+	enum xz_ret ret;
+
+	/* True if we are operating in single-call mode. */
+	bool single_call;
+
+	/*
+	 * Absolute position relative to the beginning of the uncompressed
+	 * data (in a single .xz Block). We care only about the lowest 32
+	 * bits so this doesn't need to be uint64_t even with big files.
+	 */
+	uint32_t pos;
+
+	/* x86 filter state */
+	uint32_t x86_prev_mask;
+
+	/* Temporary space to hold the variables from struct xz_buf */
+	uint8_t *out;
+	size_t out_pos;
+	size_t out_size;
+
+	struct {
+		/* Amount of already filtered data in the beginning of buf */
+		size_t filtered;
+
+		/* Total amount of data currently stored in buf  */
+		size_t size;
+
+		/*
+		 * Buffer to hold a mix of filtered and unfiltered data. This
+		 * needs to be big enough to hold Alignment + 2 * Look-ahead:
+		 *
+		 * Type         Alignment   Look-ahead
+		 * x86              1           4
+		 * PowerPC          4           0
+		 * IA-64           16           0
+		 * ARM              4           0
+		 * ARM-Thumb        2           2
+		 * SPARC            4           0
+		 */
+		uint8_t buf[16];
+	} temp;
+};
+
+#ifdef XZ_DEC_X86
+/*
+ * This is used to test the most significant byte of a memory address
+ * in an x86 instruction.
+ */
+static inline int bcj_x86_test_msbyte(uint8_t b)
+{
+	return b == 0x00 || b == 0xFF;
+}
+
+static size_t bcj_x86(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	static const bool mask_to_allowed_status[8]
+		= { true, true, true, false, true, false, false, false };
+
+	static const uint8_t mask_to_bit_num[8] = { 0, 1, 2, 2, 3, 3, 3, 3 };
+
+	size_t i;
+	size_t prev_pos = (size_t)-1;
+	uint32_t prev_mask = s->x86_prev_mask;
+	uint32_t src;
+	uint32_t dest;
+	uint32_t j;
+	uint8_t b;
+
+	if (size <= 4)
+		return 0;
+
+	size -= 4;
+	for (i = 0; i < size; ++i) {
+		if ((buf[i] & 0xFE) != 0xE8)
+			continue;
+
+		prev_pos = i - prev_pos;
+		if (prev_pos > 3) {
+			prev_mask = 0;
+		} else {
+			prev_mask = (prev_mask << (prev_pos - 1)) & 7;
+			if (prev_mask != 0) {
+				b = buf[i + 4 - mask_to_bit_num[prev_mask]];
+				if (!mask_to_allowed_status[prev_mask]
+						|| bcj_x86_test_msbyte(b)) {
+					prev_pos = i;
+					prev_mask = (prev_mask << 1) | 1;
+					continue;
+				}
+			}
+		}
+
+		prev_pos = i;
+
+		if (bcj_x86_test_msbyte(buf[i + 4])) {
+			src = get_unaligned_le32(buf + i + 1);
+			while (true) {
+				dest = src - (s->pos + (uint32_t)i + 5);
+				if (prev_mask == 0)
+					break;
+
+				j = mask_to_bit_num[prev_mask] * 8;
+				b = (uint8_t)(dest >> (24 - j));
+				if (!bcj_x86_test_msbyte(b))
+					break;
+
+				src = dest ^ (((uint32_t)1 << (32 - j)) - 1);
+			}
+
+			dest &= 0x01FFFFFF;
+			dest |= (uint32_t)0 - (dest & 0x01000000);
+			put_unaligned_le32(dest, buf + i + 1);
+			i += 4;
+		} else {
+			prev_mask = (prev_mask << 1) | 1;
+		}
+	}
+
+	prev_pos = i - prev_pos;
+	s->x86_prev_mask = prev_pos > 3 ? 0 : prev_mask << (prev_pos - 1);
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_POWERPC
+static size_t bcj_powerpc(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	size_t i;
+	uint32_t instr;
+
+	size &= ~(size_t)3;
+
+	for (i = 0; i < size; i += 4) {
+		instr = get_unaligned_be32(buf + i);
+		if ((instr & 0xFC000003) == 0x48000001) {
+			instr &= 0x03FFFFFC;
+			instr -= s->pos + (uint32_t)i;
+			instr &= 0x03FFFFFC;
+			instr |= 0x48000001;
+			put_unaligned_be32(instr, buf + i);
+		}
+	}
+
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_IA64
+static size_t bcj_ia64(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	static const uint8_t branch_table[32] = {
+		0, 0, 0, 0, 0, 0, 0, 0,
+		0, 0, 0, 0, 0, 0, 0, 0,
+		4, 4, 6, 6, 0, 0, 7, 7,
+		4, 4, 0, 0, 4, 4, 0, 0
+	};
+
+	/*
+	 * The local variables take a little bit stack space, but it's less
+	 * than what LZMA2 decoder takes, so it doesn't make sense to reduce
+	 * stack usage here without doing that for the LZMA2 decoder too.
+	 */
+
+	/* Loop counters */
+	size_t i;
+	size_t j;
+
+	/* Instruction slot (0, 1, or 2) in the 128-bit instruction word */
+	uint32_t slot;
+
+	/* Bitwise offset of the instruction indicated by slot */
+	uint32_t bit_pos;
+
+	/* bit_pos split into byte and bit parts */
+	uint32_t byte_pos;
+	uint32_t bit_res;
+
+	/* Address part of an instruction */
+	uint32_t addr;
+
+	/* Mask used to detect which instructions to convert */
+	uint32_t mask;
+
+	/* 41-bit instruction stored somewhere in the lowest 48 bits */
+	uint64_t instr;
+
+	/* Instruction normalized with bit_res for easier manipulation */
+	uint64_t norm;
+
+	size &= ~(size_t)15;
+
+	for (i = 0; i < size; i += 16) {
+		mask = branch_table[buf[i] & 0x1F];
+		for (slot = 0, bit_pos = 5; slot < 3; ++slot, bit_pos += 41) {
+			if (((mask >> slot) & 1) == 0)
+				continue;
+
+			byte_pos = bit_pos >> 3;
+			bit_res = bit_pos & 7;
+			instr = 0;
+			for (j = 0; j < 6; ++j)
+				instr |= (uint64_t)(buf[i + j + byte_pos])
+						<< (8 * j);
+
+			norm = instr >> bit_res;
+
+			if (((norm >> 37) & 0x0F) == 0x05
+					&& ((norm >> 9) & 0x07) == 0) {
+				addr = (norm >> 13) & 0x0FFFFF;
+				addr |= ((uint32_t)(norm >> 36) & 1) << 20;
+				addr <<= 4;
+				addr -= s->pos + (uint32_t)i;
+				addr >>= 4;
+
+				norm &= ~((uint64_t)0x8FFFFF << 13);
+				norm |= (uint64_t)(addr & 0x0FFFFF) << 13;
+				norm |= (uint64_t)(addr & 0x100000)
+						<< (36 - 20);
+
+				instr &= (1 << bit_res) - 1;
+				instr |= norm << bit_res;
+
+				for (j = 0; j < 6; j++)
+					buf[i + j + byte_pos]
+						= (uint8_t)(instr >> (8 * j));
+			}
+		}
+	}
+
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_ARM
+static size_t bcj_arm(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	size_t i;
+	uint32_t addr;
+
+	size &= ~(size_t)3;
+
+	for (i = 0; i < size; i += 4) {
+		if (buf[i + 3] == 0xEB) {
+			addr = (uint32_t)buf[i] | ((uint32_t)buf[i + 1] << 8)
+					| ((uint32_t)buf[i + 2] << 16);
+			addr <<= 2;
+			addr -= s->pos + (uint32_t)i + 8;
+			addr >>= 2;
+			buf[i] = (uint8_t)addr;
+			buf[i + 1] = (uint8_t)(addr >> 8);
+			buf[i + 2] = (uint8_t)(addr >> 16);
+		}
+	}
+
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_ARMTHUMB
+static size_t bcj_armthumb(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	size_t i;
+	uint32_t addr;
+
+	if (size < 4)
+		return 0;
+
+	size -= 4;
+
+	for (i = 0; i <= size; i += 2) {
+		if ((buf[i + 1] & 0xF8) == 0xF0
+				&& (buf[i + 3] & 0xF8) == 0xF8) {
+			addr = (((uint32_t)buf[i + 1] & 0x07) << 19)
+					| ((uint32_t)buf[i] << 11)
+					| (((uint32_t)buf[i + 3] & 0x07) << 8)
+					| (uint32_t)buf[i + 2];
+			addr <<= 1;
+			addr -= s->pos + (uint32_t)i + 4;
+			addr >>= 1;
+			buf[i + 1] = (uint8_t)(0xF0 | ((addr >> 19) & 0x07));
+			buf[i] = (uint8_t)(addr >> 11);
+			buf[i + 3] = (uint8_t)(0xF8 | ((addr >> 8) & 0x07));
+			buf[i + 2] = (uint8_t)addr;
+			i += 2;
+		}
+	}
+
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_SPARC
+static size_t bcj_sparc(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	size_t i;
+	uint32_t instr;
+
+	size &= ~(size_t)3;
+
+	for (i = 0; i < size; i += 4) {
+		instr = get_unaligned_be32(buf + i);
+		if ((instr >> 22) == 0x100 || (instr >> 22) == 0x1FF) {
+			instr <<= 2;
+			instr -= s->pos + (uint32_t)i;
+			instr >>= 2;
+			instr = ((uint32_t)0x40000000 - (instr & 0x400000))
+					| 0x40000000 | (instr & 0x3FFFFF);
+			put_unaligned_be32(instr, buf + i);
+		}
+	}
+
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_ARM64
+static size_t bcj_arm64(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	size_t i;
+	uint32_t instr;
+	uint32_t addr;
+
+	size &= ~(size_t)3;
+
+	for (i = 0; i < size; i += 4) {
+		instr = get_unaligned_le32(buf + i);
+
+		if ((instr >> 26) == 0x25) {
+			/* BL instruction */
+			addr = instr - ((s->pos + (uint32_t)i) >> 2);
+			instr = 0x94000000 | (addr & 0x03FFFFFF);
+			put_unaligned_le32(instr, buf + i);
+
+		} else if ((instr & 0x9F000000) == 0x90000000) {
+			/* ADRP instruction */
+			addr = ((instr >> 29) & 3) | ((instr >> 3) & 0x1FFFFC);
+
+			/* Only convert values in the range +/-512 MiB. */
+			if ((addr + 0x020000) & 0x1C0000)
+				continue;
+
+			addr -= (s->pos + (uint32_t)i) >> 12;
+
+			instr &= 0x9000001F;
+			instr |= (addr & 3) << 29;
+			instr |= (addr & 0x03FFFC) << 3;
+			instr |= (0U - (addr & 0x020000)) & 0xE00000;
+
+			put_unaligned_le32(instr, buf + i);
+		}
+	}
+
+	return i;
+}
+#endif
+
+#ifdef XZ_DEC_RISCV
+static size_t bcj_riscv(struct xz_dec_bcj *s, uint8_t *buf, size_t size)
+{
+	size_t i;
+	uint32_t b1;
+	uint32_t b2;
+	uint32_t b3;
+	uint32_t instr;
+	uint32_t instr2;
+	uint32_t instr2_rs1;
+	uint32_t addr;
+
+	if (size < 8)
+		return 0;
+
+	size -= 8;
+
+	for (i = 0; i <= size; i += 2) {
+		instr = buf[i];
+
+		if (instr == 0xEF) {
+			/* JAL */
+			b1 = buf[i + 1];
+			if ((b1 & 0x0D) != 0)
+				continue;
+
+			b2 = buf[i + 2];
+			b3 = buf[i + 3];
+
+			addr = ((b1 & 0xF0) << 13) | (b2 << 9) | (b3 << 1);
+			addr -= s->pos + (uint32_t)i;
+
+			buf[i + 1] = (uint8_t)((b1 & 0x0F)
+					| ((addr >> 8) & 0xF0));
+
+			buf[i + 2] = (uint8_t)(((addr >> 16) & 0x0F)
+					| ((addr >> 7) & 0x10)
+					| ((addr << 4) & 0xE0));
+
+			buf[i + 3] = (uint8_t)(((addr >> 4) & 0x7F)
+					| ((addr >> 13) & 0x80));
+
+			i += 4 - 2;
+
+		} else if ((instr & 0x7F) == 0x17) {
+			/* AUIPC */
+			instr |= (uint32_t)buf[i + 1] << 8;
+			instr |= (uint32_t)buf[i + 2] << 16;
+			instr |= (uint32_t)buf[i + 3] << 24;
+
+			if (instr & 0xE80) {
+				/* AUIPC's rd doesn't equal x0 or x2. */
+				instr2 = get_unaligned_le32(buf + i + 4);
+
+				if (((instr << 8) ^ (instr2 - 3)) & 0xF8003) {
+					i += 6 - 2;
+					continue;
+				}
+
+				addr = (instr & 0xFFFFF000) + (instr2 >> 20);
+
+				instr = 0x17 | (2 << 7) | (instr2 << 12);
+				instr2 = addr;
+			} else {
+				/* AUIPC's rd equals x0 or x2. */
+				instr2_rs1 = instr >> 27;
+
+				if ((uint32_t)((instr - 0x3117) << 18)
+						>= (instr2_rs1 & 0x1D)) {
+					i += 4 - 2;
+					continue;
+				}
+
+				addr = get_unaligned_be32(buf + i + 4);
+				addr -= s->pos + (uint32_t)i;
+
+				instr2 = (instr >> 12) | (addr << 20);
+
+				instr = 0x17 | (instr2_rs1 << 7)
+					| ((addr + 0x800) & 0xFFFFF000);
+			}
+
+			put_unaligned_le32(instr, buf + i);
+			put_unaligned_le32(instr2, buf + i + 4);
+
+			i += 8 - 2;
+		}
+	}
+
+	return i;
+}
+#endif
+
+/*
+ * Apply the selected BCJ filter. Update *pos and s->pos to match the amount
+ * of data that got filtered.
+ *
+ * NOTE: This is implemented as a switch statement to avoid using function
+ * pointers, which could be problematic in the kernel boot code, which must
+ * avoid pointers to static data (at least on x86).
+ */
+static void bcj_apply(struct xz_dec_bcj *s,
+		      uint8_t *buf, size_t *pos, size_t size)
+{
+	size_t filtered;
+
+	buf += *pos;
+	size -= *pos;
+
+	switch (s->type) {
+#ifdef XZ_DEC_X86
+	case BCJ_X86:
+		filtered = bcj_x86(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_POWERPC
+	case BCJ_POWERPC:
+		filtered = bcj_powerpc(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_IA64
+	case BCJ_IA64:
+		filtered = bcj_ia64(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_ARM
+	case BCJ_ARM:
+		filtered = bcj_arm(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_ARMTHUMB
+	case BCJ_ARMTHUMB:
+		filtered = bcj_armthumb(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_SPARC
+	case BCJ_SPARC:
+		filtered = bcj_sparc(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_ARM64
+	case BCJ_ARM64:
+		filtered = bcj_arm64(s, buf, size);
+		break;
+#endif
+#ifdef XZ_DEC_RISCV
+	case BCJ_RISCV:
+		filtered = bcj_riscv(s, buf, size);
+		break;
+#endif
+	default:
+		/* Never reached but silence compiler warnings. */
+		filtered = 0;
+		break;
+	}
+
+	*pos += filtered;
+	s->pos += filtered;
+}
+
+/*
+ * Flush pending filtered data from temp to the output buffer.
+ * Move the remaining mixture of possibly filtered and unfiltered
+ * data to the beginning of temp.
+ */
+static void bcj_flush(struct xz_dec_bcj *s, struct xz_buf *b)
+{
+	size_t copy_size;
+
+	copy_size = min_t(size_t, s->temp.filtered, b->out_size - b->out_pos);
+	memcpy(b->out + b->out_pos, s->temp.buf, copy_size);
+	b->out_pos += copy_size;
+
+	s->temp.filtered -= copy_size;
+	s->temp.size -= copy_size;
+	memmove(s->temp.buf, s->temp.buf + copy_size, s->temp.size);
+}
+
+/*
+ * The BCJ filter functions are primitive in sense that they process the
+ * data in chunks of 1-16 bytes. To hide this issue, this function does
+ * some buffering.
+ */
+XZ_EXTERN enum xz_ret xz_dec_bcj_run(struct xz_dec_bcj *s,
+				     struct xz_dec_lzma2 *lzma2,
+				     struct xz_buf *b)
+{
+	size_t out_start;
+
+	/*
+	 * Flush pending already filtered data to the output buffer. Return
+	 * immediately if we couldn't flush everything, or if the next
+	 * filter in the chain had already returned XZ_STREAM_END.
+	 */
+	if (s->temp.filtered > 0) {
+		bcj_flush(s, b);
+		if (s->temp.filtered > 0)
+			return XZ_OK;
+
+		if (s->ret == XZ_STREAM_END)
+			return XZ_STREAM_END;
+	}
+
+	/*
+	 * If we have more output space than what is currently pending in
+	 * temp, copy the unfiltered data from temp to the output buffer
+	 * and try to fill the output buffer by decoding more data from the
+	 * next filter in the chain. Apply the BCJ filter on the new data
+	 * in the output buffer. If everything cannot be filtered, copy it
+	 * to temp and rewind the output buffer position accordingly.
+	 *
+	 * This needs to be always run when temp.size == 0 to handle a special
+	 * case where the output buffer is full and the next filter has no
+	 * more output coming but hasn't returned XZ_STREAM_END yet.
+	 */
+	if (s->temp.size < b->out_size - b->out_pos || s->temp.size == 0) {
+		out_start = b->out_pos;
+		memcpy(b->out + b->out_pos, s->temp.buf, s->temp.size);
+		b->out_pos += s->temp.size;
+
+		s->ret = xz_dec_lzma2_run(lzma2, b);
+		if (s->ret != XZ_STREAM_END
+				&& (s->ret != XZ_OK || s->single_call))
+			return s->ret;
+
+		bcj_apply(s, b->out, &out_start, b->out_pos);
+
+		/*
+		 * As an exception, if the next filter returned XZ_STREAM_END,
+		 * we can do that too, since the last few bytes that remain
+		 * unfiltered are meant to remain unfiltered.
+		 */
+		if (s->ret == XZ_STREAM_END)
+			return XZ_STREAM_END;
+
+		s->temp.size = b->out_pos - out_start;
+		b->out_pos -= s->temp.size;
+		memcpy(s->temp.buf, b->out + b->out_pos, s->temp.size);
+
+		/*
+		 * If there wasn't enough input to the next filter to fill
+		 * the output buffer with unfiltered data, there's no point
+		 * to try decoding more data to temp.
+		 */
+		if (b->out_pos + s->temp.size < b->out_size)
+			return XZ_OK;
+	}
+
+	/*
+	 * We have unfiltered data in temp. If the output buffer isn't full
+	 * yet, try to fill the temp buffer by decoding more data from the
+	 * next filter. Apply the BCJ filter on temp. Then we hopefully can
+	 * fill the actual output buffer by copying filtered data from temp.
+	 * A mix of filtered and unfiltered data may be left in temp; it will
+	 * be taken care on the next call to this function.
+	 */
+	if (b->out_pos < b->out_size) {
+		/* Make b->out{,_pos,_size} temporarily point to s->temp. */
+		s->out = b->out;
+		s->out_pos = b->out_pos;
+		s->out_size = b->out_size;
+		b->out = s->temp.buf;
+		b->out_pos = s->temp.size;
+		b->out_size = sizeof(s->temp.buf);
+
+		s->ret = xz_dec_lzma2_run(lzma2, b);
+
+		s->temp.size = b->out_pos;
+		b->out = s->out;
+		b->out_pos = s->out_pos;
+		b->out_size = s->out_size;
+
+		if (s->ret != XZ_OK && s->ret != XZ_STREAM_END)
+			return s->ret;
+
+		bcj_apply(s, s->temp.buf, &s->temp.filtered, s->temp.size);
+
+		/*
+		 * If the next filter returned XZ_STREAM_END, we mark that
+		 * everything is filtered, since the last unfiltered bytes
+		 * of the stream are meant to be left as is.
+		 */
+		if (s->ret == XZ_STREAM_END)
+			s->temp.filtered = s->temp.size;
+
+		bcj_flush(s, b);
+		if (s->temp.filtered > 0)
+			return XZ_OK;
+	}
+
+	return s->ret;
+}
+
+XZ_EXTERN struct xz_dec_bcj *xz_dec_bcj_create(bool single_call)
+{
+	struct xz_dec_bcj *s = kmalloc(sizeof(*s), GFP_KERNEL);
+	if (s != NULL)
+		s->single_call = single_call;
+
+	return s;
+}
+
+XZ_EXTERN enum xz_ret xz_dec_bcj_reset(struct xz_dec_bcj *s, uint8_t id)
+{
+	switch (id) {
+#ifdef XZ_DEC_X86
+	case BCJ_X86:
+#endif
+#ifdef XZ_DEC_POWERPC
+	case BCJ_POWERPC:
+#endif
+#ifdef XZ_DEC_IA64
+	case BCJ_IA64:
+#endif
+#ifdef XZ_DEC_ARM
+	case BCJ_ARM:
+#endif
+#ifdef XZ_DEC_ARMTHUMB
+	case BCJ_ARMTHUMB:
+#endif
+#ifdef XZ_DEC_SPARC
+	case BCJ_SPARC:
+#endif
+#ifdef XZ_DEC_ARM64
+	case BCJ_ARM64:
+#endif
+#ifdef XZ_DEC_RISCV
+	case BCJ_RISCV:
+#endif
+		break;
+
+	default:
+		/* Unsupported Filter ID */
+		return XZ_OPTIONS_ERROR;
+	}
+
+	s->type = id;
+	s->ret = XZ_OK;
+	s->pos = 0;
+	s->x86_prev_mask = 0;
+	s->temp.filtered = 0;
+	s->temp.size = 0;
+
+	return XZ_OK;
+}
+
+#endif

android/app/src/main/cpp/xz/xz_dec_stream.c

@@ -0,0 +1,984 @@
+// SPDX-License-Identifier: 0BSD
+
+/*
+ * .xz Stream decoder
+ *
+ * Author: Lasse Collin <lasse.collin@tukaani.org>
+ */
+
+#include "xz_private.h"
+#include "xz_stream.h"
+
+#ifdef XZ_USE_CRC64
+#	define IS_CRC64(check_type) ((check_type) == XZ_CHECK_CRC64)
+#else
+#	define IS_CRC64(check_type) false
+#endif
+
+#ifdef XZ_USE_SHA256
+#	define IS_SHA256(check_type) ((check_type) == XZ_CHECK_SHA256)
+#else
+#	define IS_SHA256(check_type) false
+#endif
+
+/* Hash used to validate the Index field */
+struct xz_dec_hash {
+	vli_type unpadded;
+	vli_type uncompressed;
+	uint32_t crc32;
+};
+
+struct xz_dec {
+	/* Position in dec_main() */
+	enum {
+		SEQ_STREAM_HEADER,
+		SEQ_BLOCK_START,
+		SEQ_BLOCK_HEADER,
+		SEQ_BLOCK_UNCOMPRESS,
+		SEQ_BLOCK_PADDING,
+		SEQ_BLOCK_CHECK,
+		SEQ_INDEX,
+		SEQ_INDEX_PADDING,
+		SEQ_INDEX_CRC32,
+		SEQ_STREAM_FOOTER,
+		SEQ_STREAM_PADDING
+	} sequence;
+
+	/* Position in variable-length integers and Check fields */
+	uint32_t pos;
+
+	/* Variable-length integer decoded by dec_vli() */
+	vli_type vli;
+
+	/* Saved in_pos and out_pos */
+	size_t in_start;
+	size_t out_start;
+
+#ifdef XZ_USE_CRC64
+	/* CRC32 or CRC64 value in Block or CRC32 value in Index */
+	uint64_t crc;
+#else
+	/* CRC32 value in Block or Index */
+	uint32_t crc;
+#endif
+
+	/* Type of the integrity check calculated from uncompressed data */
+	enum xz_check check_type;
+
+	/* Operation mode */
+	enum xz_mode mode;
+
+	/*
+	 * True if the next call to xz_dec_run() is allowed to return
+	 * XZ_BUF_ERROR.
+	 */
+	bool allow_buf_error;
+
+	/* Information stored in Block Header */
+	struct {
+		/*
+		 * Value stored in the Compressed Size field, or
+		 * VLI_UNKNOWN if Compressed Size is not present.
+		 */
+		vli_type compressed;
+
+		/*
+		 * Value stored in the Uncompressed Size field, or
+		 * VLI_UNKNOWN if Uncompressed Size is not present.
+		 */
+		vli_type uncompressed;
+
+		/* Size of the Block Header field */
+		uint32_t size;
+	} block_header;
+
+	/* Information collected when decoding Blocks */
+	struct {
+		/* Observed compressed size of the current Block */
+		vli_type compressed;
+
+		/* Observed uncompressed size of the current Block */
+		vli_type uncompressed;
+
+		/* Number of Blocks decoded so far */
+		vli_type count;
+
+		/*
+		 * Hash calculated from the Block sizes. This is used to
+		 * validate the Index field.
+		 */
+		struct xz_dec_hash hash;
+	} block;
+
+	/* Variables needed when verifying the Index field */
+	struct {
+		/* Position in dec_index() */
+		enum {
+			SEQ_INDEX_COUNT,
+			SEQ_INDEX_UNPADDED,
+			SEQ_INDEX_UNCOMPRESSED
+		} sequence;
+
+		/* Size of the Index in bytes */
+		vli_type size;
+
+		/* Number of Records (matches block.count in valid files) */
+		vli_type count;
+
+		/*
+		 * Hash calculated from the Records (matches block.hash in
+		 * valid files).
+		 */
+		struct xz_dec_hash hash;
+	} index;
+
+	/*
+	 * Temporary buffer needed to hold Stream Header, Block Header,
+	 * and Stream Footer. The Block Header is the biggest (1 KiB)
+	 * so we reserve space according to that. buf[] has to be aligned
+	 * to a multiple of four bytes; the size_t variables before it
+	 * should guarantee this.
+	 */
+	struct {
+		size_t pos;
+		size_t size;
+		uint8_t buf[1024];
+	} temp;
+
+	struct xz_dec_lzma2 *lzma2;
+
+#ifdef XZ_DEC_BCJ
+	struct xz_dec_bcj *bcj;
+	bool bcj_active;
+#endif
+
+#ifdef XZ_USE_SHA256
+	/*
+	 * SHA-256 value in Block
+	 *
+	 * struct xz_sha256 is over a hundred bytes and it's only accessed
+	 * from a few places. By putting the SHA-256 state near the end
+	 * of struct xz_dec (somewhere after the "index" member) reduces
+	 * code size at least on x86 and RISC-V. It's because the first bytes
+	 * of the struct can be accessed with smaller instructions; the
+	 * members that are accessed from many places should be at the top.
+	 */
+	struct xz_sha256 sha256;
+#endif
+};
+
+#if defined(XZ_DEC_ANY_CHECK) || defined(XZ_USE_SHA256)
+/* Sizes of the Check field with different Check IDs */
+static const uint8_t check_sizes[16] = {
+	0,
+	4, 4, 4,
+	8, 8, 8,
+	16, 16, 16,
+	32, 32, 32,
+	64, 64, 64
+};
+#endif
+
+/*
+ * Fill s->temp by copying data starting from b->in[b->in_pos]. Caller
+ * must have set s->temp.pos and s->temp.size to indicate how much data
+ * we are supposed to copy into s->temp.buf. Return true once s->temp.pos
+ * has reached s->temp.size.
+ */
+static bool fill_temp(struct xz_dec *s, struct xz_buf *b)
+{
+	size_t copy_size = min_t(size_t,
+			b->in_size - b->in_pos, s->temp.size - s->temp.pos);
+
+	memcpy(s->temp.buf + s->temp.pos, b->in + b->in_pos, copy_size);
+	b->in_pos += copy_size;
+	s->temp.pos += copy_size;
+
+	if (s->temp.pos == s->temp.size) {
+		s->temp.pos = 0;
+		return true;
+	}
+
+	return false;
+}
+
+/* Decode a variable-length integer (little-endian base-128 encoding) */
+static enum xz_ret dec_vli(struct xz_dec *s, const uint8_t *in,
+			   size_t *in_pos, size_t in_size)
+{
+	uint8_t byte;
+
+	if (s->pos == 0)
+		s->vli = 0;
+
+	while (*in_pos < in_size) {
+		byte = in[*in_pos];
+		++*in_pos;
+
+		s->vli |= (vli_type)(byte & 0x7F) << s->pos;
+
+		if ((byte & 0x80) == 0) {
+			/* Don't allow non-minimal encodings. */
+			if (byte == 0 && s->pos != 0)
+				return XZ_DATA_ERROR;
+
+			s->pos = 0;
+			return XZ_STREAM_END;
+		}
+
+		s->pos += 7;
+		if (s->pos == 7 * VLI_BYTES_MAX)
+			return XZ_DATA_ERROR;
+	}
+
+	return XZ_OK;
+}
+
+/*
+ * Decode the Compressed Data field from a Block. Update and validate
+ * the observed compressed and uncompressed sizes of the Block so that
+ * they don't exceed the values possibly stored in the Block Header
+ * (validation assumes that no integer overflow occurs, since vli_type
+ * is normally uint64_t). Update the CRC32 or CRC64 value if presence of
+ * the CRC32 or CRC64 field was indicated in Stream Header.
+ *
+ * Once the decoding is finished, validate that the observed sizes match
+ * the sizes possibly stored in the Block Header. Update the hash and
+ * Block count, which are later used to validate the Index field.
+ */
+static enum xz_ret dec_block(struct xz_dec *s, struct xz_buf *b)
+{
+	enum xz_ret ret;
+
+	s->in_start = b->in_pos;
+	s->out_start = b->out_pos;
+
+#ifdef XZ_DEC_BCJ
+	if (s->bcj_active)
+		ret = xz_dec_bcj_run(s->bcj, s->lzma2, b);
+	else
+#endif
+		ret = xz_dec_lzma2_run(s->lzma2, b);
+
+	s->block.compressed += b->in_pos - s->in_start;
+	s->block.uncompressed += b->out_pos - s->out_start;
+
+	/*
+	 * There is no need to separately check for VLI_UNKNOWN, since
+	 * the observed sizes are always smaller than VLI_UNKNOWN.
+	 */
+	if (s->block.compressed > s->block_header.compressed
+			|| s->block.uncompressed
+				> s->block_header.uncompressed)
+		return XZ_DATA_ERROR;
+
+	if (s->check_type == XZ_CHECK_CRC32)
+		s->crc = xz_crc32(b->out + s->out_start,
+				b->out_pos - s->out_start, s->crc);
+#ifdef XZ_USE_CRC64
+	else if (s->check_type == XZ_CHECK_CRC64)
+		s->crc = xz_crc64(b->out + s->out_start,
+				b->out_pos - s->out_start, s->crc);
+#endif
+#ifdef XZ_USE_SHA256
+	else if (s->check_type == XZ_CHECK_SHA256)
+		xz_sha256_update(b->out + s->out_start,
+				b->out_pos - s->out_start, &s->sha256);
+#endif
+
+	if (ret == XZ_STREAM_END) {
+		if (s->block_header.compressed != VLI_UNKNOWN
+				&& s->block_header.compressed
+					!= s->block.compressed)
+			return XZ_DATA_ERROR;
+
+		if (s->block_header.uncompressed != VLI_UNKNOWN
+				&& s->block_header.uncompressed
+					!= s->block.uncompressed)
+			return XZ_DATA_ERROR;
+
+		s->block.hash.unpadded += s->block_header.size
+				+ s->block.compressed;
+
+#if defined(XZ_DEC_ANY_CHECK) || defined(XZ_USE_SHA256)
+		s->block.hash.unpadded += check_sizes[s->check_type];
+#else
+		if (s->check_type == XZ_CHECK_CRC32)
+			s->block.hash.unpadded += 4;
+		else if (IS_CRC64(s->check_type))
+			s->block.hash.unpadded += 8;
+#endif
+
+		s->block.hash.uncompressed += s->block.uncompressed;
+		s->block.hash.crc32 = xz_crc32(
+				(const uint8_t *)&s->block.hash,
+				sizeof(s->block.hash), s->block.hash.crc32);
+
+		++s->block.count;
+	}
+
+	return ret;
+}
+
+/* Update the Index size and the CRC32 value. */
+static void index_update(struct xz_dec *s, const struct xz_buf *b)
+{
+	size_t in_used = b->in_pos - s->in_start;
+	s->index.size += in_used;
+	s->crc = xz_crc32(b->in + s->in_start, in_used, s->crc);
+}
+
+/*
+ * Decode the Number of Records, Unpadded Size, and Uncompressed Size
+ * fields from the Index field. That is, Index Padding and CRC32 are not
+ * decoded by this function.
+ *
+ * This can return XZ_OK (more input needed), XZ_STREAM_END (everything
+ * successfully decoded), or XZ_DATA_ERROR (input is corrupt).
+ */
+static enum xz_ret dec_index(struct xz_dec *s, struct xz_buf *b)
+{
+	enum xz_ret ret;
+
+	do {
+		ret = dec_vli(s, b->in, &b->in_pos, b->in_size);
+		if (ret != XZ_STREAM_END) {
+			index_update(s, b);
+			return ret;
+		}
+
+		switch (s->index.sequence) {
+		case SEQ_INDEX_COUNT:
+			s->index.count = s->vli;
+
+			/*
+			 * Validate that the Number of Records field
+			 * indicates the same number of Records as
+			 * there were Blocks in the Stream.
+			 */
+			if (s->index.count != s->block.count)
+				return XZ_DATA_ERROR;
+
+			s->index.sequence = SEQ_INDEX_UNPADDED;
+			break;
+
+		case SEQ_INDEX_UNPADDED:
+			s->index.hash.unpadded += s->vli;
+			s->index.sequence = SEQ_INDEX_UNCOMPRESSED;
+			break;
+
+		case SEQ_INDEX_UNCOMPRESSED:
+			s->index.hash.uncompressed += s->vli;
+			s->index.hash.crc32 = xz_crc32(
+					(const uint8_t *)&s->index.hash,
+					sizeof(s->index.hash),
+					s->index.hash.crc32);
+			--s->index.count;
+			s->index.sequence = SEQ_INDEX_UNPADDED;
+			break;
+		}
+	} while (s->index.count > 0);
+
+	return XZ_STREAM_END;
+}
+
+/*
+ * Validate that the next four or eight input bytes match the value
+ * of s->crc. s->pos must be zero when starting to validate the first byte.
+ * The "bits" argument allows using the same code for both CRC32 and CRC64.
+ */
+static enum xz_ret crc_validate(struct xz_dec *s, struct xz_buf *b,
+				uint32_t bits)
+{
+	do {
+		if (b->in_pos == b->in_size)
+			return XZ_OK;
+
+		if (((s->crc >> s->pos) & 0xFF) != b->in[b->in_pos++])
+			return XZ_DATA_ERROR;
+
+		s->pos += 8;
+
+	} while (s->pos < bits);
+
+	s->crc = 0;
+	s->pos = 0;
+
+	return XZ_STREAM_END;
+}
+
+#ifdef XZ_DEC_ANY_CHECK
+/*
+ * Skip over the Check field when the Check ID is not supported.
+ * Returns true once the whole Check field has been skipped over.
+ */
+static bool check_skip(struct xz_dec *s, struct xz_buf *b)
+{
+	while (s->pos < check_sizes[s->check_type]) {
+		if (b->in_pos == b->in_size)
+			return false;
+
+		++b->in_pos;
+		++s->pos;
+	}
+
+	s->pos = 0;
+
+	return true;
+}
+#endif
+
+/* Decode the Stream Header field (the first 12 bytes of the .xz Stream). */
+static enum xz_ret dec_stream_header(struct xz_dec *s)
+{
+	if (!memeq(s->temp.buf, HEADER_MAGIC, HEADER_MAGIC_SIZE))
+		return XZ_FORMAT_ERROR;
+
+	if (xz_crc32(s->temp.buf + HEADER_MAGIC_SIZE, 2, 0)
+			!= get_le32(s->temp.buf + HEADER_MAGIC_SIZE + 2))
+		return XZ_DATA_ERROR;
+
+	if (s->temp.buf[HEADER_MAGIC_SIZE] != 0)
+		return XZ_OPTIONS_ERROR;
+
+	/*
+	 * Of integrity checks, we support none (Check ID = 0),
+	 * CRC32 (Check ID = 1), and optionally CRC64 (Check ID = 4).
+	 * However, if XZ_DEC_ANY_CHECK is defined, we will accept other
+	 * check types too, but then the check won't be verified and
+	 * a warning (XZ_UNSUPPORTED_CHECK) will be given.
+	 */
+	if (s->temp.buf[HEADER_MAGIC_SIZE + 1] > XZ_CHECK_MAX)
+		return XZ_OPTIONS_ERROR;
+
+	s->check_type = s->temp.buf[HEADER_MAGIC_SIZE + 1];
+
+	if (s->check_type > XZ_CHECK_CRC32 && !IS_CRC64(s->check_type)
+			&& !IS_SHA256(s->check_type)) {
+#ifdef XZ_DEC_ANY_CHECK
+		return XZ_UNSUPPORTED_CHECK;
+#else
+		return XZ_OPTIONS_ERROR;
+#endif
+	}
+
+	return XZ_OK;
+}
+
+/* Decode the Stream Footer field (the last 12 bytes of the .xz Stream) */
+static enum xz_ret dec_stream_footer(struct xz_dec *s)
+{
+	if (!memeq(s->temp.buf + 10, FOOTER_MAGIC, FOOTER_MAGIC_SIZE))
+		return XZ_DATA_ERROR;
+
+	if (xz_crc32(s->temp.buf + 4, 6, 0) != get_le32(s->temp.buf))
+		return XZ_DATA_ERROR;
+
+	/*
+	 * Validate Backward Size. Note that we never added the size of the
+	 * Index CRC32 field to s->index.size, thus we use s->index.size / 4
+	 * instead of s->index.size / 4 - 1.
+	 */
+	if ((s->index.size >> 2) != get_le32(s->temp.buf + 4))
+		return XZ_DATA_ERROR;
+
+	if (s->temp.buf[8] != 0 || s->temp.buf[9] != s->check_type)
+		return XZ_DATA_ERROR;
+
+	/*
+	 * Use XZ_STREAM_END instead of XZ_OK to be more convenient
+	 * for the caller.
+	 */
+	return XZ_STREAM_END;
+}
+
+/* Decode the Block Header and initialize the filter chain. */
+static enum xz_ret dec_block_header(struct xz_dec *s)
+{
+	enum xz_ret ret;
+
+	/*
+	 * Validate the CRC32. We know that the temp buffer is at least
+	 * eight bytes so this is safe.
+	 */
+	s->temp.size -= 4;
+	if (xz_crc32(s->temp.buf, s->temp.size, 0)
+			!= get_le32(s->temp.buf + s->temp.size))
+		return XZ_DATA_ERROR;
+
+	s->temp.pos = 2;
+
+	/*
+	 * Catch unsupported Block Flags. We support only one or two filters
+	 * in the chain, so we catch that with the same test.
+	 */
+#ifdef XZ_DEC_BCJ
+	if (s->temp.buf[1] & 0x3E)
+#else
+	if (s->temp.buf[1] & 0x3F)
+#endif
+		return XZ_OPTIONS_ERROR;
+
+	/* Compressed Size */
+	if (s->temp.buf[1] & 0x40) {
+		if (dec_vli(s, s->temp.buf, &s->temp.pos, s->temp.size)
+					!= XZ_STREAM_END)
+			return XZ_DATA_ERROR;
+
+		s->block_header.compressed = s->vli;
+	} else {
+		s->block_header.compressed = VLI_UNKNOWN;
+	}
+
+	/* Uncompressed Size */
+	if (s->temp.buf[1] & 0x80) {
+		if (dec_vli(s, s->temp.buf, &s->temp.pos, s->temp.size)
+				!= XZ_STREAM_END)
+			return XZ_DATA_ERROR;
+
+		s->block_header.uncompressed = s->vli;
+	} else {
+		s->block_header.uncompressed = VLI_UNKNOWN;
+	}
+
+#ifdef XZ_DEC_BCJ
+	/* If there are two filters, the first one must be a BCJ filter. */
+	s->bcj_active = s->temp.buf[1] & 0x01;
+	if (s->bcj_active) {
+		if (s->temp.size - s->temp.pos < 2)
+			return XZ_OPTIONS_ERROR;
+
+		ret = xz_dec_bcj_reset(s->bcj, s->temp.buf[s->temp.pos++]);
+		if (ret != XZ_OK)
+			return ret;
+
+		/*
+		 * We don't support custom start offset,
+		 * so Size of Properties must be zero.
+		 */
+		if (s->temp.buf[s->temp.pos++] != 0x00)
+			return XZ_OPTIONS_ERROR;
+	}
+#endif
+
+	/* Valid Filter Flags always take at least two bytes. */
+	if (s->temp.size - s->temp.pos < 2)
+		return XZ_DATA_ERROR;
+
+	/* Filter ID = LZMA2 */
+	if (s->temp.buf[s->temp.pos++] != 0x21)
+		return XZ_OPTIONS_ERROR;
+
+	/* Size of Properties = 1-byte Filter Properties */
+	if (s->temp.buf[s->temp.pos++] != 0x01)
+		return XZ_OPTIONS_ERROR;
+
+	/* Filter Properties contains LZMA2 dictionary size. */
+	if (s->temp.size - s->temp.pos < 1)
+		return XZ_DATA_ERROR;
+
+	ret = xz_dec_lzma2_reset(s->lzma2, s->temp.buf[s->temp.pos++]);
+	if (ret != XZ_OK)
+		return ret;
+
+	/* The rest must be Header Padding. */
+	while (s->temp.pos < s->temp.size)
+		if (s->temp.buf[s->temp.pos++] != 0x00)
+			return XZ_OPTIONS_ERROR;
+
+	s->temp.pos = 0;
+	s->block.compressed = 0;
+	s->block.uncompressed = 0;
+
+	return XZ_OK;
+}
+
+static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
+{
+	enum xz_ret ret;
+
+	/*
+	 * Store the start position for the case when we are in the middle
+	 * of the Index field.
+	 */
+	s->in_start = b->in_pos;
+
+	while (true) {
+		switch (s->sequence) {
+		case SEQ_STREAM_HEADER:
+			/*
+			 * Stream Header is copied to s->temp, and then
+			 * decoded from there. This way if the caller
+			 * gives us only little input at a time, we can
+			 * still keep the Stream Header decoding code
+			 * simple. Similar approach is used in many places
+			 * in this file.
+			 */
+			if (!fill_temp(s, b))
+				return XZ_OK;
+
+			/*
+			 * If dec_stream_header() returns
+			 * XZ_UNSUPPORTED_CHECK, it is still possible
+			 * to continue decoding if working in multi-call
+			 * mode. Thus, update s->sequence before calling
+			 * dec_stream_header().
+			 */
+			s->sequence = SEQ_BLOCK_START;
+
+			ret = dec_stream_header(s);
+			if (ret != XZ_OK)
+				return ret;
+
+			fallthrough;
+
+		case SEQ_BLOCK_START:
+			/* We need one byte of input to continue. */
+			if (b->in_pos == b->in_size)
+				return XZ_OK;
+
+			/* See if this is the beginning of the Index field. */
+			if (b->in[b->in_pos] == 0) {
+				s->in_start = b->in_pos++;
+				s->sequence = SEQ_INDEX;
+				break;
+			}
+
+			/*
+			 * Calculate the size of the Block Header and
+			 * prepare to decode it.
+			 */
+			s->block_header.size
+				= ((uint32_t)b->in[b->in_pos] + 1) * 4;
+
+			s->temp.size = s->block_header.size;
+			s->temp.pos = 0;
+			s->sequence = SEQ_BLOCK_HEADER;
+
+			fallthrough;
+
+		case SEQ_BLOCK_HEADER:
+			if (!fill_temp(s, b))
+				return XZ_OK;
+
+			ret = dec_block_header(s);
+			if (ret != XZ_OK)
+				return ret;
+
+#ifdef XZ_USE_SHA256
+			if (s->check_type == XZ_CHECK_SHA256)
+				xz_sha256_reset(&s->sha256);
+#endif
+
+			s->sequence = SEQ_BLOCK_UNCOMPRESS;
+
+			fallthrough;
+
+		case SEQ_BLOCK_UNCOMPRESS:
+			ret = dec_block(s, b);
+			if (ret != XZ_STREAM_END)
+				return ret;
+
+			s->sequence = SEQ_BLOCK_PADDING;
+
+			fallthrough;
+
+		case SEQ_BLOCK_PADDING:
+			/*
+			 * Size of Compressed Data + Block Padding
+			 * must be a multiple of four. We don't need
+			 * s->block.compressed for anything else
+			 * anymore, so we use it here to test the size
+			 * of the Block Padding field.
+			 */
+			while (s->block.compressed & 3) {
+				if (b->in_pos == b->in_size)
+					return XZ_OK;
+
+				if (b->in[b->in_pos++] != 0)
+					return XZ_DATA_ERROR;
+
+				++s->block.compressed;
+			}
+
+			s->sequence = SEQ_BLOCK_CHECK;
+
+			fallthrough;
+
+		case SEQ_BLOCK_CHECK:
+			if (s->check_type == XZ_CHECK_CRC32) {
+				ret = crc_validate(s, b, 32);
+				if (ret != XZ_STREAM_END)
+					return ret;
+			}
+			else if (IS_CRC64(s->check_type)) {
+				ret = crc_validate(s, b, 64);
+				if (ret != XZ_STREAM_END)
+					return ret;
+			}
+#ifdef XZ_USE_SHA256
+			else if (s->check_type == XZ_CHECK_SHA256) {
+				s->temp.size = 32;
+				if (!fill_temp(s, b))
+					return XZ_OK;
+
+				if (!xz_sha256_validate(s->temp.buf,
+							&s->sha256))
+					return XZ_DATA_ERROR;
+
+				s->pos = 0;
+			}
+#endif
+#ifdef XZ_DEC_ANY_CHECK
+			else if (!check_skip(s, b)) {
+				return XZ_OK;
+			}
+#endif
+
+			s->sequence = SEQ_BLOCK_START;
+			break;
+
+		case SEQ_INDEX:
+			ret = dec_index(s, b);
+			if (ret != XZ_STREAM_END)
+				return ret;
+
+			s->sequence = SEQ_INDEX_PADDING;
+
+			fallthrough;
+
+		case SEQ_INDEX_PADDING:
+			while ((s->index.size + (b->in_pos - s->in_start))
+					& 3) {
+				if (b->in_pos == b->in_size) {
+					index_update(s, b);
+					return XZ_OK;
+				}
+
+				if (b->in[b->in_pos++] != 0)
+					return XZ_DATA_ERROR;
+			}
+
+			/* Finish the CRC32 value and Index size. */
+			index_update(s, b);
+
+			/* Compare the hashes to validate the Index field. */
+			if (!memeq(&s->block.hash, &s->index.hash,
+					sizeof(s->block.hash)))
+				return XZ_DATA_ERROR;
+
+			s->sequence = SEQ_INDEX_CRC32;
+
+			fallthrough;
+
+		case SEQ_INDEX_CRC32:
+			ret = crc_validate(s, b, 32);
+			if (ret != XZ_STREAM_END)
+				return ret;
+
+			s->temp.size = STREAM_HEADER_SIZE;
+			s->sequence = SEQ_STREAM_FOOTER;
+
+			fallthrough;
+
+		case SEQ_STREAM_FOOTER:
+			if (!fill_temp(s, b))
+				return XZ_OK;
+
+			return dec_stream_footer(s);
+
+		case SEQ_STREAM_PADDING:
+			/* Never reached, only silencing a warning */
+			break;
+		}
+	}
+
+	/* Never reached */
+}
+
+/*
+ * xz_dec_run() is a wrapper for dec_main() to handle some special cases in
+ * multi-call and single-call decoding.
+ *
+ * In multi-call mode, we must return XZ_BUF_ERROR when it seems clear that we
+ * are not going to make any progress anymore. This is to prevent the caller
+ * from calling us infinitely when the input file is truncated or otherwise
+ * corrupt. Since zlib-style API allows that the caller fills the input buffer
+ * only when the decoder doesn't produce any new output, we have to be careful
+ * to avoid returning XZ_BUF_ERROR too easily: XZ_BUF_ERROR is returned only
+ * after the second consecutive call to xz_dec_run() that makes no progress.
+ *
+ * In single-call mode, if we couldn't decode everything and no error
+ * occurred, either the input is truncated or the output buffer is too small.
+ * Since we know that the last input byte never produces any output, we know
+ * that if all the input was consumed and decoding wasn't finished, the file
+ * must be corrupt. Otherwise the output buffer has to be too small or the
+ * file is corrupt in a way that decoding it produces too big output.
+ *
+ * If single-call decoding fails, we reset b->in_pos and b->out_pos back to
+ * their original values. This is because with some filter chains there won't
+ * be any valid uncompressed data in the output buffer unless the decoding
+ * actually succeeds (that's the price to pay of using the output buffer as
+ * the workspace).
+ */
+XZ_EXTERN enum xz_ret xz_dec_run(struct xz_dec *s, struct xz_buf *b)
+{
+	size_t in_start;
+	size_t out_start;
+	enum xz_ret ret;
+
+	if (DEC_IS_SINGLE(s->mode))
+		xz_dec_reset(s);
+
+	in_start = b->in_pos;
+	out_start = b->out_pos;
+	ret = dec_main(s, b);
+
+	if (DEC_IS_SINGLE(s->mode)) {
+		if (ret == XZ_OK)
+			ret = b->in_pos == b->in_size
+					? XZ_DATA_ERROR : XZ_BUF_ERROR;
+
+		if (ret != XZ_STREAM_END) {
+			b->in_pos = in_start;
+			b->out_pos = out_start;
+		}
+
+	} else if (ret == XZ_OK && in_start == b->in_pos
+			&& out_start == b->out_pos) {
+		if (s->allow_buf_error)
+			ret = XZ_BUF_ERROR;
+
+		s->allow_buf_error = true;
+	} else {
+		s->allow_buf_error = false;
+	}
+
+	return ret;
+}
+
+#ifdef XZ_DEC_CONCATENATED
+XZ_EXTERN enum xz_ret xz_dec_catrun(struct xz_dec *s, struct xz_buf *b,
+				    int finish)
+{
+	enum xz_ret ret;
+
+	if (DEC_IS_SINGLE(s->mode)) {
+		xz_dec_reset(s);
+		finish = true;
+	}
+
+	while (true) {
+		if (s->sequence == SEQ_STREAM_PADDING) {
+			/*
+			 * Skip Stream Padding. Its size must be a multiple
+			 * of four bytes which is tracked with s->pos.
+			 */
+			while (true) {
+				if (b->in_pos == b->in_size) {
+					/*
+					 * Note that if we are repeatedly
+					 * given no input and finish is false,
+					 * we will keep returning XZ_OK even
+					 * though no progress is being made.
+					 * The lack of XZ_BUF_ERROR support
+					 * isn't a problem here because a
+					 * reasonable caller will eventually
+					 * provide more input or set finish
+					 * to true.
+					 */
+					if (!finish)
+						return XZ_OK;
+
+					if (s->pos != 0)
+						return XZ_DATA_ERROR;
+
+					return XZ_STREAM_END;
+				}
+
+				if (b->in[b->in_pos] != 0x00) {
+					if (s->pos != 0)
+						return XZ_DATA_ERROR;
+
+					break;
+				}
+
+				++b->in_pos;
+				s->pos = (s->pos + 1) & 3;
+			}
+
+			/*
+			 * More input remains. It should be a new Stream.
+			 *
+			 * In single-call mode xz_dec_run() will always call
+			 * xz_dec_reset(). Thus, we need to do it here only
+			 * in multi-call mode.
+			 */
+			if (DEC_IS_MULTI(s->mode))
+				xz_dec_reset(s);
+		}
+
+		ret = xz_dec_run(s, b);
+
+		if (ret != XZ_STREAM_END)
+			break;
+
+		s->sequence = SEQ_STREAM_PADDING;
+	}
+
+	return ret;
+}
+#endif
+
+XZ_EXTERN struct xz_dec *xz_dec_init(enum xz_mode mode, uint32_t dict_max)
+{
+	struct xz_dec *s = kmalloc(sizeof(*s), GFP_KERNEL);
+	if (s == NULL)
+		return NULL;
+
+	s->mode = mode;
+
+#ifdef XZ_DEC_BCJ
+	s->bcj = xz_dec_bcj_create(DEC_IS_SINGLE(mode));
+	if (s->bcj == NULL)
+		goto error_bcj;
+#endif
+
+	s->lzma2 = xz_dec_lzma2_create(mode, dict_max);
+	if (s->lzma2 == NULL)
+		goto error_lzma2;
+
+	xz_dec_reset(s);
+	return s;
+
+error_lzma2:
+#ifdef XZ_DEC_BCJ
+	xz_dec_bcj_end(s->bcj);
+error_bcj:
+#endif
+	kfree(s);
+	return NULL;
+}
+
+XZ_EXTERN void xz_dec_reset(struct xz_dec *s)
+{
+	s->sequence = SEQ_STREAM_HEADER;
+	s->allow_buf_error = false;
+	s->pos = 0;
+	s->crc = 0;
+	memzero(&s->block, sizeof(s->block));
+	memzero(&s->index, sizeof(s->index));
+	s->temp.pos = 0;
+	s->temp.size = STREAM_HEADER_SIZE;
+}
+
+XZ_EXTERN void xz_dec_end(struct xz_dec *s)
+{
+	if (s != NULL) {
+		xz_dec_lzma2_end(s->lzma2);
+#ifdef XZ_DEC_BCJ
+		xz_dec_bcj_end(s->bcj);
+#endif
+		kfree(s);
+	}
+}

android/app/src/main/cpp/xz/xz_lzma2.h

@@ -0,0 +1,203 @@
+/* SPDX-License-Identifier: 0BSD */
+
+/*
+ * LZMA2 definitions
+ *
+ * Authors: Lasse Collin <lasse.collin@tukaani.org>
+ *          Igor Pavlov <https://7-zip.org/>
+ */
+
+#ifndef XZ_LZMA2_H
+#define XZ_LZMA2_H
+
+/* Range coder constants */
+#define RC_SHIFT_BITS 8
+#define RC_TOP_BITS 24
+#define RC_TOP_VALUE (1 << RC_TOP_BITS)
+#define RC_BIT_MODEL_TOTAL_BITS 11
+#define RC_BIT_MODEL_TOTAL (1 << RC_BIT_MODEL_TOTAL_BITS)
+#define RC_MOVE_BITS 5
+
+/*
+ * Maximum number of position states. A position state is the lowest pb
+ * number of bits of the current uncompressed offset. In some places there
+ * are different sets of probabilities for different position states.
+ */
+#define POS_STATES_MAX (1 << 4)
+
+/*
+ * This enum is used to track which LZMA symbols have occurred most recently
+ * and in which order. This information is used to predict the next symbol.
+ *
+ * Symbols:
+ *  - Literal: One 8-bit byte
+ *  - Match: Repeat a chunk of data at some distance
+ *  - Long repeat: Multi-byte match at a recently seen distance
+ *  - Short repeat: One-byte repeat at a recently seen distance
+ *
+ * The symbol names are in from STATE_oldest_older_previous. REP means
+ * either short or long repeated match, and NONLIT means any non-literal.
+ */
+enum lzma_state {
+	STATE_LIT_LIT,
+	STATE_MATCH_LIT_LIT,
+	STATE_REP_LIT_LIT,
+	STATE_SHORTREP_LIT_LIT,
+	STATE_MATCH_LIT,
+	STATE_REP_LIT,
+	STATE_SHORTREP_LIT,
+	STATE_LIT_MATCH,
+	STATE_LIT_LONGREP,
+	STATE_LIT_SHORTREP,
+	STATE_NONLIT_MATCH,
+	STATE_NONLIT_REP
+};
+
+/* Total number of states */
+#define STATES 12
+
+/* The lowest 7 states indicate that the previous state was a literal. */
+#define LIT_STATES 7
+
+/* Indicate that the latest symbol was a literal. */
+static inline void lzma_state_literal(enum lzma_state *state)
+{
+	if (*state <= STATE_SHORTREP_LIT_LIT)
+		*state = STATE_LIT_LIT;
+	else if (*state <= STATE_LIT_SHORTREP)
+		*state -= 3;
+	else
+		*state -= 6;
+}
+
+/* Indicate that the latest symbol was a match. */
+static inline void lzma_state_match(enum lzma_state *state)
+{
+	*state = *state < LIT_STATES ? STATE_LIT_MATCH : STATE_NONLIT_MATCH;
+}
+
+/* Indicate that the latest state was a long repeated match. */
+static inline void lzma_state_long_rep(enum lzma_state *state)
+{
+	*state = *state < LIT_STATES ? STATE_LIT_LONGREP : STATE_NONLIT_REP;
+}
+
+/* Indicate that the latest symbol was a short match. */
+static inline void lzma_state_short_rep(enum lzma_state *state)
+{
+	*state = *state < LIT_STATES ? STATE_LIT_SHORTREP : STATE_NONLIT_REP;
+}
+
+/* Test if the previous symbol was a literal. */
+static inline bool lzma_state_is_literal(enum lzma_state state)
+{
+	return state < LIT_STATES;
+}
+
+/* Each literal coder is divided in three sections:
+ *   - 0x001-0x0FF: Without match byte
+ *   - 0x101-0x1FF: With match byte; match bit is 0
+ *   - 0x201-0x2FF: With match byte; match bit is 1
+ *
+ * Match byte is used when the previous LZMA symbol was something else than
+ * a literal (that is, it was some kind of match).
+ */
+#define LITERAL_CODER_SIZE 0x300
+
+/* Maximum number of literal coders */
+#define LITERAL_CODERS_MAX (1 << 4)
+
+/* Minimum length of a match is two bytes. */
+#define MATCH_LEN_MIN 2
+
+/* Match length is encoded with 4, 5, or 10 bits.
+ *
+ * Length   Bits
+ *  2-9      4 = Choice=0 + 3 bits
+ * 10-17     5 = Choice=1 + Choice2=0 + 3 bits
+ * 18-273   10 = Choice=1 + Choice2=1 + 8 bits
+ */
+#define LEN_LOW_BITS 3
+#define LEN_LOW_SYMBOLS (1 << LEN_LOW_BITS)
+#define LEN_MID_BITS 3
+#define LEN_MID_SYMBOLS (1 << LEN_MID_BITS)
+#define LEN_HIGH_BITS 8
+#define LEN_HIGH_SYMBOLS (1 << LEN_HIGH_BITS)
+#define LEN_SYMBOLS (LEN_LOW_SYMBOLS + LEN_MID_SYMBOLS + LEN_HIGH_SYMBOLS)
+
+/*
+ * Maximum length of a match is 273 which is a result of the encoding
+ * described above.
+ */
+#define MATCH_LEN_MAX (MATCH_LEN_MIN + LEN_SYMBOLS - 1)
+
+/*
+ * Different sets of probabilities are used for match distances that have
+ * very short match length: Lengths of 2, 3, and 4 bytes have a separate
+ * set of probabilities for each length. The matches with longer length
+ * use a shared set of probabilities.
+ */
+#define DIST_STATES 4
+
+/*
+ * Get the index of the appropriate probability array for decoding
+ * the distance slot.
+ */
+static inline uint32_t lzma_get_dist_state(uint32_t len)
+{
+	return len < DIST_STATES + MATCH_LEN_MIN
+			? len - MATCH_LEN_MIN : DIST_STATES - 1;
+}
+
+/*
+ * The highest two bits of a 32-bit match distance are encoded using six bits.
+ * This six-bit value is called a distance slot. This way encoding a 32-bit
+ * value takes 6-36 bits, larger values taking more bits.
+ */
+#define DIST_SLOT_BITS 6
+#define DIST_SLOTS (1 << DIST_SLOT_BITS)
+
+/* Match distances up to 127 are fully encoded using probabilities. Since
+ * the highest two bits (distance slot) are always encoded using six bits,
+ * the distances 0-3 don't need any additional bits to encode, since the
+ * distance slot itself is the same as the actual distance. DIST_MODEL_START
+ * indicates the first distance slot where at least one additional bit is
+ * needed.
+ */
+#define DIST_MODEL_START 4
+
+/*
+ * Match distances greater than 127 are encoded in three pieces:
+ *   - distance slot: the highest two bits
+ *   - direct bits: 2-26 bits below the highest two bits
+ *   - alignment bits: four lowest bits
+ *
+ * Direct bits don't use any probabilities.
+ *
+ * The distance slot value of 14 is for distances 128-191.
+ */
+#define DIST_MODEL_END 14
+
+/* Distance slots that indicate a distance <= 127. */
+#define FULL_DISTANCES_BITS (DIST_MODEL_END / 2)
+#define FULL_DISTANCES (1 << FULL_DISTANCES_BITS)
+
+/*
+ * For match distances greater than 127, only the highest two bits and the
+ * lowest four bits (alignment) is encoded using probabilities.
+ */
+#define ALIGN_BITS 4
+#define ALIGN_SIZE (1 << ALIGN_BITS)
+#define ALIGN_MASK (ALIGN_SIZE - 1)
+
+/* Total number of all probability variables */
+#define PROBS_TOTAL (1846 + LITERAL_CODERS_MAX * LITERAL_CODER_SIZE)
+
+/*
+ * LZMA remembers the four most recent match distances. Reusing these
+ * distances tends to take less space than re-encoding the actual
+ * distance value.
+ */
+#define REPS 4
+
+#endif

android/app/src/main/cpp/xz/xz_private.h

@@ -0,0 +1,189 @@
+/* SPDX-License-Identifier: 0BSD */
+
+/*
+ * Private includes and definitions
+ *
+ * Author: Lasse Collin <lasse.collin@tukaani.org>
+ */
+
+#ifndef XZ_PRIVATE_H
+#define XZ_PRIVATE_H
+
+#ifdef __KERNEL__
+#	include <linux/xz.h>
+#	include <linux/kernel.h>
+#	include <linux/unaligned.h>
+	/* XZ_PREBOOT may be defined only via decompress_unxz.c. */
+#	ifndef XZ_PREBOOT
+#		include <linux/slab.h>
+#		include <linux/vmalloc.h>
+#		include <linux/string.h>
+#		ifdef CONFIG_XZ_DEC_X86
+#			define XZ_DEC_X86
+#		endif
+#		ifdef CONFIG_XZ_DEC_POWERPC
+#			define XZ_DEC_POWERPC
+#		endif
+#		ifdef CONFIG_XZ_DEC_IA64
+#			define XZ_DEC_IA64
+#		endif
+#		ifdef CONFIG_XZ_DEC_ARM
+#			define XZ_DEC_ARM
+#		endif
+#		ifdef CONFIG_XZ_DEC_ARMTHUMB
+#			define XZ_DEC_ARMTHUMB
+#		endif
+#		ifdef CONFIG_XZ_DEC_SPARC
+#			define XZ_DEC_SPARC
+#		endif
+#		ifdef CONFIG_XZ_DEC_ARM64
+#			define XZ_DEC_ARM64
+#		endif
+#		ifdef CONFIG_XZ_DEC_RISCV
+#			define XZ_DEC_RISCV
+#		endif
+#		ifdef CONFIG_XZ_DEC_MICROLZMA
+#			define XZ_DEC_MICROLZMA
+#		endif
+#		define memeq(a, b, size) (memcmp(a, b, size) == 0)
+#		define memzero(buf, size) memset(buf, 0, size)
+#	endif
+#	define get_le32(p) le32_to_cpup((const uint32_t *)(p))
+#else
+	/*
+	 * For userspace builds, use a separate header to define the required
+	 * macros and functions. This makes it easier to adapt the code into
+	 * different environments and avoids clutter in the Linux kernel tree.
+	 */
+#	include "xz_config.h"
+#endif
+
+/* If no specific decoding mode is requested, enable support for all modes. */
+#if !defined(XZ_DEC_SINGLE) && !defined(XZ_DEC_PREALLOC) \
+		&& !defined(XZ_DEC_DYNALLOC)
+#	define XZ_DEC_SINGLE
+#	define XZ_DEC_PREALLOC
+#	define XZ_DEC_DYNALLOC
+#endif
+
+/*
+ * The DEC_IS_foo(mode) macros are used in "if" statements. If only some
+ * of the supported modes are enabled, these macros will evaluate to true or
+ * false at compile time and thus allow the compiler to omit unneeded code.
+ */
+#ifdef XZ_DEC_SINGLE
+#	define DEC_IS_SINGLE(mode) ((mode) == XZ_SINGLE)
+#else
+#	define DEC_IS_SINGLE(mode) (false)
+#endif
+
+#ifdef XZ_DEC_PREALLOC
+#	define DEC_IS_PREALLOC(mode) ((mode) == XZ_PREALLOC)
+#else
+#	define DEC_IS_PREALLOC(mode) (false)
+#endif
+
+#ifdef XZ_DEC_DYNALLOC
+#	define DEC_IS_DYNALLOC(mode) ((mode) == XZ_DYNALLOC)
+#else
+#	define DEC_IS_DYNALLOC(mode) (false)
+#endif
+
+#if !defined(XZ_DEC_SINGLE)
+#	define DEC_IS_MULTI(mode) (true)
+#elif defined(XZ_DEC_PREALLOC) || defined(XZ_DEC_DYNALLOC)
+#	define DEC_IS_MULTI(mode) ((mode) != XZ_SINGLE)
+#else
+#	define DEC_IS_MULTI(mode) (false)
+#endif
+
+/*
+ * If any of the BCJ filter decoders are wanted, define XZ_DEC_BCJ.
+ * XZ_DEC_BCJ is used to enable generic support for BCJ decoders.
+ */
+#ifndef XZ_DEC_BCJ
+#	if defined(XZ_DEC_X86) || defined(XZ_DEC_POWERPC) \
+			|| defined(XZ_DEC_IA64) \
+			|| defined(XZ_DEC_ARM) || defined(XZ_DEC_ARMTHUMB) \
+			|| defined(XZ_DEC_SPARC) || defined(XZ_DEC_ARM64) \
+			|| defined(XZ_DEC_RISCV)
+#		define XZ_DEC_BCJ
+#	endif
+#endif
+
+struct xz_sha256 {
+	/* Buffered input data */
+	uint8_t data[64];
+
+	/* Internal state and the final hash value */
+	uint32_t state[8];
+
+	/* Size of the input data */
+	uint64_t size;
+};
+
+/* Reset the SHA-256 state to prepare for a new calculation. */
+XZ_EXTERN void xz_sha256_reset(struct xz_sha256 *s);
+
+/* Update the SHA-256 state with new data. */
+XZ_EXTERN void xz_sha256_update(const uint8_t *buf, size_t size,
+				struct xz_sha256 *s);
+
+/*
+ * Finish the SHA-256 calculation. Compare the result with the first 32 bytes
+ * from buf. Return true if the values are equal and false if they aren't.
+ */
+XZ_EXTERN bool xz_sha256_validate(const uint8_t *buf, struct xz_sha256 *s);
+
+/*
+ * Allocate memory for LZMA2 decoder. xz_dec_lzma2_reset() must be used
+ * before calling xz_dec_lzma2_run().
+ */
+XZ_EXTERN struct xz_dec_lzma2 *xz_dec_lzma2_create(enum xz_mode mode,
+						   uint32_t dict_max);
+
+/*
+ * Decode the LZMA2 properties (one byte) and reset the decoder. Return
+ * XZ_OK on success, XZ_MEMLIMIT_ERROR if the preallocated dictionary is not
+ * big enough, and XZ_OPTIONS_ERROR if props indicates something that this
+ * decoder doesn't support.
+ */
+XZ_EXTERN enum xz_ret xz_dec_lzma2_reset(struct xz_dec_lzma2 *s,
+					 uint8_t props);
+
+/* Decode raw LZMA2 stream from b->in to b->out. */
+XZ_EXTERN enum xz_ret xz_dec_lzma2_run(struct xz_dec_lzma2 *s,
+				       struct xz_buf *b);
+
+/* Free the memory allocated for the LZMA2 decoder. */
+XZ_EXTERN void xz_dec_lzma2_end(struct xz_dec_lzma2 *s);
+
+#ifdef XZ_DEC_BCJ
+/*
+ * Allocate memory for BCJ decoders. xz_dec_bcj_reset() must be used before
+ * calling xz_dec_bcj_run().
+ */
+XZ_EXTERN struct xz_dec_bcj *xz_dec_bcj_create(bool single_call);
+
+/*
+ * Decode the Filter ID of a BCJ filter. This implementation doesn't
+ * support custom start offsets, so no decoding of Filter Properties
+ * is needed. Returns XZ_OK if the given Filter ID is supported.
+ * Otherwise XZ_OPTIONS_ERROR is returned.
+ */
+XZ_EXTERN enum xz_ret xz_dec_bcj_reset(struct xz_dec_bcj *s, uint8_t id);
+
+/*
+ * Decode raw BCJ + LZMA2 stream. This must be used only if there actually is
+ * a BCJ filter in the chain. If the chain has only LZMA2, xz_dec_lzma2_run()
+ * must be called directly.
+ */
+XZ_EXTERN enum xz_ret xz_dec_bcj_run(struct xz_dec_bcj *s,
+				     struct xz_dec_lzma2 *lzma2,
+				     struct xz_buf *b);
+
+/* Free the memory allocated for the BCJ filters. */
+#define xz_dec_bcj_end(s) kfree(s)
+#endif
+
+#endif

android/app/src/main/cpp/xz/xz_sha256.c

@@ -0,0 +1,182 @@
+// SPDX-License-Identifier: 0BSD
+
+/*
+ * SHA-256
+ *
+ * This is based on the XZ Utils version which is based public domain code
+ * from Crypto++ Library 5.5.1 released in 2007: https://www.cryptopp.com/
+ *
+ * Authors: Wei Dai
+ *          Lasse Collin <lasse.collin@tukaani.org>
+ */
+
+#include "xz_private.h"
+
+static inline uint32_t
+rotr_32(uint32_t num, unsigned amount)
+{
+	return (num >> amount) | (num << (32 - amount));
+}
+
+#define blk0(i) (W[i] = get_be32(&data[4 * i]))
+#define blk2(i) (W[i & 15] += s1(W[(i - 2) & 15]) + W[(i - 7) & 15] \
+		+ s0(W[(i - 15) & 15]))
+
+#define Ch(x, y, z) (z ^ (x & (y ^ z)))
+#define Maj(x, y, z) ((x & (y ^ z)) + (y & z))
+
+#define a(i) T[(0 - i) & 7]
+#define b(i) T[(1 - i) & 7]
+#define c(i) T[(2 - i) & 7]
+#define d(i) T[(3 - i) & 7]
+#define e(i) T[(4 - i) & 7]
+#define f(i) T[(5 - i) & 7]
+#define g(i) T[(6 - i) & 7]
+#define h(i) T[(7 - i) & 7]
+
+#define R(i, j, blk) \
+	h(i) += S1(e(i)) + Ch(e(i), f(i), g(i)) + SHA256_K[i + j] + blk; \
+	d(i) += h(i); \
+	h(i) += S0(a(i)) + Maj(a(i), b(i), c(i))
+#define R0(i) R(i, 0, blk0(i))
+#define R2(i) R(i, j, blk2(i))
+
+#define S0(x) rotr_32(x ^ rotr_32(x ^ rotr_32(x, 9), 11), 2)
+#define S1(x) rotr_32(x ^ rotr_32(x ^ rotr_32(x, 14), 5), 6)
+#define s0(x) (rotr_32(x ^ rotr_32(x, 11), 7) ^ (x >> 3))
+#define s1(x) (rotr_32(x ^ rotr_32(x, 2), 17) ^ (x >> 10))
+
+static const uint32_t SHA256_K[64] = {
+	0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
+	0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
+	0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
+	0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
+	0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
+	0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
+	0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
+	0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
+	0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
+	0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
+	0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
+	0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
+	0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
+	0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
+	0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
+	0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
+};
+
+static void
+transform(uint32_t state[8], const uint8_t data[64])
+{
+	uint32_t W[16];
+	uint32_t T[8];
+	unsigned int j;
+
+	/* Copy state[] to working vars. */
+	memcpy(T, state, sizeof(T));
+
+	/* The first 16 operations unrolled */
+	R0( 0); R0( 1); R0( 2); R0( 3);
+	R0( 4); R0( 5); R0( 6); R0( 7);
+	R0( 8); R0( 9); R0(10); R0(11);
+	R0(12); R0(13); R0(14); R0(15);
+
+	/* The remaining 48 operations partially unrolled */
+	for (j = 16; j < 64; j += 16) {
+		R2( 0); R2( 1); R2( 2); R2( 3);
+		R2( 4); R2( 5); R2( 6); R2( 7);
+		R2( 8); R2( 9); R2(10); R2(11);
+		R2(12); R2(13); R2(14); R2(15);
+	}
+
+	/* Add the working vars back into state[]. */
+	state[0] += a(0);
+	state[1] += b(0);
+	state[2] += c(0);
+	state[3] += d(0);
+	state[4] += e(0);
+	state[5] += f(0);
+	state[6] += g(0);
+	state[7] += h(0);
+}
+
+XZ_EXTERN void xz_sha256_reset(struct xz_sha256 *s)
+{
+	static const uint32_t initial_state[8] = {
+		0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+		0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+	};
+
+	memcpy(s->state, initial_state, sizeof(initial_state));
+	s->size = 0;
+}
+
+XZ_EXTERN void xz_sha256_update(const uint8_t *buf, size_t size,
+				struct xz_sha256 *s)
+{
+	size_t copy_start;
+	size_t copy_size;
+
+	/*
+	 * Copy the input data into a properly aligned temporary buffer.
+	 * This way we can be called with arbitrarily sized buffers
+	 * (no need to be a multiple of 64 bytes).
+	 *
+	 * Full 64-byte chunks could be processed directly from buf with
+	 * unaligned access. It seemed to make very little difference in
+	 * speed on x86-64 though. Thus it was omitted.
+	 */
+	while (size > 0) {
+		copy_start = s->size & 0x3F;
+		copy_size = 64 - copy_start;
+		if (copy_size > size)
+			copy_size = size;
+
+		memcpy(s->data + copy_start, buf, copy_size);
+
+		buf += copy_size;
+		size -= copy_size;
+		s->size += copy_size;
+
+		if ((s->size & 0x3F) == 0)
+			transform(s->state, s->data);
+	}
+}
+
+XZ_EXTERN bool xz_sha256_validate(const uint8_t *buf, struct xz_sha256 *s)
+{
+	/*
+	 * Add padding as described in RFC 3174 (it describes SHA-1 but
+	 * the same padding style is used for SHA-256 too).
+	 */
+	size_t i = s->size & 0x3F;
+	s->data[i++] = 0x80;
+
+	while (i != 64 - 8) {
+		if (i == 64) {
+			transform(s->state, s->data);
+			i = 0;
+		}
+
+		s->data[i++] = 0x00;
+	}
+
+	/* Convert the message size from bytes to bits. */
+	s->size *= 8;
+
+	/*
+	 * Store the message size in big endian byte order and
+	 * calculate the final hash value.
+	 */
+	for (i = 0; i < 8; ++i)
+		s->data[64 - 8 + i] = (uint8_t)(s->size >> ((7 - i) * 8));
+
+	transform(s->state, s->data);
+
+	/* Compare if the hash value matches the first 32 bytes in buf. */
+	for (i = 0; i < 8; ++i)
+		if (get_unaligned_be32(buf + 4 * i) != s->state[i])
+			return false;
+
+	return true;
+}

android/app/src/main/cpp/xz/xz_stream.h

@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: 0BSD */
+
+/*
+ * Definitions for handling the .xz file format
+ *
+ * Author: Lasse Collin <lasse.collin@tukaani.org>
+ */
+
+#ifndef XZ_STREAM_H
+#define XZ_STREAM_H
+
+#if defined(__KERNEL__) && !XZ_INTERNAL_CRC32
+#	include <linux/crc32.h>
+#	undef crc32
+#	define xz_crc32(buf, size, crc) \
+		(~crc32_le(~(uint32_t)(crc), buf, size))
+#endif
+
+/*
+ * See the .xz file format specification at
+ * https://tukaani.org/xz/xz-file-format.txt
+ * to understand the container format.
+ */
+
+#define STREAM_HEADER_SIZE 12
+
+#define HEADER_MAGIC "\3757zXZ"
+#define HEADER_MAGIC_SIZE 6
+
+#define FOOTER_MAGIC "YZ"
+#define FOOTER_MAGIC_SIZE 2
+
+/*
+ * Variable-length integer can hold a 63-bit unsigned integer or a special
+ * value indicating that the value is unknown.
+ *
+ * Experimental: vli_type can be defined to uint32_t to save a few bytes
+ * in code size (no effect on speed). Doing so limits the uncompressed and
+ * compressed size of the file to less than 256 MiB and may also weaken
+ * error detection slightly.
+ */
+typedef uint64_t vli_type;
+
+#define VLI_MAX ((vli_type)-1 / 2)
+#define VLI_UNKNOWN ((vli_type)-1)
+
+/* Maximum encoded size of a VLI */
+#define VLI_BYTES_MAX (sizeof(vli_type) * 8 / 7)
+
+/* Integrity Check types */
+enum xz_check {
+	XZ_CHECK_NONE = 0,
+	XZ_CHECK_CRC32 = 1,
+	XZ_CHECK_CRC64 = 4,
+	XZ_CHECK_SHA256 = 10
+};
+
+/* Maximum possible Check ID */
+#define XZ_CHECK_MAX 15
+
+#endif

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

@@ -1,112 +0,0 @@
-package me.kavishdevar.aln
-
-import android.annotation.SuppressLint
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.service.quicksettings.Tile
-import android.service.quicksettings.TileService
-import android.util.Log
-
-class AirPodsQSService: TileService() {
-    private val ancModes = listOf(NoiseControlMode.NOISE_CANCELLATION.name, NoiseControlMode.TRANSPARENCY.name, NoiseControlMode.ADAPTIVE.name)
-    private var currentModeIndex = 2
-    private lateinit var ancStatusReceiver: BroadcastReceiver
-    private lateinit var availabilityReceiver: BroadcastReceiver
-
-    @SuppressLint("InlinedApi")
-    override fun onStartListening() {
-        super.onStartListening()
-        currentModeIndex = (ServiceManager.getService()?.getANC()?.minus(1)) ?: -1
-        if (currentModeIndex == -1) {
-            currentModeIndex = 2
-        }
-
-        if (ServiceManager.getService() == null) {
-            qsTile.state = Tile.STATE_UNAVAILABLE
-            qsTile.updateTile()
-        }
-        if (ServiceManager.getService()?.isConnected == true) {
-            qsTile.state = Tile.STATE_ACTIVE
-            qsTile.updateTile()
-        }
-        else {
-            qsTile.state = Tile.STATE_UNAVAILABLE
-            qsTile.updateTile()
-        }
-
-        ancStatusReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                val ancStatus = intent.getIntExtra("data", 4)
-                currentModeIndex = if (ancStatus == 2) 0 else if (ancStatus == 3) 1 else if (ancStatus == 4) 2 else 2
-                updateTile()
-            }
-        }
-
-        availabilityReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                if (intent.action == AirPodsNotifications.AIRPODS_CONNECTED) {
-                    qsTile.state = Tile.STATE_ACTIVE
-                    qsTile.updateTile()
-                }
-                else if (intent.action == AirPodsNotifications.AIRPODS_DISCONNECTED) {
-                    qsTile.state = Tile.STATE_UNAVAILABLE
-                    qsTile.updateTile()
-                }
-            }
-        }
-
-        registerReceiver(ancStatusReceiver, IntentFilter(AirPodsNotifications.ANC_DATA), RECEIVER_EXPORTED)
-
-        qsTile.state = if (ServiceManager.getService()?.isConnected == true) Tile.STATE_ACTIVE else Tile.STATE_UNAVAILABLE
-        val ancIndex = ServiceManager.getService()?.getANC()
-        currentModeIndex = if (ancIndex != null) { if (ancIndex == 2) 0 else if (ancIndex == 3) 1 else if (ancIndex == 4) 2 else 2 } else 0
-        updateTile()
-    }
-
-    override fun onStopListening() {
-        super.onStopListening()
-        try {
-            unregisterReceiver(ancStatusReceiver)
-        }
-        catch (
-            _: IllegalArgumentException
-        )
-        {
-            Log.e("QuickSettingTileService", "Receiver not registered")
-        }
-        try {
-            unregisterReceiver(availabilityReceiver)
-        }
-        catch (
-            _: IllegalArgumentException
-        )
-        {
-            Log.e("QuickSettingTileService", "Receiver not registered")
-        }
-    }
-
-    override fun onClick() {
-        super.onClick()
-        Log.d("QuickSettingTileService", "ANC tile clicked")
-        currentModeIndex = (currentModeIndex + 1) % ancModes.size
-        Log.d("QuickSettingTileService", "New mode index: $currentModeIndex, would be set to ${currentModeIndex + 1}")
-        switchAncMode()
-    }
-
-    private fun updateTile() {
-        val currentMode = ancModes[currentModeIndex % ancModes.size]
-        qsTile.label = currentMode.replace("_", " ").lowercase().replaceFirstChar { it.uppercase() }
-        qsTile.state = Tile.STATE_ACTIVE
-        qsTile.updateTile()
-    }
-
-    private fun switchAncMode() {
-        val airPodsService = ServiceManager.getService()
-        Log.d("QuickSettingTileService", "Setting ANC mode to ${currentModeIndex + 2}")
-        airPodsService?.setANCMode(currentModeIndex + 2)
-        Log.d("QuickSettingTileService", "ANC mode set to ${currentModeIndex + 2}")
-        updateTile()
-    }
-}

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

@@ -1,736 +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.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 android.widget.RemoteViews
-import androidx.core.app.NotificationCompat
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import org.lsposed.hiddenapibypass.HiddenApiBypass
-
-object ServiceManager {
-    private var service: AirPodsService? = null
-    @Synchronized
-    fun getService(): AirPodsService? {
-        return service
-    }
-    @Synchronized
-    fun setService(service: AirPodsService?) {
-        this.service = service
-    }
-}
-
-@Suppress("unused")
-class AirPodsService: Service() {
-    inner class LocalBinder : Binder() {
-        fun getService(): AirPodsService = this@AirPodsService
-    }
-
-    override fun onBind(intent: Intent?): IBinder {
-        return LocalBinder()
-    }
-
-    var popupShown = false
-
-    fun showPopup(service: Service, name: String) {
-        if (popupShown) {
-            return
-        }
-        val window = Window(service.applicationContext)
-        window.open(name, batteryNotification)
-        popupShown = true
-    }
-
-    @Suppress("ClassName")
-    private object bluetoothReceiver: BroadcastReceiver() {
-        @SuppressLint("NewApi", "MissingPermission")
-        override fun onReceive(context: Context?, intent: Intent) {
-            val bluetoothDevice =
-                intent.getParcelableExtra("android.bluetooth.device.extra.DEVICE", BluetoothDevice::class.java)
-            val action = intent.action
-            val context = context?.applicationContext
-            val name = context?.getSharedPreferences("settings", MODE_PRIVATE)?.getString("name", bluetoothDevice?.name)
-            if (bluetoothDevice != null && action != null && !action.isEmpty()) {
-                Log.d("AirPodsService", "Received bluetooth connection broadcast")
-                if (BluetoothDevice.ACTION_ACL_CONNECTED == action) {
-                    val uuid = ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a")
-                    if (bluetoothDevice.uuids.contains(uuid)) {
-                        val intent = Intent(AirPodsNotifications.AIRPODS_CONNECTION_DETECTED)
-                        intent.putExtra("name", name)
-                        intent.putExtra("device", bluetoothDevice)
-                        context?.sendBroadcast(intent)
-                    }
-                }
-
-                // Airpods disconnected, remove notification but leave the scanner going.
-                if (BluetoothDevice.ACTION_ACL_DISCONNECTED == action
-                    || BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED == action
-                ) {
-                    context?.sendBroadcast(
-                        Intent(AirPodsNotifications.AIRPODS_DISCONNECTED)
-                    )
-                }
-            }
-        }
-    }
-
-    var isConnected = false
-    var device: BluetoothDevice? = null
-
-    private lateinit var earReceiver: BroadcastReceiver
-
-    fun startForegroundNotification() {
-        val notificationChannel = NotificationChannel(
-            "background_service_status",
-            "Background Service Status",
-            NotificationManager.IMPORTANCE_LOW
-        )
-        val notificationManager = getSystemService(NotificationManager::class.java)
-        notificationManager.createNotificationChannel(notificationChannel)
-        val notification = NotificationCompat.Builder(this, "background_service_status")
-            .setSmallIcon(R.drawable.airpods)
-            .setContentTitle("AirPods Service")
-            .setContentText("Service is running in the background")
-            .setCategory(Notification.CATEGORY_SERVICE)
-            .setPriority(NotificationCompat.PRIORITY_LOW)
-            .build()
-
-        try {
-            startForeground(1, notification)
-        }
-        catch (e: Exception) {
-            e.printStackTrace()
-        }
-    }
-
-    fun updateNotificationContent(connected: Boolean, airpodsName: String? = null, batteryList: List<Battery>? = null) {
-        val notificationManager = getSystemService(NotificationManager::class.java)
-        val textColor = this.getSharedPreferences("settings", MODE_PRIVATE).getLong("textColor", 0)
-        var updatedNotification: Notification? = null
-
-        if (connected) {
-            val collapsedRemoteViews = RemoteViews(packageName, R.layout.notification)
-            val expandedRemoteViews = RemoteViews(packageName, R.layout.notification_expanded)
-            collapsedRemoteViews.setTextColor(R.id.notification_title, textColor.toInt())
-
-            collapsedRemoteViews.setTextViewText(R.id.notification_title, "Connected to $airpodsName")
-            expandedRemoteViews.setTextViewText(
-                R.id.notification_title,
-                "Connected to $airpodsName"
-            )
-            expandedRemoteViews.setTextViewText(
-                R.id.left_battery_notification,
-                batteryList?.find { it.component == BatteryComponent.LEFT }?.let {
-                    if (it.status != BatteryStatus.DISCONNECTED) {
-                        "Left ${if (it.status == BatteryStatus.CHARGING) "⚡" else ""} ${it.level}%"
-                    } else {
-                        ""
-                    }
-                } ?: "")
-            expandedRemoteViews.setTextViewText(
-                R.id.right_battery_notification,
-                batteryList?.find { it.component == BatteryComponent.RIGHT }?.let {
-                    if (it.status != BatteryStatus.DISCONNECTED) {
-                        "Right ${if (it.status == BatteryStatus.CHARGING) "⚡" else ""} ${it.level}%"
-                    } else {
-                        ""
-                    }
-                } ?: "")
-            expandedRemoteViews.setTextViewText(
-                R.id.case_battery_notification,
-                batteryList?.find { it.component == BatteryComponent.CASE }?.let {
-                    if (it.status != BatteryStatus.DISCONNECTED) {
-                        "Case ${if (it.status == BatteryStatus.CHARGING) "⚡" else ""} ${it.level}%"
-                    } else {
-                        ""
-                    }
-                } ?: "")
-            expandedRemoteViews.setTextColor(R.id.notification_title, textColor.toInt())
-            expandedRemoteViews.setTextColor(R.id.left_battery_notification, textColor.toInt())
-            expandedRemoteViews.setTextColor(R.id.right_battery_notification, textColor.toInt())
-            expandedRemoteViews.setTextColor(R.id.case_battery_notification, textColor.toInt())
-            updatedNotification = NotificationCompat.Builder(this, "background_service_status")
-                .setSmallIcon(R.drawable.airpods)
-                .setStyle(NotificationCompat.DecoratedCustomViewStyle())
-                .setCustomContentView(collapsedRemoteViews)
-                .setCustomBigContentView(expandedRemoteViews)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .setCategory(Notification.CATEGORY_SERVICE)
-                .setOngoing(true)
-                .build()
-        } else {
-            updatedNotification = NotificationCompat.Builder(this, "background_service_status")
-                .setSmallIcon(R.drawable.airpods)
-                .setContentTitle("AirPods Service")
-                .setContentText("Service is running in the background!")
-                .setCategory(Notification.CATEGORY_SERVICE)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .build()
-        }
-
-        // Notify the NotificationManager with the same ID
-        notificationManager.notify(1, updatedNotification)
-    }
-
-    private lateinit var connectionReceiver: BroadcastReceiver
-    private lateinit var disconnectionReceiver: BroadcastReceiver
-
-    @SuppressLint("InlinedApi", "MissingPermission")
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        Log.d("AirPodsService", "Service started")
-        ServiceManager.setService(this)
-        startForegroundNotification()
-        registerReceiver(bluetoothReceiver, BluetoothReceiver.buildFilter(), RECEIVER_EXPORTED)
-
-        connectionReceiver = object: BroadcastReceiver() {
-            override fun onReceive(context: Context?, intent: Intent?) {
-                if (intent?.action == AirPodsNotifications.AIRPODS_CONNECTION_DETECTED) {
-                    val name = this@AirPodsService.getSharedPreferences("settings", MODE_PRIVATE)
-                        .getString("name", device?.name)
-                    Log.d("AirPodsService", "$name connected")
-                    device = intent.getParcelableExtra("device", BluetoothDevice::class.java)!!
-                    showPopup(this@AirPodsService, name.toString())
-                    connectToSocket(device!!)
-                    updateNotificationContent(true, name.toString(), batteryNotification.getBattery())
-                }
-                else if (intent?.action == AirPodsNotifications.AIRPODS_DISCONNECTED) {
-                    device = null
-                    isConnected = false
-                    popupShown = false
-                    updateNotificationContent(false)
-                }
-            }
-        }
-
-        val intentFilter = IntentFilter().apply {
-            addAction(AirPodsNotifications.AIRPODS_CONNECTION_DETECTED)
-            addAction(AirPodsNotifications.AIRPODS_DISCONNECTED)
-        }
-        registerReceiver(connectionReceiver, intentFilter, RECEIVER_EXPORTED)
-
-        val bluetoothAdapter = getSystemService(BluetoothManager::class.java).adapter
-        bluetoothAdapter.bondedDevices.forEach { device ->
-            if (device.uuids.contains(ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a"))) {
-                bluetoothAdapter.getProfileProxy(this, object : BluetoothProfile.ServiceListener {
-                    override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
-                        if (profile == BluetoothProfile.A2DP) {
-                            val connectedDevices = proxy.connectedDevices
-                            if (connectedDevices.isNotEmpty()) {
-                                connectToSocket(device)
-                                this@AirPodsService.sendBroadcast(
-                                    Intent(AirPodsNotifications.AIRPODS_CONNECTED)
-                                )
-                            }
-                        }
-                        bluetoothAdapter.closeProfileProxy(profile, proxy)
-                    }
-
-                    override fun onServiceDisconnected(profile: Int) { }
-                }, BluetoothProfile.A2DP)
-            }
-        }
-
-        return START_STICKY
-    }
-
-    private lateinit var socket: BluetoothSocket
-
-    @SuppressLint("MissingPermission", "UnspecifiedRegisterReceiverFlag")
-    fun connectToSocket(device: BluetoothDevice) {
-        HiddenApiBypass.addHiddenApiExemptions("Landroid/bluetooth/BluetoothSocket;")
-        val uuid: ParcelUuid = ParcelUuid.fromString("74ec2172-0bad-4d01-8f77-997b2be0722a")
-
-        if (isConnected != true) {
-
-
-            try {
-                socket = HiddenApiBypass.newInstance(
-                    BluetoothSocket::class.java,
-                    3,
-                    true,
-                    true,
-                    device,
-                    0x1001,
-                    uuid
-                ) as BluetoothSocket
-            } catch (
-                e: Exception
-            ) {
-                e.printStackTrace()
-                try {
-                    socket = HiddenApiBypass.newInstance(
-                        BluetoothSocket::class.java,
-                        3,
-                        1,
-                        true,
-                        true,
-                        device,
-                        0x1001,
-                        uuid
-                    ) as BluetoothSocket
-                } catch (
-                    e: Exception
-                ) {
-                    e.printStackTrace()
-                }
-            }
-
-            try {
-                socket.connect()
-                this@AirPodsService.device = device
-                isConnected = true
-                socket.let { it ->
-                    it.outputStream.write(Enums.HANDSHAKE.value)
-                    it.outputStream.flush()
-                    it.outputStream.write(Enums.SET_SPECIFIC_FEATURES.value)
-                    it.outputStream.flush()
-                    it.outputStream.write(Enums.REQUEST_NOTIFICATIONS.value)
-                    it.outputStream.flush()
-                    sendBroadcast(
-                        Intent(AirPodsNotifications.AIRPODS_CONNECTED)
-                            .putExtra("device", device)
-                    )
-
-                    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)")
-//                                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
-                                    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)
-                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                                        this@AirPodsService.registerReceiver(
-                                            earReceiver, earIntentFilter,
-                                            RECEIVER_EXPORTED
-                                        )
-                                    } else {
-                                        this@AirPodsService.registerReceiver(
-                                            earReceiver,
-                                            earIntentFilter
-                                        )
-                                    }
-                                } 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())
-                                        )
-                                    })
-                                    updateNotificationContent(
-                                        true,
-                                        this@AirPodsService.getSharedPreferences(
-                                            "settings",
-                                            MODE_PRIVATE
-                                        ).getString("name", device.name),
-                                        batteryNotification.getBattery()
-                                    )
-                                    for (battery in batteryNotification.getBattery()) {
-                                        Log.d(
-                                            "AirPods Parser",
-                                            "${battery.getComponentName()}: ${battery.getStatusName()} at ${battery.level}% "
-                                        )
-                                    }
-                                    if (batteryNotification.getBattery()[0].status == 1 && batteryNotification.getBattery()[1].status == 1) {
-                                        disconnectAudio(this@AirPodsService, device)
-                                    } else {
-                                        connectAudio(this@AirPodsService, device)
-                                    }
-                                } 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")
-                        isConnected = false
-                        socket.close()
-                        sendBroadcast(Intent(AirPodsNotifications.AIRPODS_DISCONNECTED))
-                    }
-                }
-            } catch (e: Exception) {
-                e.printStackTrace()
-                Log.d("AirPodsService", "Failed to connect to socket")
-            }
-        }
-    }
-
-
-    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)
-        socket.outputStream?.flush()
-    }
-
-    fun setOffListeningMode(enabled: Boolean) {
-        socket.outputStream?.write(byteArrayOf(0x04, 0x00 ,0x04, 0x00, 0x09, 0x00, 0x34, if (enabled) 0x01 else 0x02, 0x00, 0x00, 0x00))
-        socket.outputStream?.flush()
-    }
-
-    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()
-    }
-
-    fun setPressSpeed(speed: Int) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x17, speed.toByte(), 0x00, 0x00, 0x00)
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    fun setPressAndHoldDuration(speed: Int) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x18, speed.toByte(), 0x00, 0x00, 0x00)
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    fun setNoiseCancellationWithOnePod(enabled: Boolean) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1B, if (enabled) 0x01 else 0x02, 0x00, 0x00, 0x00)
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    fun setVolumeControl(enabled: Boolean) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x25, if (enabled) 0x01 else 0x02, 0x00, 0x00, 0x00)
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    fun setVolumeSwipeSpeed(speed: Int) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x23, speed.toByte(), 0x00, 0x00, 0x00)
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    fun setToneVolume(volume: Int) {
-        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1F, volume.toByte(), 0x50, 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
-    }
-
-    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 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")
-    }
-
-    fun setPVEnabled(enabled: Boolean) {
-        var hex = "04 00 04 00 09 00 26 ${if (enabled) "01" else "02"} 00 00 00"
-        var bytes = hex.split(" ").map { it.toInt(16).toByte() }.toByteArray()
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-        hex = "04 00 04 00 17 00 00 00 10 00 12 00 08 E${if (enabled) "6" else "5"} 05 10 02 42 0B 08 50 10 02 1A 05 02 ${if (enabled) "32" else "00"} 00 00 00"
-        bytes = hex.split(" ").map { it.toInt(16).toByte() }.toByteArray()
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    fun setLoudSoundReduction(enabled: Boolean) {
-        val hex = "52 1B 00 0${if (enabled) "1" else "0"}"
-        val bytes = hex.split(" ").map { it.toInt(16).toByte() }.toByteArray()
-        socket.outputStream?.write(bytes)
-        socket.outputStream?.flush()
-    }
-
-    override fun onDestroy() {
-        Log.d("AirPodsService", "Service stopped is being destroyed for some reason!")
-        try {
-            unregisterReceiver(bluetoothReceiver)
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        try {
-            unregisterReceiver(connectionReceiver)
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        try {
-            unregisterReceiver(disconnectionReceiver)
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        try {
-            unregisterReceiver(earReceiver)
-        } catch (e: Exception) {
-            e.printStackTrace()
-        }
-        super.onDestroy()
-    }
-}

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

@@ -1,44 +0,0 @@
-package me.kavishdevar.aln
-
-import android.appwidget.AppWidgetManager
-import android.appwidget.AppWidgetProvider
-import android.content.Context
-import android.widget.RemoteViews
-
-/**
- * Implementation of App Widget functionality.
- */
-class BatteryWidget : AppWidgetProvider() {
-    override fun onUpdate(
-        context: Context,
-        appWidgetManager: AppWidgetManager,
-        appWidgetIds: IntArray
-    ) {
-        // There may be multiple widgets active, so update all of them
-        for (appWidgetId in appWidgetIds) {
-            updateAppWidget(context, appWidgetManager, appWidgetId)
-        }
-    }
-
-    override fun onEnabled(context: Context) {
-        // Enter relevant functionality for when the first widget is created
-    }
-
-    override fun onDisabled(context: Context) {
-        // Enter relevant functionality for when the last widget is disabled
-    }
-}
-
-internal fun updateAppWidget(
-    context: Context,
-    appWidgetManager: AppWidgetManager,
-    appWidgetId: Int
-) {
-    val widgetText = context.getString(R.string.appwidget_text)
-    // Construct the RemoteViews object
-    val views = RemoteViews(context.packageName, R.layout.battery_widget)
-    views.setTextViewText(R.id.appwidget_text, widgetText)
-
-    // Instruct the widget manager to update the widget
-    appWidgetManager.updateAppWidget(appWidgetId, views)
-}

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

@@ -1,14 +0,0 @@
-package me.kavishdevar.aln
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-
-class BootReceiver: BroadcastReceiver() {
-    override fun onReceive(context: Context?, intent: Intent?) {
-        when (intent?.action) {
-            Intent.ACTION_MY_PACKAGE_REPLACED -> try { context?.startForegroundService(Intent(context, AirPodsService::class.java)) } catch (e: Exception) { e.printStackTrace() }
-            Intent.ACTION_BOOT_COMPLETED -> try { context?.startForegroundService(Intent(context, AirPodsService::class.java)) } catch (e: Exception) { e.printStackTrace() }
-        }
-    }
-}

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

@@ -1,261 +0,0 @@
-@file:OptIn(ExperimentalHazeMaterialsApi::class)
-
-package me.kavishdevar.aln
-
-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.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.Spacer
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.fillMaxWidth
-import androidx.compose.foundation.layout.height
-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.material3.TopAppBarDefaults
-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
-import dev.chrisbanes.haze.HazeState
-import dev.chrisbanes.haze.haze
-import dev.chrisbanes.haze.hazeChild
-import dev.chrisbanes.haze.materials.CupertinoMaterials
-import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
-
-@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
-@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
-@Composable
-fun DebugScreen(navController: NavController) {
-    val hazeState = remember { HazeState() }
-    val text = remember { mutableStateListOf<String>("Log Start") }
-    val context = LocalContext.current
-    val listState = rememberLazyListState()
-
-    Scaffold(
-        topBar = {
-            TopAppBar(
-                title = { Text("Debug") },
-                navigationIcon = {
-                    IconButton(onClick = {
-                        navController.popBackStack()
-                    }) {
-                        Icon(Icons.AutoMirrored.Filled.ArrowBack, null)
-                    }
-                },
-                modifier = Modifier
-                    .hazeChild(
-                        state = hazeState,
-                        style = CupertinoMaterials.thin(),
-                        block = {
-                            alpha = if (listState.firstVisibleItemIndex > 0) {
-                                1f
-                            } else {
-                                0f
-                            }
-                        }
-                    ),
-                colors = TopAppBarDefaults.topAppBarColors(
-                    containerColor = Color.Transparent
-                )
-            )
-        },
-        containerColor = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(0xFF000000)
-        else Color(0xFFF2F2F7),
-    ) { paddingValues ->
-        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) })
-                }
-            }
-        }
-
-        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()
-                .imePadding()
-                .haze(hazeState)
-                .padding(top = 0.dp)
-        ) {
-            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)
-
-                        if (message == "Log Start") {
-                            Spacer(modifier = Modifier.height(115.dp))
-                        }
-
-                        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,
-                                    fontFamily = FontFamily(Font(R.font.hack)),
-                                    color = if (MaterialTheme.colorScheme.surface.luminance() < 0.5) Color(
-                                        0xFF000000
-                                    )
-                                    else Color(0xFF000000),
-                                    modifier = Modifier.weight(1f)
-                                )
-
-                                if (isSent) {
-                                    Text(">", color = Color(0xFF00796B), fontSize = 16.sp)
-                                }
-                            }
-                        }
-                    }
-                }
-            )
-            Spacer(modifier = Modifier.height(8.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)
-            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(bottom = 5.dp),
-                    trailingIcon = {
-                        IconButton(
-                            onClick = {
-                                airPodsService.value?.sendPacket(packet.value.text)
-                                text.add(packet.value.text)
-                                packet.value = TextFieldValue("")
-                            }
-                        ) {
-                            @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,187 +0,0 @@
-package me.kavishdevar.aln
-
-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.os.Bundle
-import android.os.IBinder
-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.padding
-import androidx.compose.material3.Button
-import androidx.compose.material3.ExperimentalMaterial3Api
-import androidx.compose.material3.MaterialTheme
-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.graphics.toArgb
-import androidx.compose.ui.platform.LocalContext
-import androidx.compose.ui.unit.dp
-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.rememberMultiplePermissionsState
-import me.kavishdevar.aln.ui.theme.ALNTheme
-
-lateinit var serviceConnection: ServiceConnection
-lateinit var connectionStatusReceiver: BroadcastReceiver
-
-@ExperimentalMaterial3Api
-class MainActivity : ComponentActivity() {
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        enableEdgeToEdge()
-        setContent {
-            ALNTheme {
-                getSharedPreferences("settings", MODE_PRIVATE).edit().putLong("textColor",
-                    MaterialTheme.colorScheme.onSurface.toArgb().toLong()).apply()
-                Main()
-                startService(Intent(this, AirPodsService::class.java))
-            }
-        }
-    }
-    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")
-        }
-        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()
-    }
-}
-
-@SuppressLint("MissingPermission", "InlinedApi")
-@OptIn(ExperimentalPermissionsApi::class)
-@Composable
-fun Main() {
-    val isConnected = remember { mutableStateOf(false) }
-    val permissionState = rememberMultiplePermissionsState(
-        permissions = listOf(
-            "android.permission.BLUETOOTH_CONNECT",
-            "android.permission.POST_NOTIFICATIONS"
-        )
-    )
-
-    val airPodsService = remember { mutableStateOf<AirPodsService?>(null) }
-    if (permissionState.allPermissionsGranted) {
-        val context = LocalContext.current
-        val navController = rememberNavController()
-
-        connectionStatusReceiver = object : BroadcastReceiver() {
-            override fun onReceive(context: Context, intent: Intent) {
-                if (intent.action == AirPodsNotifications.AIRPODS_CONNECTED) {
-                    Log.d("MainActivity", "AirPods Connected intent received")
-                    isConnected.value = true
-                }
-                else if (intent.action == AirPodsNotifications.AIRPODS_DISCONNECTED) {
-                    Log.d("MainActivity", "AirPods Disconnected intent received")
-                    isConnected.value = false
-                }
-            }
-        }
-
-        val filter = IntentFilter().apply {
-            addAction(AirPodsNotifications.AIRPODS_CONNECTED)
-            addAction(AirPodsNotifications.AIRPODS_DISCONNECTED)
-            addAction(AirPodsNotifications.AIRPODS_CONNECTION_DETECTED)
-        }
-        Log.d("MainActivity", "Registering Receiver")
-        context.registerReceiver(connectionStatusReceiver, filter, Context.RECEIVER_EXPORTED)
-        Log.d("MainActivity", "Registered Receiver")
-
-        NavHost(
-            navController = navController,
-            startDestination = "settings",
-            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("settings") {
-                if (airPodsService.value != null) {
-                    AirPodsSettingsScreen(
-                        dev = airPodsService.value?.device,
-                        service = airPodsService.value!!,
-                        navController = navController,
-                        isConnected = isConnected.value
-                    )
-                }
-            }
-            composable("debug") {
-                DebugScreen(navController = navController)
-            }
-        }
-
-         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 {
-        // Permission is not granted, request it
-        Column (
-            modifier = Modifier.padding(24.dp),
-        ){
-            val textToShow = if (permissionState.shouldShowRationale) {
-                // If the user has denied the permission but not permanently, explain why it's needed.
-                "Please enable Bluetooth and Notification permissions to use the app. The Nearby Devices is required to connect to your AirPods, and the notification is required to show the AirPods battery status."
-            } else {
-                // If the user has permanently denied the permission, inform them to enable it in settings.
-                "Please enable Bluetooth and Notification permissions in the app settings to use the app."
-            }
-            Text(textToShow)
-            Button(onClick = { permissionState.launchMultiplePermissionRequest() }) {
-                Text("Request permission")
-            }
-        }
-    }
-}

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/OldAirPodsService.kt

@@ -1,463 +0,0 @@
-//@file:Suppress("unused")
-//
-//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.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
-//
-//object ServiceManager {
-//    private var service: OldAirPodsService? = null
-//    @Synchronized
-//    fun getService(): OldAirPodsService? {
-//        return service
-//    }
-//    @Synchronized
-//    fun setService(service: OldAirPodsService?) {
-//        this.service = service
-//    }
-//}
-//
-//class OldAirPodsService : Service() {
-//    inner class LocalBinder : Binder() {
-//        fun getService(): OldAirPodsService = this@OldAirPodsService
-//    }
-//
-//    override fun onBind(intent: Intent?): IBinder {
-//        return LocalBinder()
-//    }
-//
-//    var isConnected: 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 setOffListeningMode(enabled: Boolean) {
-//        socket?.outputStream?.write(byteArrayOf(0x04, 0x00 ,0x04, 0x00, 0x09, 0x00, 0x34, if (enabled) 0x01 else 0x02, 0x00, 0x00, 0x00))
-//    }
-//
-//    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()
-//    }
-//
-//    fun setPressSpeed(speed: Int) {
-//        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x17, speed.toByte(), 0x00, 0x00, 0x00)
-//        socket?.outputStream?.write(bytes)
-//        socket?.outputStream?.flush()
-//    }
-//
-//    fun setPressAndHoldDuration(speed: Int) {
-//        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x18, speed.toByte(), 0x00, 0x00, 0x00)
-//        socket?.outputStream?.write(bytes)
-//        socket?.outputStream?.flush()
-//    }
-//
-//    fun setNoiseCancellationWithOnePod(enabled: Boolean) {
-//        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1B, if (enabled) 0x01 else 0x02, 0x00, 0x00, 0x00)
-//        socket?.outputStream?.write(bytes)
-//        socket?.outputStream?.flush()
-//    }
-//
-//    fun setVolumeControl(enabled: Boolean) {
-//        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x25, if (enabled) 0x01 else 0x02, 0x00, 0x00, 0x00)
-//        socket?.outputStream?.write(bytes)
-//        socket?.outputStream?.flush()
-//    }
-//
-//    fun setVolumeSwipeSpeed(speed: Int) {
-//        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x23, speed.toByte(), 0x00, 0x00, 0x00)
-//        socket?.outputStream?.write(bytes)
-//        socket?.outputStream?.flush()
-//    }
-//
-//    fun setToneVolume(volume: Int) {
-//        val bytes = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1F, volume.toByte(), 0x50, 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 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 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("OldAirPodsService", "setName: $name, sent packet: $hex")
-//    }
-//
-//    @SuppressLint("MissingPermission", "InlinedApi")
-//    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-//
-//        val notification = createNotification()
-//        startForeground(1, notification)
-//
-//        ServiceManager.setService(this)
-//
-//        if (isConnected) {
-//            return START_STICKY
-//        }
-//        isConnected = 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@OldAirPodsService.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@OldAirPodsService.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@OldAirPodsService, device)
-//                                                justEnabledA2dp = true
-//                                                val bluetoothAdapter = this@OldAirPodsService.getSystemService(BluetoothManager::class.java).adapter
-//                                                bluetoothAdapter.getProfileProxy(
-//                                                    this@OldAirPodsService, 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@OldAirPodsService, device)
-//                                            }
-//
-//                                            inEarData = newInEarData
-//
-//                                            if (inEar == true) {
-//                                                if (!justEnabledA2dp) {
-//                                                    justEnabledA2dp = false
-//                                                    MediaController.sendPlay()
-//                                                }
-//                                            } else {
-//                                                MediaController.sendPause()
-//                                            }
-//                                        }
-//                                    }
-//                                }
-//
-//                                val earIntentFilter = IntentFilter(AirPodsNotifications.EAR_DETECTION_DATA)
-//                                this@OldAirPodsService.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}% ")
-//                                }
-////                                if both are charging, disconnect audio profiles
-//                                if (batteryNotification.getBattery()[0].status == 1 && batteryNotification.getBattery()[1].status == 1) {
-//                                    disconnectAudio(this@OldAirPodsService, device)
-//                                }
-//                                else {
-//                                    connectAudio(this@OldAirPodsService, device)
-//                                }
-////                                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")
-//                    isConnected = false
-//                    this@OldAirPodsService.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()
-//        isConnected = false
-//        ServiceManager.setService(null)
-//    }
-//
-//    fun setPVEnabled(enabled: Boolean) {
-//        var hex = "04 00 04 00 09 00 26 ${if (enabled) "01" else "02"} 00 00 00"
-//        var bytes = hex.split(" ").map { it.toInt(16).toByte() }.toByteArray()
-//        socket?.outputStream?.write(bytes)
-//        hex = "04 00 04 00 17 00 00 00 10 00 12 00 08 E${if (enabled) "6" else "5"} 05 10 02 42 0B 08 50 10 02 1A 05 02 ${if (enabled) "32" else "00"} 00 00 00"
-//        bytes = hex.split(" ").map { it.toInt(16).toByte() }.toByteArray()
-//        socket?.outputStream?.write(bytes)
-//    }
-//
-//    fun setLoudSoundReduction(enabled: Boolean) {
-//        val hex = "52 1B 00 0${if (enabled) "1" else "0"}"
-//        val bytes = hex.split(" ").map { it.toInt(16).toByte() }.toByteArray()
-//        socket?.outputStream?.write(bytes)
-//    }
-//}

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

@@ -1,208 +0,0 @@
-@file:Suppress("unused")
-
-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
-        }
-    }
-}
-
-enum class NoiseControlMode {
-    OFF,  NOISE_CANCELLATION, TRANSPARENCY, ADAPTIVE
-}
-
-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"
-        const val AIRPODS_CONNECTION_DETECTED = "me.kavishdevar.aln.AIRPODS_CONNECTION_DETECTED"
-    }
-
-    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 = 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())
-            }
-        }
-
-        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/Window.kt

@@ -1,170 +0,0 @@
-package me.kavishdevar.aln
-
-import android.animation.Animator
-import android.animation.AnimatorListenerAdapter
-import android.animation.ObjectAnimator
-import android.annotation.SuppressLint
-import android.content.Context
-import android.graphics.PixelFormat
-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 kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.MainScope
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-import java.lang.Exception
-
-@SuppressLint("InflateParams", "ClickableViewAccessibility")
-class Window (context: Context) {
-    private val mView: View
-
-    @Suppress("DEPRECATION")
-    @SuppressLint("NewApi")
-    private val mParams: WindowManager.LayoutParams = WindowManager.LayoutParams().apply {
-        height = WindowManager.LayoutParams.WRAP_CONTENT
-        width = WindowManager.LayoutParams.MATCH_PARENT
-        type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
-        format = PixelFormat.TRANSLUCENT
-        gravity = Gravity.BOTTOM
-        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
-
-        mParams.gravity = Gravity.BOTTOM
-        mView.setOnClickListener(View.OnClickListener {
-            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", "SetTextI18n")
-    fun open(name: String = "AirPods Pro", batteryNotification: AirPodsNotifications.BatteryNotification) {
-        try {
-            if (mView.windowToken == null) {
-                if (mView.parent == null) {
-                    // Add the view initially off-screen
-                    mWindowManager.addView(mView, mParams)
-                    mView.findViewById<TextView>(R.id.name).text = name
-                    val vid = mView.findViewById<VideoView>(R.id.video)
-
-                    vid.setVideoPath("android.resource://me.kavishdevar.aln/" + R.raw.connected)
-                    vid.resolveAdjustedSize(vid.width, vid.height)
-                    vid.start()
-                    vid.setOnCompletionListener {
-                        vid.start()
-                    }
-
-                    val batteryStatus = batteryNotification.getBattery()
-                    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 = batteryStatus.find { it.component == BatteryComponent.LEFT }?.let {
-                        "\uDBC3\uDC8E    ${it.level}%"
-                    } ?: ""
-                    batteryRightText.text = batteryStatus.find { it.component == BatteryComponent.RIGHT }?.let {
-                        "\uDBC3\uDC8D    ${it.level}%"
-                    } ?: ""
-                    batteryCaseText.text = batteryStatus.find { it.component == BatteryComponent.CASE }?.let {
-                        "\uDBC3\uDE6C    ${it.level}%"
-                    } ?: ""
-
-                    // Slide-up animation
-                    val displayMetrics = mView.context.resources.displayMetrics
-                    val screenHeight = displayMetrics.heightPixels
-
-                    mView.translationY = screenHeight.toFloat()  // Start below the screen
-                    ObjectAnimator.ofFloat(mView, "translationY", 0f).apply {
-                        duration = 500  // Animation duration in milliseconds
-                        interpolator = DecelerateInterpolator()  // Smooth deceleration
-                        start()
-                    }
-
-                    CoroutineScope(MainScope().coroutineContext).launch {
-                        delay(12000)
-                        close()
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            Log.d("PopupService", e.toString())
-        }
-    }
-
-    fun close() {
-        try {
-            ObjectAnimator.ofFloat(mView, "translationY", mView.height.toFloat()).apply {
-                duration = 500  // Animation duration in milliseconds
-                interpolator = AccelerateInterpolator()  // Smooth acceleration
-                addListener(object : AnimatorListenerAdapter() {
-                    override fun onAnimationEnd(animation: Animator) {
-                        try {
-                            mWindowManager.removeView(mView)
-                        } catch (e: Exception) {
-                            Log.d("PopupService", e.toString())
-                        }
-                    }
-                })
-                start()
-            }
-        } catch (e: Exception) {
-            Log.d("PopupService", e.toString())
-        }
-    }
-}

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

@@ -1,62 +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
-
-class BluetoothReceiver : BroadcastReceiver() {
-    fun onConnect(bluetoothDevice: BluetoothDevice?) {
-
-    }
-
-    fun onDisconnect(bluetoothDevice: BluetoothDevice?) {
-
-    }
-
-    @SuppressLint("NewApi")
-    override fun onReceive(context: Context?, intent: Intent) {
-        val bluetoothDevice =
-            intent.getParcelableExtra("android.bluetooth.device.extra.DEVICE", BluetoothDevice::class.java)
-        val action = intent.action
-
-        // Airpods filter
-        if (bluetoothDevice != null && action != null && !action.isEmpty()) {
-            // Airpods connected, show notification.
-            if (BluetoothDevice.ACTION_ACL_CONNECTED == action) {
-                onConnect(bluetoothDevice)
-            }
-
-            // Airpods disconnected, remove notification but leave the scanner going.
-            if (BluetoothDevice.ACTION_ACL_DISCONNECTED == action
-                || BluetoothDevice.ACTION_ACL_DISCONNECT_REQUESTED == action
-            ) {
-                onDisconnect(bluetoothDevice)
-            }
-        }
-    }
-
-    companion object {
-        /**
-         * When the service is created, we register to get as many bluetooth and airpods related events as possible.
-         * ACL_CONNECTED and ACL_DISCONNECTED should have been enough, but you never know with android these days.
-         */
-        fun buildFilter(): IntentFilter {
-            val intentFilter = IntentFilter()
-            intentFilter.addAction("android.bluetooth.device.action.ACL_CONNECTED")
-            intentFilter.addAction("android.bluetooth.device.action.ACL_DISCONNECTED")
-            intentFilter.addAction("android.bluetooth.device.action.BOND_STATE_CHANGED")
-            intentFilter.addAction("android.bluetooth.device.action.NAME_CHANGED")
-            intentFilter.addAction("android.bluetooth.adapter.action.CONNECTION_STATE_CHANGED")
-            intentFilter.addAction("android.bluetooth.adapter.action.STATE_CHANGED")
-            intentFilter.addAction("android.bluetooth.headset.profile.action.CONNECTION_STATE_CHANGED")
-            intentFilter.addAction("android.bluetooth.headset.action.VENDOR_SPECIFIC_HEADSET_EVENT")
-            intentFilter.addAction("android.bluetooth.a2dp.profile.action.CONNECTION_STATE_CHANGED")
-            intentFilter.addAction("android.bluetooth.a2dp.profile.action.PLAYING_STATE_CHANGED")
-            intentFilter.addCategory("android.bluetooth.headset.intent.category.companyid.76")
-            return intentFilter
-        }
-    }
-}

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/CustomDeviceActivity.kt

@@ -1,5 +1,24 @@
-package me.kavishdevar.aln
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
 
+package me.kavishdevar.librepods
+
+import android.Manifest
 import android.annotation.SuppressLint
 import android.bluetooth.BluetoothDevice
 import android.bluetooth.BluetoothDevice.TRANSPORT_LE
@@ -7,11 +26,13 @@ import android.bluetooth.BluetoothGatt
 import android.bluetooth.BluetoothGattCallback
 import android.bluetooth.BluetoothGattCharacteristic
 import android.bluetooth.BluetoothManager
+import android.os.Build
 import android.os.Bundle
 import android.util.Log
 import androidx.activity.ComponentActivity
 import androidx.activity.compose.setContent
 import androidx.activity.enableEdgeToEdge
+import androidx.annotation.RequiresPermission
 import androidx.compose.foundation.layout.Arrangement
 import androidx.compose.foundation.layout.Column
 import androidx.compose.foundation.layout.fillMaxSize
@@ -26,17 +47,17 @@ import androidx.compose.runtime.remember
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.unit.dp
-import me.kavishdevar.aln.ui.theme.ALNTheme
+import me.kavishdevar.librepods.ui.theme.LibrePodsTheme
 import org.lsposed.hiddenapibypass.HiddenApiBypass
 import java.util.UUID
 
 class CustomDevice : ComponentActivity() {
-    @SuppressLint("MissingPermission", "CoroutineCreationDuringComposition", "NewApi")
+    @SuppressLint("MissingPermission", "CoroutineCreationDuringComposition")
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
         enableEdgeToEdge()
         setContent {
-            ALNTheme {
+            LibrePodsTheme {
                 val connect = remember { mutableStateOf(false) }
                 Scaffold(
                     modifier = Modifier.fillMaxSize(),
@@ -53,10 +74,10 @@ class CustomDevice : ComponentActivity() {
                     HiddenApiBypass.addHiddenApiExemptions("Landroid/bluetooth/BluetoothSocket;")
                     val manager = getSystemService(BLUETOOTH_SERVICE) as BluetoothManager
 //                    val device: BluetoothDevice = manager.adapter.getRemoteDevice("EC:D6:F4:3D:89:B8")
-                    val device: BluetoothDevice = manager.adapter.getRemoteDevice("DE:F4:C6:A3:CD:7A")
+                    val device: BluetoothDevice = manager.adapter.getRemoteDevice("E7:48:92:3B:7D:A5")
 //                    val socket = device.createInsecureL2capChannel(31)
 
-                    val batteryLevel = remember { mutableStateOf("") }
+//                    val batteryLevel = remember { mutableStateOf("") }
 //                    socket.outputStream.write(byteArrayOf(0x12,0x3B,0x00,0x02, 0x00))
 //                    socket.outputStream.write(byteArrayOf(0x12, 0x3A, 0x00, 0x01, 0x00, 0x08,0x01))
 
@@ -119,11 +140,10 @@ class CustomDevice : ComponentActivity() {
                         }
 
                         Button(onClick = {
-//                            val characteristicUuid = "4f860002-943b-49ef-bed4-2f730304427a"
-//                            val value = byteArrayOf(0x01, 0x00, 0x02)
-
-//                            sendWriteRequest(gatt, characteristicUuid, value)
-
+                            val characteristicUuid = "94110001-6D9B-4225-A4F1-6A4A7F01B0DE"
+                            val value = byteArrayOf(0x01, 0x00, 0x00, 0x00, 0x00 ,0x00 ,0x01)
+                            sendWriteRequest(gatt, characteristicUuid, value)
+                        
                         }) {
                             Text("batteryLevel.value")
                         }
@@ -134,7 +154,7 @@ class CustomDevice : ComponentActivity() {
     }
 }
 
-@SuppressLint("MissingPermission", "NewApi")
+@RequiresPermission(Manifest.permission.BLUETOOTH_CONNECT)
 fun sendWriteRequest(
     gatt: BluetoothGatt,
     characteristicUuid: String,
@@ -159,6 +179,10 @@ fun sendWriteRequest(
 
 
     // Send the write request
-    val success = gatt.writeCharacteristic(characteristic, value, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
+    val success = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        gatt.writeCharacteristic(characteristic, value, BluetoothGattCharacteristic.WRITE_TYPE_DEFAULT)
+    } else {
+        gatt.writeCharacteristic(characteristic)
+    }
     Log.d("GATT", "Write request sent $success to UUID: $characteristicUuid")
 }

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

@@ -0,0 +1,664 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero 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.Context.MODE_PRIVATE
+import android.content.Intent
+import android.content.ServiceConnection
+import android.content.SharedPreferences
+import android.net.Uri
+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.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.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.Box
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.size
+import androidx.compose.foundation.rememberScrollState
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.verticalScroll
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Notifications
+import androidx.compose.material.icons.filled.Phone
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.draw.clip
+import androidx.compose.ui.draw.scale
+import androidx.compose.ui.geometry.Offset
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.drawscope.rotate
+import androidx.compose.ui.graphics.toArgb
+import androidx.compose.ui.graphics.vector.ImageVector
+import androidx.compose.ui.platform.LocalContext
+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.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 me.kavishdevar.librepods.screens.AirPodsSettingsScreen
+import me.kavishdevar.librepods.screens.AppSettingsScreen
+import me.kavishdevar.librepods.screens.DebugScreen
+import me.kavishdevar.librepods.screens.HeadTrackingScreen
+import me.kavishdevar.librepods.screens.LongPress
+// import me.kavishdevar.librepods.screens.Onboarding
+import me.kavishdevar.librepods.screens.RenameScreen
+import me.kavishdevar.librepods.screens.TroubleshootingScreen
+import me.kavishdevar.librepods.services.AirPodsService
+import me.kavishdevar.librepods.ui.theme.LibrePodsTheme
+import me.kavishdevar.librepods.utils.AirPodsNotifications
+import me.kavishdevar.librepods.utils.CrossDevice
+// import me.kavishdevar.librepods.utils.RadareOffsetFinder
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+lateinit var serviceConnection: ServiceConnection
+lateinit var connectionStatusReceiver: BroadcastReceiver
+
+@ExperimentalMaterial3Api
+class MainActivity : ComponentActivity() {
+    companion object {
+        init {
+            System.loadLibrary("l2c_fcr_hook")
+        }
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+
+        setContent {
+            LibrePodsTheme {
+                getSharedPreferences("settings", MODE_PRIVATE).edit().putLong("textColor",
+                    MaterialTheme.colorScheme.onSurface.toArgb().toLong()).apply()
+                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()
+    }
+}
+
+@SuppressLint("MissingPermission", "InlinedApi", "UnspecifiedRegisterReceiverFlag")
+@OptIn(ExperimentalPermissionsApi::class)
+@Composable
+fun Main() {
+    val isConnected = remember { mutableStateOf(false) }
+    val isRemotelyConnected = remember { mutableStateOf(false) }
+//     val hookAvailable = RadareOffsetFinder(LocalContext.current).isHookOffsetAvailable()
+    val context = LocalContext.current
+    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) }
+
+    LaunchedEffect(Unit) {
+        canDrawOverlays = Settings.canDrawOverlays(context)
+    }
+
+    if (permissionState.allPermissionsGranted && (canDrawOverlays || overlaySkipped.value)) {
+        val context = LocalContext.current
+        context.startService(Intent(context, AirPodsService::class.java))
+
+        val navController = rememberNavController()
+
+        val sharedPreferences = context.getSharedPreferences("settings", MODE_PRIVATE)
+        val isAvailableChangeListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
+            if (key == "CrossDeviceIsAvailable") {
+                Log.d("MainActivity", "CrossDeviceIsAvailable changed")
+                isRemotelyConnected.value = sharedPreferences.getBoolean("CrossDeviceIsAvailable", false)
+            }
+        }
+        sharedPreferences.registerOnSharedPreferenceChangeListener(isAvailableChangeListener)
+        Log.d("MainActivity", "CrossDeviceIsAvailable: ${sharedPreferences.getBoolean("CrossDeviceIsAvailable", false)} | isAvailable: ${CrossDevice.isAvailable}")
+        isRemotelyConnected.value = sharedPreferences.getBoolean("CrossDeviceIsAvailable", false) || CrossDevice.isAvailable
+        Log.d("MainActivity", "isRemotelyConnected: ${isRemotelyConnected.value}")
+        Box (
+            modifier = Modifier
+                .padding(0.dp)
+                .fillMaxSize()
+                .background(if (isSystemInDarkTheme()) Color.Black else Color(0xFFF2F2F7))
+        ) {
+            NavHost(
+                navController = navController,
+                startDestination = "settings", // if (hookAvailable) "settings" else "onboarding",
+                enterTransition = {
+                    slideInHorizontally(
+                        initialOffsetX = { it },
+                        animationSpec = tween(durationMillis = 300)
+                    ) + fadeIn(animationSpec = tween(durationMillis = 300))
+                },
+                exitTransition = {
+                    slideOutHorizontally(
+                        targetOffsetX = { -it/4 },
+                        animationSpec = tween(durationMillis = 300)
+                    ) + fadeOut(animationSpec = tween(durationMillis = 150))
+                },
+                popEnterTransition = {
+                    slideInHorizontally(
+                        initialOffsetX = { -it/4 },
+                        animationSpec = tween(durationMillis = 300)
+                    ) + fadeIn(animationSpec = tween(durationMillis = 300))
+                },
+                popExitTransition = {
+                    slideOutHorizontally(
+                        targetOffsetX = { it },
+                        animationSpec = tween(durationMillis = 300)
+                    ) + fadeOut(animationSpec = tween(durationMillis = 150))
+                }
+            ) {
+                composable("settings") {
+                    if (airPodsService.value != null) {
+                        AirPodsSettingsScreen(
+                            dev = airPodsService.value?.device,
+                            service = airPodsService.value!!,
+                            navController = navController,
+                            isConnected = isConnected.value,
+                            isRemotelyConnected = isRemotelyConnected.value
+                        )
+                    }
+                }
+                composable("debug") {
+                    DebugScreen(navController = navController)
+                }
+                composable("long_press/{bud}") { navBackStackEntry ->
+                    LongPress(
+                        navController = navController,
+                        name = navBackStackEntry.arguments?.getString("bud")!!
+                    )
+                }
+                composable("rename") { navBackStackEntry ->
+                    RenameScreen(navController)
+                }
+                composable("app_settings") {
+                    AppSettingsScreen(navController)
+                }
+                composable("troubleshooting") {
+                    TroubleshootingScreen(navController)
+                }
+                composable("head_tracking") {
+                    HeadTrackingScreen(navController)
+                }
+//                composable("onboarding") {
+//                    Onboarding(navController, context)
+//                }
+            }
+        }
+
+         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?.isConnectedLocally == 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 = "The following permissions are required to use the app. Please grant them to continue.",
+            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,
+                    Uri.parse("package:${context.packageName}")
+                )
+                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 = {
+                    val editor = context.getSharedPreferences("settings", MODE_PRIVATE).edit()
+                    editor.putBoolean("overlay_permission_skipped", true)
+                    editor.apply()
+
+                    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,623 @@
+@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.platform.LocalDensity
+import androidx.compose.ui.res.painterResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.composables.AdaptiveRainbowBrush
+import me.kavishdevar.librepods.composables.IconAreaSize
+import me.kavishdevar.librepods.composables.ControlCenterNoiseControlSegmentedButton
+import me.kavishdevar.librepods.composables.VerticalVolumeSlider
+import me.kavishdevar.librepods.services.AirPodsService
+import me.kavishdevar.librepods.ui.theme.LibrePodsTheme
+import me.kavishdevar.librepods.utils.AACPManager
+import me.kavishdevar.librepods.utils.AirPodsNotifications
+import me.kavishdevar.librepods.utils.NoiseControlMode
+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, Context.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/composables/AccessibilitySettings.kt

@@ -0,0 +1,221 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+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.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+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.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.FontWeight
+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.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun AccessibilitySettings() {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+    val service = ServiceManager.getService()!!
+    Text(
+        text = stringResource(R.string.accessibility).uppercase(),
+        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()
+            .background(backgroundColor, RoundedCornerShape(14.dp))
+            .padding(top = 2.dp)
+    ) {
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(12.dp)
+        ) {
+            Text(
+                text = stringResource(R.string.tone_volume),
+                modifier = Modifier
+                    .padding(end = 8.dp, bottom = 2.dp, start = 2.dp)
+                    .fillMaxWidth(),
+                style = TextStyle(
+                    fontSize = 16.sp,
+                    fontWeight = FontWeight.Medium,
+                    color = textColor
+                )
+            )
+
+            ToneVolumeSlider()
+        }
+
+        val pressSpeedOptions = mapOf(
+            0.toByte() to "Default",
+            1.toByte() to "Slower",
+            2.toByte() to "Slowest"
+        )
+        val selectedPressSpeedValue = service.aacpManager.controlCommandStatusList.find { it.identifier == AACPManager.Companion.ControlCommandIdentifiers.DOUBLE_CLICK_INTERVAL }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+        var selectedPressSpeed by remember { mutableStateOf(pressSpeedOptions[selectedPressSpeedValue] ?: pressSpeedOptions[0]) }
+        DropdownMenuComponent(
+            label = "Press Speed",
+            options = pressSpeedOptions.values.toList(),
+            selectedOption = selectedPressSpeed.toString(),
+            onOptionSelected = { newValue ->
+                selectedPressSpeed = newValue
+                service.aacpManager.sendControlCommand(
+                    identifier = AACPManager.Companion.ControlCommandIdentifiers.DOUBLE_CLICK_INTERVAL.value,
+                    value = pressSpeedOptions.filterValues { it == newValue }.keys.firstOrNull() ?: 0.toByte()
+                )
+            },
+            textColor = textColor
+        )
+
+        val pressAndHoldDurationOptions = mapOf(
+            0.toByte() to "Default",
+            1.toByte() to "Slower",
+            2.toByte() to "Slowest"
+        )
+
+        val selectedPressAndHoldDurationValue = service.aacpManager.controlCommandStatusList.find { it.identifier == AACPManager.Companion.ControlCommandIdentifiers.CLICK_HOLD_INTERVAL }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+        var selectedPressAndHoldDuration by remember { mutableStateOf(pressAndHoldDurationOptions[selectedPressAndHoldDurationValue] ?: pressAndHoldDurationOptions[0]) }
+        DropdownMenuComponent(
+            label = "Press and Hold Duration",
+            options = pressAndHoldDurationOptions.values.toList(),
+            selectedOption = selectedPressAndHoldDuration.toString(),
+            onOptionSelected = { newValue ->
+                selectedPressAndHoldDuration = newValue
+                service.aacpManager.sendControlCommand(
+                    identifier = AACPManager.Companion.ControlCommandIdentifiers.CLICK_HOLD_INTERVAL.value,
+                    value = pressAndHoldDurationOptions.filterValues { it == newValue }.keys.firstOrNull() ?: 0.toByte()
+                )
+            },
+            textColor = textColor
+        )
+
+        val volumeSwipeSpeedOptions = mapOf<Byte, String>(
+            1.toByte() to "Default",
+            2.toByte() to "Longer",
+            3.toByte() to "Longest"
+        )
+        val selectedVolumeSwipeSpeedValue = service.aacpManager.controlCommandStatusList.find { it.identifier == AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_INTERVAL }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+        var selectedVolumeSwipeSpeed by remember { mutableStateOf(volumeSwipeSpeedOptions[selectedVolumeSwipeSpeedValue] ?: volumeSwipeSpeedOptions[1]) }
+        DropdownMenuComponent(
+            label = "Volume Swipe Speed",
+            options = volumeSwipeSpeedOptions.values.toList(),
+            selectedOption = selectedVolumeSwipeSpeed.toString(),
+            onOptionSelected = { newValue ->
+                selectedVolumeSwipeSpeed = newValue
+                service.aacpManager.sendControlCommand(
+                    identifier = AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_INTERVAL.value,
+                    value = volumeSwipeSpeedOptions.filterValues { it == newValue }.keys.firstOrNull() ?: 1.toByte()
+                )
+            },
+            textColor = textColor
+        )
+
+        SinglePodANCSwitch()
+        VolumeControlSwitch()
+    }
+}
+
+@Composable
+fun DropdownMenuComponent(
+    label: String,
+    options: List<String>,
+    selectedOption: String,
+    onOptionSelected: (String) -> Unit,
+    textColor: Color
+) {
+    var expanded by remember { mutableStateOf(false) }
+
+    Column (
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(horizontal = 12.dp)
+    ) {
+        Text(
+            text = label,
+            style = TextStyle(
+                fontSize = 16.sp,
+                fontWeight = FontWeight.Medium,
+                color = textColor
+            )
+        )
+
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .clickable { expanded = true }
+                .padding(8.dp)
+        ) {
+            Text(
+                text = selectedOption,
+                modifier = Modifier.padding(16.dp),
+                color = textColor
+            )
+        }
+
+        DropdownMenu(
+            expanded = expanded,
+            onDismissRequest = { expanded = false }
+        ) {
+            options.forEach { option ->
+                DropdownMenuItem(
+                    onClick = {
+                        onOptionSelected(option)
+                        expanded = false
+                    },
+                    text = { Text(text = option) }
+                )
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+fun AccessibilitySettingsPreview() {
+    AccessibilitySettings()
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/AdaptiveStrengthSlider.kt

@@ -0,0 +1,158 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+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.height
+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.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.mutableFloatStateOf
+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.text.TextStyle
+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 me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.roundToInt
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AdaptiveStrengthSlider() {
+    val sliderValue = remember { mutableFloatStateOf(0f) }
+    val service = ServiceManager.getService()!!
+    LaunchedEffect(sliderValue) {
+        val sliderValueFromAACP = service.aacpManager.controlCommandStatusList.find {
+            it.identifier == AACPManager.Companion.ControlCommandIdentifiers.AUTO_ANC_STRENGTH
+        }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+        sliderValueFromAACP?.toFloat()?.let { sliderValue.floatValue = (100 - it) }
+    }
+
+    val isDarkTheme = isSystemInDarkTheme()
+
+    val trackColor = if (isDarkTheme) Color(0xFFB3B3B3) else Color(0xFFD9D9D9)
+    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(
+            value = sliderValue.floatValue,
+            onValueChange = {
+                sliderValue.floatValue = it
+            },
+            valueRange = 0f..100f,
+            onValueChangeFinished = {
+                sliderValue.floatValue = sliderValue.floatValue.roundToInt().toFloat()
+                service.aacpManager.sendControlCommand(
+                    identifier = AACPManager.Companion.ControlCommandIdentifiers.AUTO_ANC_STRENGTH.value,
+                    value = (100 - sliderValue.floatValue).toInt()
+                )
+            },
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(36.dp),
+            colors = SliderDefaults.colors(
+                thumbColor = thumbColor,
+                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))
+                    )
+                }
+
+            }
+        )
+
+        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 AdaptiveStrengthSliderPreview() {
+    AdaptiveStrengthSlider()
+}

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

@@ -0,0 +1,104 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+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.Text
+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.text.TextStyle
+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 me.kavishdevar.librepods.R
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun AudioSettings() {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+
+    Text(
+        text = stringResource(R.string.audio).uppercase(),
+        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(0xFF1C1C1E) else Color(0xFFFFFFFF)
+
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(backgroundColor, RoundedCornerShape(14.dp))
+            .padding(top = 2.dp)
+    ) {
+
+        ConversationalAwarenessSwitch()
+
+        Column(
+            modifier = Modifier
+                .fillMaxWidth()
+                .padding(horizontal = 8.dp, vertical = 10.dp)
+        ) {
+            Text(
+                text = stringResource(R.string.adaptive_audio),
+                modifier = Modifier
+                    .padding(end = 8.dp, bottom = 2.dp, start = 2.dp)
+                    .fillMaxWidth(),
+                style = TextStyle(
+                    fontSize = 16.sp,
+                    color = textColor
+                )
+            )
+            Text(
+                text = stringResource(R.string.adaptive_audio_description),
+                modifier = Modifier
+                    .padding(bottom = 8.dp, top = 2.dp)
+                    .padding(end = 2.dp, start = 2.dp)
+                    .fillMaxWidth(),
+                style = TextStyle(
+                    fontSize = 12.sp,
+                    color = textColor.copy(alpha = 0.6f)
+                )
+            )
+
+            AdaptiveStrengthSlider()
+        }
+    }
+}
+
+@Preview
+@Composable
+fun AudioSettingsPreview() {
+    AudioSettings()
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/BatteryIndicator.kt

@@ -0,0 +1,135 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+
+import androidx.compose.animation.core.animateFloatAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.border
+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.fillMaxHeight
+import androidx.compose.foundation.layout.fillMaxSize
+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.MaterialTheme
+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.draw.scale
+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.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import me.kavishdevar.librepods.R
+
+@Composable
+fun BatteryIndicator(batteryPercentage: Int, charging: Boolean = false) {
+    val batteryOutlineColor = Color(0xFFBFBFBF)
+    val batteryFillColor = if (batteryPercentage > 30) Color(0xFF30D158) else Color(0xFFFC3C3C)
+    val batteryTextColor = MaterialTheme.colorScheme.onSurface
+
+    val batteryWidth = 40.dp
+    val batteryHeight = 15.dp
+    val batteryCornerRadius = 4.dp
+    val tipWidth = 5.dp
+    val tipHeight = batteryHeight * 0.375f
+
+    val animatedFillWidth by animateFloatAsState(targetValue = batteryPercentage / 100f)
+    val animatedScale by animateFloatAsState(targetValue = if (charging) 1.2f else 1f)
+
+    Column(
+        horizontalAlignment = Alignment.CenterHorizontally
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.spacedBy(0.dp),
+            modifier = Modifier.padding(bottom = 4.dp)
+        ) {
+            Box(
+                modifier = Modifier
+                    .width(batteryWidth)
+                    .height(batteryHeight)
+            ) {
+                Box (
+                    modifier = Modifier
+                        .fillMaxSize()
+                        .border(1.dp, batteryOutlineColor, RoundedCornerShape(batteryCornerRadius))
+                )
+                Box(
+                    modifier = Modifier
+                        .fillMaxHeight()
+                        .padding(2.dp)
+                        .width(batteryWidth * animatedFillWidth)
+                        .background(batteryFillColor, RoundedCornerShape(2.dp))
+                )
+                if (charging) {
+                    Text(
+                        text = "\uDBC0\uDEE6",
+                        fontSize = 16.sp,
+                        fontFamily = FontFamily(Font(R.font.sf_pro)),
+                        color = Color.White,
+                        modifier = Modifier
+                            .scale(animatedScale)
+                            .fillMaxSize(),
+                        textAlign = TextAlign.Center
+                    )
+                }
+            }
+            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
+                        )
+                    )
+            )
+        }
+
+        Text(
+            text = "$batteryPercentage%",
+            color = batteryTextColor,
+            style = TextStyle(fontSize = 16.sp, fontWeight = FontWeight.Bold)
+        )
+    }
+}
+
+@Preview
+@Composable
+fun BatteryIndicatorPreview() {
+    BatteryIndicator(batteryPercentage = 48, charging = true)
+}

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

@@ -0,0 +1,188 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.util.Log
+import androidx.compose.foundation.Image
+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.fillMaxWidth
+import androidx.compose.foundation.layout.width
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+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.scale
+import androidx.compose.ui.graphics.ImageBitmap
+import androidx.compose.ui.platform.LocalContext
+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.services.AirPodsService
+import me.kavishdevar.librepods.utils.AirPodsNotifications
+import me.kavishdevar.librepods.utils.Battery
+import me.kavishdevar.librepods.utils.BatteryComponent
+import me.kavishdevar.librepods.utils.BatteryStatus
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun BatteryView(service: AirPodsService, preview: Boolean = false) {
+    val batteryStatus = remember { mutableStateOf<List<Battery>>(listOf()) }
+    @Suppress("DEPRECATION") val batteryReceiver = remember {
+        object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                if (intent.action == AirPodsNotifications.BATTERY_DATA) {
+                    batteryStatus.value =
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                            intent.getParcelableArrayListExtra("data", Battery::class.java)
+                        } else {
+                            intent.getParcelableArrayListExtra("data")
+                        }?.toList() ?: listOf()
+                }
+                else if (intent.action == AirPodsNotifications.DISCONNECT_RECEIVERS) {
+                    try {
+                        context.unregisterReceiver(this)
+                    }
+                    catch (_: IllegalArgumentException) {
+                        Log.wtf("BatteryReceiver", "Receiver already unregistered")
+                    }
+                }
+            }
+        }
+    }
+    val context = LocalContext.current
+
+    LaunchedEffect(context) {
+        val batteryIntentFilter = IntentFilter()
+            .apply {
+                addAction(AirPodsNotifications.BATTERY_DATA)
+                addAction(AirPodsNotifications.DISCONNECT_RECEIVERS)
+            }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(
+                batteryReceiver,
+                batteryIntentFilter,
+                Context.RECEIVER_EXPORTED
+            )
+        }
+    }
+
+    batteryStatus.value = service.getBattery()
+
+    if (preview) {
+        batteryStatus.value = listOf<Battery>(
+            Battery(BatteryComponent.LEFT, 100, BatteryStatus.CHARGING),
+            Battery(BatteryComponent.RIGHT, 50, BatteryStatus.NOT_CHARGING),
+            Battery(BatteryComponent.CASE, 5, BatteryStatus.CHARGING)
+        )
+    }
+
+    Row {
+        Column (
+            modifier = Modifier
+                .fillMaxWidth(0.5f),
+            horizontalAlignment = Alignment.CenterHorizontally
+        ) {
+            Image (
+                bitmap = ImageBitmap.imageResource(R.drawable.pro_2_buds),
+                contentDescription = stringResource(R.string.buds),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .scale(0.80f)
+            )
+            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 (
+                    modifier = Modifier
+                        .fillMaxWidth(),
+                    horizontalArrangement = Arrangement.Center
+                ) {
+//                    if (left?.status != BatteryStatus.DISCONNECTED) {
+                    if (left?.level != null) {
+                        BatteryIndicator(
+                            left.level,
+                            left.status == BatteryStatus.CHARGING
+                        )
+                    }
+//                    }
+//                    if (left?.status != BatteryStatus.DISCONNECTED && right?.status != BatteryStatus.DISCONNECTED) {
+                    if (left?.level != null && right?.level != null)
+                    {
+                        Spacer(modifier = Modifier.width(16.dp))
+                    }
+//                    }
+//                    if (right?.status != BatteryStatus.DISCONNECTED) {
+                    if (right?.level != null)
+                    {
+                        BatteryIndicator(
+                            right.level,
+                            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 = stringResource(R.string.case_alt),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .scale(1.25f)
+            )
+//            if (case?.status != BatteryStatus.DISCONNECTED) {
+                if (case?.level != null) {
+                    BatteryIndicator(case.level, case.status == BatteryStatus.CHARGING)
+                }
+//            }
+        }
+    }
+}
+
+@Preview
+@Composable
+fun BatteryViewPreview() {
+    BatteryView(AirPodsService(), preview = true)
+}

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

@@ -0,0 +1,104 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+ 
+package me.kavishdevar.librepods.composables
+
+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/composables/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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+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.utils.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/composables/ConversationalAwarenessSwitch.kt

@@ -0,0 +1,133 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+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.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.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun ConversationalAwarenessSwitch() {
+    val service = ServiceManager.getService()!!
+    val conversationEnabledValue = service.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+    var conversationalAwarenessEnabled by remember {
+        mutableStateOf(
+            conversationEnabledValue == 1.toByte()
+        )
+    }
+
+    fun updateConversationalAwareness(enabled: Boolean) {
+        conversationalAwarenessEnabled = enabled
+        service.aacpManager.sendControlCommand(
+            AACPManager.Companion.ControlCommandIdentifiers.CONVERSATION_DETECT_CONFIG.value,
+            enabled
+        )
+    }
+
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+
+    val isPressed = remember { mutableStateOf(false) }
+
+    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) {
+                detectTapGestures(
+                    onPress = {
+                        isPressed.value = true
+                        tryAwaitRelease()
+                        isPressed.value = false
+                    }
+                )
+            }
+            .clickable(
+                indication = null,
+                interactionSource = remember { MutableInteractionSource() }
+            ) {
+                updateConversationalAwareness(!conversationalAwarenessEnabled)
+            },
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(end = 4.dp)
+        ) {
+            Text(
+                text = "Conversational Awareness",
+                fontSize = 16.sp,
+                color = textColor
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = "Lowers media volume and reduces background noise when you start speaking to other people.",
+                fontSize = 12.sp,
+                color = textColor.copy(0.6f),
+                lineHeight = 14.sp,
+            )
+        }
+        StyledSwitch(
+            checked = conversationalAwarenessEnabled,
+            onCheckedChange = {
+                updateConversationalAwareness(it)
+            },
+        )
+    }
+}
+
+@Preview
+@Composable
+fun ConversationalAwarenessSwitchPreview() {
+    ConversationalAwarenessSwitch()
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/CustomDropdown.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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.animation.core.animateFloatAsState
+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.isSystemInDarkTheme
+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.layout.widthIn
+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.setValue
+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.graphics.Color
+import androidx.compose.ui.layout.onGloballyPositioned
+import androidx.compose.ui.platform.LocalDensity
+import androidx.compose.ui.text.font.Font
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.compose.ui.window.Popup
+import androidx.compose.ui.window.PopupProperties
+import me.kavishdevar.librepods.R
+
+class DropdownItem(val name: String, val onSelect: () -> Unit) {
+    fun select() {
+        onSelect()
+    }
+}
+
+@Composable
+fun CustomDropdown(name: String, description: String = "", items: List<DropdownItem>) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+    var expanded by remember { mutableStateOf(false) }
+    var offset by remember { mutableStateOf(IntOffset.Zero) }
+    var popupHeight by remember { mutableStateOf(0.dp) }
+
+    val animatedHeight by animateDpAsState(
+        targetValue = if (expanded) popupHeight else 0.dp,
+        animationSpec = spring(dampingRatio = Spring.DampingRatioMediumBouncy, stiffness = Spring.StiffnessLow)
+    )
+    val animatedScale by animateFloatAsState(
+        targetValue = if (expanded) 1f else 0f,
+        animationSpec = spring(dampingRatio = Spring.DampingRatioMediumBouncy, stiffness = Spring.StiffnessLow)
+    )
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(
+                shape = RoundedCornerShape(14.dp),
+                color = Color.Transparent
+            )
+            .padding(horizontal = 12.dp, vertical = 12.dp)
+            .clickable(
+                indication = null,
+                interactionSource = remember { MutableInteractionSource() }
+            ) {
+                expanded = true
+            }
+            .onGloballyPositioned { coordinates ->
+                val windowPosition = coordinates.localToWindow(Offset.Zero)
+                offset = IntOffset(windowPosition.x.toInt(), windowPosition.y.toInt() + coordinates.size.height)
+            },
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(end = 4.dp)
+        ) {
+            Text(
+                text = name,
+                fontSize = 16.sp,
+                color = textColor,
+                maxLines = 1
+            )
+            if (description.isNotEmpty()) {
+                Spacer(modifier = Modifier.height(4.dp))
+                Text(
+                    text = description,
+                    fontSize = 12.sp,
+                    color = textColor.copy(0.6f),
+                    lineHeight = 14.sp,
+                    maxLines = 1
+                )
+            }
+        }
+        Text(
+            text = "\uDBC0\uDD8F",
+            fontSize = 16.sp,
+            fontFamily = FontFamily(Font(R.font.sf_pro)),
+            color = textColor
+        )
+    }
+
+    if (expanded) {
+        Popup(
+            alignment = Alignment.TopStart,
+            offset = offset ,
+            properties = PopupProperties(focusable = true),
+            onDismissRequest = { expanded = false }
+        ) {
+            val density = LocalDensity.current
+            Column(
+                modifier = Modifier
+                    .background(backgroundColor, RoundedCornerShape(8.dp))
+                    .padding(8.dp)
+                    .widthIn(max = 50.dp)
+                    .height(animatedHeight)
+                    .scale(animatedScale)
+                    .onGloballyPositioned { coordinates ->
+                        popupHeight = with(density) { coordinates.size.height.toDp() }
+                    }
+            ) {
+                items.forEach { item ->
+                    Text(
+                        text = item.name,
+                        modifier = Modifier
+                            .fillMaxWidth()
+                            .clickable {
+                                item.select()
+                                expanded = false
+                            }
+                            .padding(8.dp),
+                        color = textColor
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+fun CustomDropdownPreview() {
+    CustomDropdown(
+        name = "Volume Swipe Speed",
+        items = listOf(
+            DropdownItem("Always On") { },
+            DropdownItem("Off") { },
+            DropdownItem("Only when speaking") { }
+        )
+    )
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/IndependentToggle.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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+import android.content.SharedPreferences
+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.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.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.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import me.kavishdevar.librepods.services.AirPodsService
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun IndependentToggle(name: String, service: AirPodsService? = null, functionName: String? = null, sharedPreferences: SharedPreferences, default: Boolean = false, controlCommandIdentifier: AACPManager.Companion.ControlCommandIdentifiers? = null) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+    val snakeCasedName =
+        controlCommandIdentifier?.name ?: name.replace(Regex("[\\W\\s]+"), "_").lowercase()
+    var checked by remember { mutableStateOf(default) }
+
+    if (controlCommandIdentifier != null) {
+        checked = service!!.aacpManager.controlCommandStatusList.find {
+            it.identifier == controlCommandIdentifier
+        }?.value?.takeIf { it.isNotEmpty() }?.get(0) == 1.toByte()
+    }
+
+    var backgroundColor by remember { mutableStateOf(if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)) }
+    val animatedBackgroundColor by animateColorAsState(targetValue = backgroundColor, animationSpec = tween(durationMillis = 500))
+
+    fun cb() {
+        if (controlCommandIdentifier == null) {
+            sharedPreferences.edit().putBoolean(snakeCasedName, checked).apply()
+        }
+        if (functionName != null && service != null) {
+            val method =
+                service::class.java.getMethod(functionName, Boolean::class.java)
+            method.invoke(service, checked)
+        }
+        if (controlCommandIdentifier != null) {
+            service?.aacpManager?.sendControlCommand(identifier = controlCommandIdentifier.value, value = checked)
+        }
+    }
+
+    LaunchedEffect(sharedPreferences) {
+        checked = sharedPreferences.getBoolean(snakeCasedName, true)
+    }
+    Box (
+        modifier = Modifier
+            .padding(vertical = 8.dp)
+            .background(animatedBackgroundColor, RoundedCornerShape(14.dp))
+            .pointerInput(Unit) {
+                detectTapGestures(
+                    onPress = {
+                        backgroundColor = if (isDarkTheme) Color(0x40888888) else Color(0x40D9D9D9)
+                        tryAwaitRelease()
+                        backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+                    },
+                    onTap = {
+                        checked = !checked
+                        cb()
+                    }
+                )
+            },
+    )
+    {
+        Row(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(55.dp)
+                .padding(horizontal = 12.dp),
+            verticalAlignment = Alignment.CenterVertically
+        ) {
+            Text(text = name, modifier = Modifier.weight(1f), fontSize = 16.sp, color = textColor)
+            StyledSwitch(
+                checked = checked,
+                onCheckedChange = {
+                    checked = it
+                    cb()
+                },
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun IndependentTogglePreview() {
+    IndependentToggle("Test", AirPodsService(), "test", LocalContext.current.getSharedPreferences("preview", 0), true)
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/NameField.kt

@@ -0,0 +1,154 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+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.Arrangement
+import androidx.compose.foundation.layout.Box
+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.size
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.foundation.text.BasicTextField
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
+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.focus.onFocusChanged
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.SolidColor
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.text.TextStyle
+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 androidx.navigation.compose.rememberNavController
+
+@Composable
+fun NameField(
+    name: String,
+    value: String,
+    navController: NavController
+) {
+    var isFocused by remember { mutableStateOf(false) }
+
+    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 textColor = if (isDarkTheme) Color.White else Color.Black
+    val cursorColor = if (isFocused) {
+        if (isDarkTheme) Color.White else Color.Black
+    } else {
+        Color.Transparent
+    }
+
+    Box (
+        modifier = Modifier
+            .background(animatedBackgroundColor, RoundedCornerShape(14.dp))
+            .pointerInput(Unit) {
+                detectTapGestures(
+                    onPress = {
+                        backgroundColor = if (isDarkTheme) Color(0x40888888) else Color(0x40D9D9D9)
+                        tryAwaitRelease()
+                        backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+                    },
+                    onTap = {
+                        navController.navigate("rename")
+                    }
+                )
+            }
+    ) {
+        Row(
+            verticalAlignment = Alignment.CenterVertically,
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(55.dp)
+                .background(
+                    animatedBackgroundColor,
+                    RoundedCornerShape(14.dp)
+                )
+                .padding(horizontal = 16.dp, vertical = 8.dp)
+
+        ) {
+            Text(
+                text = name,
+                style = TextStyle(
+                    fontSize = 16.sp,
+                    color = textColor
+                )
+            )
+            BasicTextField(
+                value = value,
+                textStyle = TextStyle(
+                    color = textColor.copy(alpha = 0.75f),
+                    fontSize = 16.sp,
+                    textAlign = TextAlign.End
+                ),
+                onValueChange = {},
+                singleLine = true,
+                enabled = false,
+                cursorBrush = SolidColor(cursorColor),
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .padding(start = 8.dp)
+                    .onFocusChanged { focusState ->
+                        isFocused = focusState.isFocused
+                    },
+                decorationBox = { innerTextField ->
+                    Row(
+                        verticalAlignment = Alignment.CenterVertically,
+                        horizontalArrangement = Arrangement.End
+                    ) {
+                        innerTextField()
+                        Icon(
+                            imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
+                            contentDescription = "Edit name",
+                            tint = textColor.copy(alpha = 0.75f),
+                            modifier = Modifier
+                                .size(32.dp)
+                        )
+                    }
+                }
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun StyledTextFieldPreview() {
+    NameField(name = "Name", value = "AirPods Pro", rememberNavController())
+}

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

@@ -0,0 +1,104 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+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.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxHeight
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.KeyboardArrowRight
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.IconButtonDefaults
+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.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.navigation.NavController
+
+
+@Composable
+fun NavigationButton(to: String, name: String, navController: NavController) {
+    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))
+
+    Row(
+        modifier = Modifier
+            .background(animatedBackgroundColor, RoundedCornerShape(14.dp))
+            .height(55.dp)
+            .pointerInput(Unit) {
+                detectTapGestures(
+                    onPress = {
+                        backgroundColor = if (isDarkTheme) Color(0x40888888) else Color(0x40D9D9D9)
+                        tryAwaitRelease()
+                        backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+                    },
+                    onTap = {
+                        navController.navigate(to)
+                    }
+                )
+            }
+    ) {
+        Text(
+            text = name,
+            modifier = Modifier.padding(16.dp),
+            color = if (isDarkTheme) Color.White else Color.Black
+        )
+        Spacer(modifier = Modifier.weight(1f))
+        IconButton(
+            onClick = { navController.navigate(to) },
+            colors = IconButtonDefaults.iconButtonColors(
+                containerColor = Color.Transparent,
+                contentColor = if (isDarkTheme) Color.White else Color.Black
+            ),
+            modifier = Modifier
+                .padding(start = 16.dp)
+                .fillMaxHeight()
+        ) {
+            @Suppress("DEPRECATION")
+            Icon(
+                imageVector = Icons.Default.KeyboardArrowRight,
+                contentDescription = name
+            )
+        }
+    }
+}
+
+@Preview
+@Composable
+fun NavigationButtonPreview() {
+    NavigationButton("to", "Name", NavController(LocalContext.current))
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+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/composables/NoiseControlSettings.kt

@@ -0,0 +1,444 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+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.LocalContext
+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.FontWeight
+import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
+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.services.AirPodsService
+import me.kavishdevar.librepods.utils.AACPManager
+import me.kavishdevar.librepods.utils.AirPodsNotifications
+import me.kavishdevar.librepods.utils.NoiseControlMode
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.roundToInt
+
+@SuppressLint("UnspecifiedRegisterReceiverFlag", "UnusedBoxWithConstraintsScope")
+@Composable
+fun NoiseControlSettings(
+    service: AirPodsService,
+) {
+    val context = LocalContext.current
+    val offListeningModeConfigValue = service.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.ALLOW_OFF_OPTION
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0) == 1.toByte()
+    val offListeningMode = remember { mutableStateOf(offListeningModeConfigValue) }
+
+    val offListeningModeListener = object: AACPManager.ControlCommandListener {
+        override fun onControlCommandReceived(controlCommand: AACPManager.ControlCommand) {
+            offListeningMode.value = controlCommand.value[0] == 1.toByte()
+        }
+    }
+
+    service.aacpManager.registerControlCommandListener(
+        AACPManager.Companion.ControlCommandIdentifiers.ALLOW_OFF_OPTION,
+        offListeningModeListener
+    )
+
+    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) }
+
+    fun onModeSelected(mode: NoiseControlMode, received: Boolean = false) {
+        val previousMode = noiseControlMode.value
+
+        val targetMode = if (!offListeningMode.value && mode == NoiseControlMode.OFF) {
+             NoiseControlMode.TRANSPARENCY
+        } else {
+            mode
+        }
+
+        noiseControlMode.value = targetMode
+
+        if (!received && targetMode != previousMode) {
+            service.aacpManager.sendControlCommand(identifier = AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE.value, value = 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 noiseControlReceiver = remember {
+        object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                if (intent.action == AirPodsNotifications.ANC_DATA) {
+                    noiseControlMode.value = NoiseControlMode.entries.toTypedArray()[intent.getIntExtra("data", 3) - 1]
+                    onModeSelected(noiseControlMode.value, true)
+                } else if (intent.action == AirPodsNotifications.DISCONNECT_RECEIVERS) {
+                    try {
+                        context.unregisterReceiver(this)
+                    } catch (e: IllegalArgumentException) {
+                        e.printStackTrace()
+                    }
+                }
+            }
+        }
+    }
+
+    val noiseControlIntentFilter = IntentFilter().apply {
+        addAction(AirPodsNotifications.ANC_DATA)
+        addAction(AirPodsNotifications.DISCONNECT_RECEIVERS)
+    }
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        context.registerReceiver(noiseControlReceiver, noiseControlIntentFilter, Context.RECEIVER_EXPORTED)
+    } else {
+        context.registerReceiver(noiseControlReceiver, noiseControlIntentFilter)
+    }
+
+    Text(
+        text = stringResource(R.string.noise_control).uppercase(),
+        style = TextStyle(
+            fontSize = 14.sp,
+            fontWeight = FontWeight.Light,
+            color = textColor.copy(alpha = 0.6f),
+        ),
+        modifier = Modifier.padding(8.dp, bottom = 2.dp)
+    )
+    BoxWithConstraints(
+        modifier = Modifier
+            .fillMaxWidth()
+            .padding(vertical = 8.dp)
+    ) {
+        val density = LocalDensity.current
+        val buttonCount = if (offListeningMode.value) 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 (offListeningMode.value) 0f else buttonWidth.toPx()
+                        NoiseControlMode.TRANSPARENCY -> if (offListeningMode.value) buttonWidth.toPx() else 0f
+                        NoiseControlMode.ADAPTIVE -> if (offListeningMode.value) (buttonWidth * 2).toPx() else buttonWidth.toPx()
+                        NoiseControlMode.NOISE_CANCELLATION -> if (offListeningMode.value) (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 (offListeningMode.value) 0 else 1
+            NoiseControlMode.TRANSPARENCY -> if (offListeningMode.value) 1 else 0
+            NoiseControlMode.ADAPTIVE -> if (offListeningMode.value) 2 else 1
+            NoiseControlMode.NOISE_CANCELLATION -> if (offListeningMode.value) 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(14.dp))
+            ) {
+                Row(
+                    modifier = Modifier.fillMaxWidth()
+                ) {
+                    if (offListeningMode.value) {
+                        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 (offListeningMode.value) NoiseControlMode.OFF else NoiseControlMode.TRANSPARENCY
+                                    1 -> if (offListeningMode.value) NoiseControlMode.TRANSPARENCY else NoiseControlMode.ADAPTIVE
+                                    2 -> if (offListeningMode.value) NoiseControlMode.ADAPTIVE else NoiseControlMode.NOISE_CANCELLATION
+                                    3 -> NoiseControlMode.NOISE_CANCELLATION
+                                    else -> noiseControlMode.value // Keep current if index is invalid
+                                }
+                                // Call onModeSelected which now handles service call but not callback
+                                onModeSelected(newMode)
+                            }
+                        )
+                ) {
+                    Box(
+                        modifier = Modifier
+                            .fillMaxSize()
+                            .padding(3.dp)
+                            .background(selectedBackground, RoundedCornerShape(12.dp))
+                    )
+                }
+
+                Row(
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .zIndex(1f)
+                ) {
+                    if (offListeningMode.value) {
+                        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(horizontal = 4.dp)
+                    .padding(top = 4.dp)
+            ) {
+                if (offListeningMode.value) {
+                    Text(
+                        text = stringResource(R.string.off),
+                        style = TextStyle(fontSize = 12.sp, color = textColor),
+                        textAlign = TextAlign.Center,
+                        fontWeight = FontWeight.Bold,
+                        modifier = Modifier.weight(1f)
+                    )
+                }
+                Text(
+                    text = stringResource(R.string.transparency),
+                    style = TextStyle(fontSize = 12.sp, color = textColor),
+                    textAlign = TextAlign.Center,
+                    fontWeight = FontWeight.Bold,
+                    modifier = Modifier.weight(1f)
+                )
+                Text(
+                    text = stringResource(R.string.adaptive),
+                    style = TextStyle(fontSize = 12.sp, color = textColor),
+                    textAlign = TextAlign.Center,
+                    fontWeight = FontWeight.Bold,
+                    modifier = Modifier.weight(1f)
+                )
+                Text(
+                    text = stringResource(R.string.noise_cancellation),
+                    style = TextStyle(fontSize = 12.sp, color = textColor),
+                    textAlign = TextAlign.Center,
+                    fontWeight = FontWeight.Bold,
+                    modifier = Modifier.weight(1f)
+                )
+            }
+        }
+    }
+}
+
+@Preview()
+@Composable
+fun NoiseControlSettingsPreview() {
+    NoiseControlSettings(AirPodsService())
+}

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

@@ -0,0 +1,212 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+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.fillMaxWidth
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+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.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.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.navigation.NavController
+import me.kavishdevar.librepods.R
+
+@Composable
+fun PressAndHoldSettings(navController: NavController) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+    val dividerColor = Color(0x40888888)
+    var leftBackgroundColor by remember { mutableStateOf(if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)) }
+    var rightBackgroundColor by remember { mutableStateOf(if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)) }
+
+    val animationSpec = tween<Color>(durationMillis = 500)
+    val animatedLeftBackgroundColor by animateColorAsState(targetValue = leftBackgroundColor, animationSpec = animationSpec)
+    val animatedRightBackgroundColor by animateColorAsState(targetValue = rightBackgroundColor, animationSpec = animationSpec)
+
+    Text(
+        text = stringResource(R.string.press_and_hold_airpods).uppercase(),
+        style = TextStyle(
+            fontSize = 14.sp,
+            fontWeight = FontWeight.Light,
+            color = textColor.copy(alpha = 0.6f),
+            fontFamily = FontFamily(Font(R.font.sf_pro))
+        ),
+        modifier = Modifier.padding(8.dp, bottom = 2.dp)
+    )
+
+    Spacer(modifier = Modifier.height(1.dp))
+
+    Column(
+        modifier = Modifier
+            .fillMaxWidth()
+            .background(if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF), RoundedCornerShape(14.dp))
+    ) {
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(55.dp)
+                .background(animatedLeftBackgroundColor, RoundedCornerShape(topStart = 14.dp, topEnd = 14.dp))
+                .pointerInput(Unit) {
+                    detectTapGestures(
+                        onPress = {
+                            leftBackgroundColor = dividerColor
+                            tryAwaitRelease()
+                            leftBackgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+                        },
+                        onTap = {
+                            navController.navigate("long_press/Left")
+                        }
+                    )
+                },
+            contentAlignment = Alignment.Center
+        ) {
+            Row(
+                modifier = Modifier
+                    .padding(start = 16.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = stringResource(R.string.left),
+                    style = TextStyle(
+                        fontSize = 18.sp,
+                        color = textColor,
+                        fontFamily = FontFamily(Font(R.font.sf_pro))
+                    ),
+                )
+                Spacer(modifier = Modifier.weight(1f))
+                Text(
+                    text = stringResource(R.string.noise_control),
+                    style = TextStyle(
+                        fontSize = 18.sp,
+                        color = textColor.copy(alpha = 0.6f),
+                        fontFamily = FontFamily(Font(R.font.sf_pro))
+                    ),
+                )
+                IconButton(
+                    onClick = {
+                        navController.navigate("long_press/Left")
+                    }
+                ) {
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
+                        contentDescription = "go",
+                        tint = textColor
+                    )
+                }
+            }
+        }
+        HorizontalDivider(
+            thickness = 1.5.dp,
+            color = dividerColor,
+            modifier = Modifier
+                .padding(start = 16.dp)
+        )
+        Box(
+            modifier = Modifier
+                .fillMaxWidth()
+                .height(55.dp)
+                .background(animatedRightBackgroundColor, RoundedCornerShape(bottomEnd = 14.dp, bottomStart = 14.dp))
+                .pointerInput(Unit) {
+                    detectTapGestures(
+                        onPress = {
+                            rightBackgroundColor = dividerColor
+                            tryAwaitRelease()
+                            rightBackgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+                        },
+                        onTap = {
+                            navController.navigate("long_press/Right")
+                        }
+                    )
+                },
+            contentAlignment = Alignment.Center
+        ) {
+            Row(
+                modifier = Modifier
+                    .padding(start = 16.dp),
+                verticalAlignment = Alignment.CenterVertically
+            ) {
+                Text(
+                    text = stringResource(R.string.right),
+                    style = TextStyle(
+                        fontSize = 18.sp,
+                        color = textColor,
+                        fontFamily = FontFamily(Font(R.font.sf_pro))
+                    ),
+                )
+                Spacer(modifier = Modifier.weight(1f))
+                Text(
+                    text = stringResource(R.string.noise_control),
+                    style = TextStyle(
+                        fontSize = 18.sp,
+                        color = textColor.copy(alpha = 0.6f),
+                        fontFamily = FontFamily(Font(R.font.sf_pro))
+                    ),
+                )
+                IconButton(
+                    onClick = {
+                        navController.navigate("long_press/Right")
+                    }
+                ) {
+                    Icon(
+                        imageVector = Icons.AutoMirrored.Filled.KeyboardArrowRight,
+                        contentDescription = "go",
+                        tint = textColor
+                    )
+                }
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+fun PressAndHoldSettingsPreview() {
+    PressAndHoldSettings(navController = NavController(LocalContext.current))
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/SinglePodANCSwitch.kt

@@ -0,0 +1,133 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+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.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.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun SinglePodANCSwitch() {
+    val service = ServiceManager.getService()!!
+    val singleANCEnabledValue = service.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.ONE_BUD_ANC_MODE
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+    var singleANCEnabled by remember {
+        mutableStateOf(
+            singleANCEnabledValue == 1.toByte()
+        )
+    }
+
+    fun updateSingleEnabled(enabled: Boolean) {
+        singleANCEnabled = enabled
+        service.aacpManager.sendControlCommand(
+            AACPManager.Companion.ControlCommandIdentifiers.ONE_BUD_ANC_MODE.value,
+            enabled
+        )
+    }
+
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+
+    val isPressed = remember { mutableStateOf(false) }
+
+    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) {
+                detectTapGestures(
+                    onPress = {
+                        isPressed.value = true
+                        tryAwaitRelease()
+                        isPressed.value = false
+                    }
+                )
+            }
+            .clickable(
+                indication = null,
+                interactionSource = remember { MutableInteractionSource() }
+            ) {
+                updateSingleEnabled(!singleANCEnabled)
+            },
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(end = 4.dp)
+        ) {
+            Text(
+                text = "Noise Cancellation with Single AirPod",
+                fontSize = 16.sp,
+                color = textColor
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = "Allow AirPods to be put in noise cancellation mode when only one AirPods is in your ear.",
+                fontSize = 12.sp,
+                color = textColor.copy(0.6f),
+                lineHeight = 14.sp,
+            )
+        }
+        StyledSwitch(
+            checked = singleANCEnabled,
+            onCheckedChange = {
+                updateSingleEnabled(it)
+            },
+        )
+    }
+}
+
+@Preview
+@Composable
+fun SinglePodANCSwitchPreview() {
+    SinglePodANCSwitch()
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/StyledSwitch.kt

@@ -0,0 +1,88 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+import androidx.compose.animation.core.animateDpAsState
+import androidx.compose.foundation.background
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Box
+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.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+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.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+
+@Composable
+fun StyledSwitch(
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    enabled: Boolean = true,
+) {
+    val isDarkTheme = isSystemInDarkTheme()
+
+    val thumbColor = Color.White
+    val trackColor = if (enabled) (
+        if (isDarkTheme) {
+            if (checked) Color(0xFF34C759) else Color(0xFF5B5B5E)
+        } else {
+            if (checked) Color(0xFF34C759) else Color(0xFFD1D1D6)
+        }
+    ) else {
+        if (isDarkTheme) Color(0xFF5B5B5E) else Color(0xFFD1D1D6)
+    }
+
+
+    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)
+                .size(27.dp)
+                .clip(CircleShape)
+                .background(thumbColor)
+                .clickable { if (enabled) onCheckedChange(!checked) }
+        )
+    }
+}
+
+@Preview
+@Composable
+fun StyledSwitchPreview() {
+    StyledSwitch(checked = true, onCheckedChange = {})
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/ToneVolumeSlider.kt

@@ -0,0 +1,165 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+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.Row
+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.shape.CircleShape
+import androidx.compose.foundation.shape.RoundedCornerShape
+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.mutableFloatStateOf
+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.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 me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.roundToInt
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun ToneVolumeSlider() {
+    val service = ServiceManager.getService()!!
+    val sliderValueFromAACP = service.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.CHIME_VOLUME
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+    val sliderValue = remember { mutableFloatStateOf(
+        sliderValueFromAACP?.toFloat() ?: -1f
+    ) }
+    Log.d("ToneVolumeSlider", "Slider value: ${sliderValue.floatValue}")
+
+    val isDarkTheme = isSystemInDarkTheme()
+
+    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 labelTextColor = if (isDarkTheme) Color.White else Color.Black
+
+    Row(
+        modifier = Modifier
+            .fillMaxWidth(),
+        horizontalArrangement = Arrangement.SpaceBetween,
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Text(
+            text = "\uDBC0\uDEA1",
+            style = TextStyle(
+                fontSize = 16.sp,
+                fontFamily = FontFamily(Font(R.font.sf_pro)),
+                fontWeight = FontWeight.Light,
+                color = labelTextColor
+            ),
+            modifier = Modifier.padding(start = 4.dp)
+        )
+        Slider(
+            value = sliderValue.floatValue,
+            onValueChange = {
+                sliderValue.floatValue = it
+            },
+            valueRange = 0f..100f,
+            onValueChangeFinished = {
+                sliderValue.floatValue = sliderValue.floatValue.roundToInt().toFloat()
+                service.aacpManager.sendControlCommand(
+                    identifier = AACPManager.Companion.ControlCommandIdentifiers.CHIME_VOLUME.value,
+                    value = byteArrayOf(sliderValue.floatValue.toInt().toByte(),
+                       0x50.toByte()
+                    )
+                )
+            },
+            modifier = Modifier
+                .weight(1f)
+                .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(sliderValue.floatValue / 100)
+                            .height(4.dp)
+                            .background(activeTrackColor, RoundedCornerShape(4.dp))
+                    )
+                }
+            }
+        )
+        Text(
+            text = "\uDBC0\uDEA9",
+            style = TextStyle(
+                fontSize = 16.sp,
+                fontFamily = FontFamily(Font(R.font.sf_pro)),
+                fontWeight = FontWeight.Light,
+                color = labelTextColor
+            ),
+            modifier = Modifier.padding(end = 4.dp)
+        )
+    }
+}
+
+@Preview
+@Composable
+fun ToneVolumeSliderPreview() {
+    ToneVolumeSlider()
+}

android/app/src/main/java/me/kavishdevar/librepods/composables/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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.composables
+
+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/composables/VolumeControlSwitch.kt

@@ -0,0 +1,132 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.composables
+
+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.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.setValue
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.input.pointer.pointerInput
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable
+fun VolumeControlSwitch() {
+    val service = ServiceManager.getService()!!
+    val volumeControlEnabledValue = service.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_MODE
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+    var volumeControlEnabled by remember {
+        mutableStateOf(
+            volumeControlEnabledValue == 1.toByte()
+        )
+    }
+    fun updateVolumeControlEnabled(enabled: Boolean) {
+        volumeControlEnabled = enabled
+        service.aacpManager.sendControlCommand(
+            AACPManager.Companion.ControlCommandIdentifiers.VOLUME_SWIPE_MODE.value,
+            enabled
+        )
+    }
+
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+
+    val isPressed = remember { mutableStateOf(false) }
+
+    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) {
+                detectTapGestures(
+                    onPress = {
+                        isPressed.value = true
+                        tryAwaitRelease()
+                        isPressed.value = false
+                    }
+                )
+            }
+            .clickable(
+                indication = null,
+                interactionSource = remember { MutableInteractionSource() }
+            ) {
+                updateVolumeControlEnabled(!volumeControlEnabled)
+            },
+        verticalAlignment = Alignment.CenterVertically
+    ) {
+        Column(
+            modifier = Modifier
+                .weight(1f)
+                .padding(end = 4.dp)
+        ) {
+            Text(
+                text = "Volume Control",
+                fontSize = 16.sp,
+                color = textColor
+            )
+            Spacer(modifier = Modifier.height(4.dp))
+            Text(
+                text = "Adjust the volume by swiping up or down on the sensor located on the AirPods Pro stem.",
+                fontSize = 12.sp,
+                color = textColor.copy(0.6f),
+                lineHeight = 14.sp,
+            )
+        }
+        StyledSwitch(
+            checked = volumeControlEnabled,
+            onCheckedChange = {
+                updateVolumeControlEnabled(it)
+            },
+        )
+    }
+}
+
+@Preview
+@Composable
+fun VolumeControlSwitchPreview() {
+    VolumeControlSwitch()
+}

android/app/src/main/java/me/kavishdevar/librepods/receivers/BootReceiver.kt

@@ -0,0 +1,46 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.receivers
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import kotlin.io.encoding.ExperimentalEncodingApi
+import me.kavishdevar.librepods.services.AirPodsService
+
+class BootReceiver: BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+        when (intent?.action) {
+            Intent.ACTION_MY_PACKAGE_REPLACED -> try { context?.startForegroundService(
+                Intent(
+                    context,
+                    AirPodsService::class.java
+                )
+            ) } catch (e: Exception) { e.printStackTrace() }
+            Intent.ACTION_BOOT_COMPLETED -> try { context?.startForegroundService(
+                Intent(
+                    context,
+                    AirPodsService::class.java
+                )
+            ) } catch (e: Exception) { e.printStackTrace() }
+        }
+    }
+}

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

@@ -0,0 +1,459 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.screens
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothDevice
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Context.MODE_PRIVATE
+import android.content.Context.RECEIVER_EXPORTED
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.SharedPreferences
+import android.os.Build
+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.material.icons.Icons
+import androidx.compose.material.icons.filled.Info
+import androidx.compose.material.icons.filled.Settings
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.CenterAlignedTopAppBar
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.IconButtonDefaults
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Text
+import androidx.compose.material3.TopAppBarDefaults
+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.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.drawBehind
+import androidx.compose.ui.geometry.Offset
+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.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 androidx.navigation.compose.rememberNavController
+import dev.chrisbanes.haze.HazeEffectScope
+import dev.chrisbanes.haze.HazeState
+import dev.chrisbanes.haze.hazeEffect
+import dev.chrisbanes.haze.hazeSource
+import dev.chrisbanes.haze.materials.CupertinoMaterials
+import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.composables.AccessibilitySettings
+import me.kavishdevar.librepods.composables.AudioSettings
+import me.kavishdevar.librepods.composables.BatteryView
+import me.kavishdevar.librepods.composables.IndependentToggle
+import me.kavishdevar.librepods.composables.NameField
+import me.kavishdevar.librepods.composables.NavigationButton
+import me.kavishdevar.librepods.composables.NoiseControlSettings
+import me.kavishdevar.librepods.composables.PressAndHoldSettings
+import me.kavishdevar.librepods.services.AirPodsService
+import me.kavishdevar.librepods.ui.theme.LibrePodsTheme
+import me.kavishdevar.librepods.utils.AACPManager
+import me.kavishdevar.librepods.utils.AirPodsNotifications
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalHazeMaterialsApi::class)
+@SuppressLint("MissingPermission", "UnspecifiedRegisterReceiverFlag")
+@Composable
+fun AirPodsSettingsScreen(dev: BluetoothDevice?, service: AirPodsService,
+                          navController: NavController, isConnected: Boolean, isRemotelyConnected: Boolean) {
+    var isLocallyConnected by remember { mutableStateOf(isConnected) }
+    var isRemotelyConnected by remember { mutableStateOf(isRemotelyConnected) }
+    val sharedPreferences = LocalContext.current.getSharedPreferences("settings", MODE_PRIVATE)
+    var device by remember { mutableStateOf(dev) }
+    var deviceName by remember {
+        mutableStateOf(
+            TextFieldValue(
+                sharedPreferences.getString("name", device?.name ?: "AirPods Pro").toString()
+            )
+        )
+    }
+
+    LaunchedEffect(service) {
+        isLocallyConnected = service.isConnectedLocally
+    }
+
+    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 verticalScrollState  = rememberScrollState()
+    val hazeState = remember { HazeState() }
+    val snackbarHostState = remember { SnackbarHostState() }
+    val coroutineScope = rememberCoroutineScope()
+
+    fun handleRemoteConnection(connected: Boolean) {
+        isRemotelyConnected = connected
+    }
+
+    fun showSnackbar(message: String) {
+        coroutineScope.launch {
+            snackbarHostState.showSnackbar(message)
+        }
+    }
+
+    val context = LocalContext.current
+
+    val connectionReceiver = remember {
+        object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                when (intent?.action) {
+                    "me.kavishdevar.librepods.AIRPODS_CONNECTED_REMOTELY" -> {
+                        coroutineScope.launch {
+                            handleRemoteConnection(true)
+                        }
+                    }
+                    "me.kavishdevar.librepods.AIRPODS_DISCONNECTED_REMOTELY" -> {
+                        coroutineScope.launch {
+                            handleRemoteConnection(false)
+                        }
+                    }
+                    AirPodsNotifications.AIRPODS_CONNECTED -> {
+                        coroutineScope.launch {
+                            isLocallyConnected = true
+                        }
+                    }
+                    AirPodsNotifications.AIRPODS_DISCONNECTED -> {
+                        coroutineScope.launch {
+                            isLocallyConnected = false
+                        }
+                    }
+                    AirPodsNotifications.DISCONNECT_RECEIVERS -> {
+                        try {
+                            context?.unregisterReceiver(this)
+                        } catch (e: IllegalArgumentException) {
+                            e.printStackTrace()
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    DisposableEffect(Unit) {
+        val filter = IntentFilter().apply {
+            addAction("me.kavishdevar.librepods.AIRPODS_CONNECTED_REMOTELY")
+            addAction("me.kavishdevar.librepods.AIRPODS_DISCONNECTED_REMOTELY")
+            addAction(AirPodsNotifications.AIRPODS_CONNECTED)
+            addAction(AirPodsNotifications.AIRPODS_DISCONNECTED)
+            addAction(AirPodsNotifications.DISCONNECT_RECEIVERS)
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            context.registerReceiver(connectionReceiver, filter, RECEIVER_EXPORTED)
+        } else {
+            context.registerReceiver(connectionReceiver, filter)
+        }
+        onDispose {
+            try {
+                context.unregisterReceiver(connectionReceiver)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+    }
+
+    @SuppressLint("UnusedMaterial3ScaffoldPaddingParameter")
+    Scaffold(
+        containerColor = if (isSystemInDarkTheme()) Color(
+            0xFF000000
+        ) else Color(
+            0xFFF2F2F7
+        ),
+        topBar = {
+            val darkMode = isSystemInDarkTheme()
+            val mDensity = remember { mutableFloatStateOf(1f) }
+            CenterAlignedTopAppBar(
+                title = {
+                    Text(
+                        text = deviceName.text,
+                        style = TextStyle(
+                            fontSize = 20.sp,
+                            fontWeight = FontWeight.Medium,
+                            color = if (darkMode) Color.White else Color.Black,
+                            fontFamily = FontFamily(Font(R.font.sf_pro))
+                        )
+                    )
+                },
+                modifier = Modifier
+                    .hazeEffect(
+                        state = hazeState,
+                        style = CupertinoMaterials.thick(),
+                        block = fun HazeEffectScope.() {
+                            alpha =
+                                if (verticalScrollState.value > 60.dp.value * mDensity.floatValue) 1f else 0f
+                        })
+                    .drawBehind {
+                        mDensity.floatValue = density
+                        val strokeWidth = 0.7.dp.value * density
+                        val y = size.height - strokeWidth / 2
+                        if (verticalScrollState.value > 60.dp.value * density) {
+                            drawLine(
+                                if (darkMode) Color.DarkGray else Color.LightGray,
+                                Offset(0f, y),
+                                Offset(size.width, y),
+                                strokeWidth
+                            )
+                        }
+                    },
+                colors = TopAppBarDefaults.centerAlignedTopAppBarColors(
+                    containerColor = Color.Transparent
+                ),
+                actions = {
+                    if (isRemotelyConnected) {
+                        IconButton(
+                            onClick = {
+                                showSnackbar("Connected remotely to AirPods via Linux.")
+                            },
+                            colors = IconButtonDefaults.iconButtonColors(
+                                containerColor = Color.Transparent,
+                                contentColor = if (isSystemInDarkTheme()) Color.White else Color.Black
+                            )
+                        ) {
+                            Icon(
+                                imageVector = Icons.Default.Info,
+                                contentDescription = "Info",
+                            )
+                        }
+                    }
+                    IconButton(
+                        onClick = {
+                            navController.navigate("app_settings")
+                        },
+                        colors = IconButtonDefaults.iconButtonColors(
+                            containerColor = Color.Transparent,
+                            contentColor = if (isSystemInDarkTheme()) Color.White else Color.Black
+                        )
+                    ) {
+                        Icon(
+                            imageVector = Icons.Default.Settings,
+                            contentDescription = "Settings",
+                        )
+                    }
+                }
+            )
+        },
+        snackbarHost = { SnackbarHost(snackbarHostState) }
+    ) { paddingValues ->
+        if (isLocallyConnected || isRemotelyConnected) {
+            Column(
+                modifier = Modifier
+                    .hazeSource(hazeState)
+                    .fillMaxSize()
+                    .padding(horizontal = 16.dp)
+                    .verticalScroll(
+                        state = verticalScrollState,
+                        enabled = true,
+                    )
+            ) {
+                Spacer(Modifier.height(75.dp))
+                LaunchedEffect(service) {
+                    service.let {
+                        it.sendBroadcast(Intent(AirPodsNotifications.Companion.BATTERY_DATA).apply {
+                            putParcelableArrayListExtra("data", ArrayList(it.getBattery()))
+                        })
+                        it.sendBroadcast(Intent(AirPodsNotifications.Companion.ANC_DATA).apply {
+                            putExtra("data", it.getANC())
+                        })
+                    }
+                }
+                val sharedPreferences = LocalContext.current.getSharedPreferences("settings", MODE_PRIVATE)
+
+                Spacer(modifier = Modifier.height(64.dp))
+
+                BatteryView(service = service)
+
+                Spacer(modifier = Modifier.height(32.dp))
+
+                NameField(
+                    name = stringResource(R.string.name),
+                    value = deviceName.text,
+                    navController = navController
+                )
+
+                Spacer(modifier = Modifier.height(32.dp))
+                NoiseControlSettings(service = service)
+
+                Spacer(modifier = Modifier.height(16.dp))
+                Text(
+                    text = stringResource(R.string.head_gestures).uppercase(),
+                    style = TextStyle(
+                        fontSize = 14.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(8.dp, bottom = 2.dp)
+                )
+
+                Spacer(modifier = Modifier.height(2.dp))
+                NavigationButton(to = "head_tracking", "Head Tracking", navController)
+
+                Spacer(modifier = Modifier.height(16.dp))
+                PressAndHoldSettings(navController = navController)
+
+                Spacer(modifier = Modifier.height(16.dp))
+                AudioSettings()
+
+                Spacer(modifier = Modifier.height(16.dp))
+                IndependentToggle(
+                    name = "Automatic Ear Detection",
+                    service = service,
+                    functionName = "setEarDetection",
+                    sharedPreferences = sharedPreferences,
+                    default = true
+                )
+
+                Spacer(modifier = Modifier.height(16.dp))
+                IndependentToggle(
+                    name = "Off Listening Mode",
+                    service = service,
+                    sharedPreferences = sharedPreferences,
+                    default = false,
+                    controlCommandIdentifier = AACPManager.Companion.ControlCommandIdentifiers.ALLOW_OFF_OPTION
+                )
+
+                Spacer(modifier = Modifier.height(16.dp))
+                AccessibilitySettings()
+
+                Spacer(modifier = Modifier.height(16.dp))
+                NavigationButton("debug", "Debug", navController)
+                Spacer(Modifier.height(24.dp))
+            }
+        }
+        else {
+            Column(
+                modifier = Modifier
+                    .fillMaxSize()
+                    .padding(horizontal = 8.dp)
+                    .verticalScroll(
+                        state = verticalScrollState,
+                        enabled = true,
+                    ),
+                horizontalAlignment = Alignment.CenterHorizontally,
+                verticalArrangement = Arrangement.Center
+            ) {
+                Text(
+                    text = "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 = "Please connect your AirPods to access settings.",
+                    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))
+                Button(
+                    onClick = { navController.navigate("troubleshooting") },
+                    shape = RoundedCornerShape(10.dp),
+                    colors = ButtonDefaults.buttonColors(
+                        containerColor = if (isSystemInDarkTheme()) Color(0xFF1C1C1E) else Color(0xFFF2F2F7),
+                        contentColor = if (isSystemInDarkTheme()) Color.White else Color.Black,
+                    )
+                ) {
+                    Text(
+                        text = "Troubleshoot Connection",
+                        style = TextStyle(
+                            fontSize = 16.sp,
+                            fontWeight = FontWeight.Medium,
+                            fontFamily = FontFamily(Font(R.font.sf_pro))
+                        )
+                    )
+                }
+            }
+        }
+    }
+}
+
+
+@Preview
+@Composable
+fun AirPodsSettingsScreenPreview() {
+    Column (
+        modifier = Modifier.height(2000.dp)
+    ) {
+        LibrePodsTheme (
+            darkTheme = true
+        ) {
+            AirPodsSettingsScreen(dev = null, service = AirPodsService(), navController = rememberNavController(), isConnected = true, isRemotelyConnected = false)
+        }
+    }
+}

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

@@ -0,0 +1,667 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero 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.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.clickable
+import androidx.compose.foundation.combinedClickable
+import androidx.compose.foundation.isSystemInDarkTheme
+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.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.size
+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.automirrored.filled.KeyboardArrowLeft
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowRight
+import androidx.compose.material.icons.filled.Check
+import androidx.compose.material.icons.filled.Delete
+import androidx.compose.material.icons.filled.MoreVert
+import androidx.compose.material.icons.filled.Send
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CenterAlignedTopAppBar
+import androidx.compose.material3.DropdownMenu
+import androidx.compose.material3.DropdownMenuItem
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TextField
+import androidx.compose.material3.TextFieldDefaults
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.derivedStateOf
+import androidx.compose.runtime.getValue
+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.scale
+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 dev.chrisbanes.haze.HazeEffectScope
+import dev.chrisbanes.haze.HazeState
+import dev.chrisbanes.haze.hazeEffect
+import dev.chrisbanes.haze.hazeSource
+import dev.chrisbanes.haze.materials.CupertinoMaterials
+import dev.chrisbanes.haze.materials.ExperimentalHazeMaterialsApi
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.BatteryStatus
+import me.kavishdevar.librepods.utils.isHeadTrackingData
+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)
+    }
+}
+
+@Composable
+fun IOSCheckbox(
+    checked: Boolean,
+    onCheckedChange: (Boolean) -> Unit,
+    modifier: Modifier = Modifier
+) {
+    Box(
+        modifier = modifier
+            .size(24.dp)
+            .clickable { onCheckedChange(!checked) },
+        contentAlignment = Alignment.Center
+    ) {
+        if (checked) {
+            Icon(
+                imageVector = Icons.Default.Check,
+                contentDescription = "Checked",
+                tint = if (isSystemInDarkTheme()) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                modifier = Modifier.size(20.dp)
+            )
+        }
+    }
+}
+
+@RequiresApi(Build.VERSION_CODES.Q)
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class, ExperimentalFoundationApi::class)
+@SuppressLint("UnusedMaterial3ScaffoldPaddingParameter", "UnspecifiedRegisterReceiverFlag")
+@Composable
+fun DebugScreen(navController: NavController) {
+    val hazeState = remember { HazeState() }
+    val context = LocalContext.current
+    val listState = rememberLazyListState()
+    val scrollOffset by remember { derivedStateOf { listState.firstVisibleItemScrollOffset } }
+    val focusManager = LocalFocusManager.current
+    val coroutineScope = rememberCoroutineScope()
+
+    val showMenu = remember { mutableStateOf(false) }
+
+    val airPodsService = remember { ServiceManager.getService() }
+    val packetLogs = airPodsService?.packetLogsFlow?.collectAsState(emptySet())?.value ?: emptySet()
+    val shouldScrollToBottom = remember { mutableStateOf(true) }
+
+    val refreshTrigger = remember { mutableStateOf(0) }
+    LaunchedEffect(refreshTrigger.value) {
+        while(true) {
+            delay(1000)
+            refreshTrigger.value = refreshTrigger.value + 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.value) {
+        if (shouldScrollToBottom.value && packetLogs.isNotEmpty()) {
+            listState.animateScrollToItem(packetLogs.size - 1)
+        }
+    }
+
+    Scaffold(
+        topBar = {
+            CenterAlignedTopAppBar(
+                title = { Text("Debug") },
+                navigationIcon = {
+                    TextButton(
+                        onClick = { navController.popBackStack() },
+                        shape = RoundedCornerShape(8.dp),
+                    ) {
+                        val sharedPreferences = context.getSharedPreferences("settings", Context.MODE_PRIVATE)
+                        Icon(
+                            Icons.AutoMirrored.Filled.KeyboardArrowLeft,
+                            contentDescription = "Back",
+                            tint = if (isSystemInDarkTheme()) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                            modifier = Modifier.scale(1.5f)
+                        )
+                        Text(
+                            sharedPreferences.getString("name", "AirPods")!!,
+                            style = TextStyle(
+                                fontSize = 18.sp,
+                                fontWeight = FontWeight.Medium,
+                                color = if (isSystemInDarkTheme()) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                                fontFamily = FontFamily(Font(R.font.sf_pro))
+                            ),
+                        )
+                    }
+                },
+                actions = {
+                    Box {
+                        IconButton(onClick = { showMenu.value = true }) {
+                            Icon(
+                                imageVector = Icons.Default.MoreVert,
+                                contentDescription = "More Options",
+                                tint = if (isSystemInDarkTheme()) Color.White else Color.Black
+                            )
+                        }
+
+                        DropdownMenu(
+                            expanded = showMenu.value,
+                            onDismissRequest = { showMenu.value = false },
+                            modifier = Modifier
+                                .width(250.dp)
+                                .background(
+                                    if (isSystemInDarkTheme()) Color(0xFF1C1B20) else Color(0xFFF2F2F7)
+                                )
+                                .padding(vertical = 4.dp)
+                        ) {
+                            DropdownMenuItem(
+                                text = {
+                                    Row(
+                                        verticalAlignment = Alignment.CenterVertically,
+                                        modifier = Modifier.fillMaxWidth()
+                                    ) {
+                                        Text(
+                                            "Auto-scroll",
+                                            style = TextStyle(
+                                                fontSize = 16.sp,
+                                                fontWeight = FontWeight.Normal
+                                            )
+                                        )
+                                        Spacer(modifier = Modifier.weight(1f))
+                                        IOSCheckbox(
+                                            checked = shouldScrollToBottom.value,
+                                            onCheckedChange = { shouldScrollToBottom.value = it }
+                                        )
+                                    }
+                                },
+                                onClick = {
+                                    shouldScrollToBottom.value = !shouldScrollToBottom.value
+                                    showMenu.value = false
+                                }
+                            )
+
+                            HorizontalDivider(
+                                color = if (isSystemInDarkTheme()) Color(0xFF3A3A3C) else Color(0xFFE5E5EA),
+                                thickness = 0.5.dp
+                            )
+
+                            DropdownMenuItem(
+                                text = {
+                                    Row(
+                                        verticalAlignment = Alignment.CenterVertically,
+                                        modifier = Modifier.fillMaxWidth()
+                                    ) {
+                                        Text(
+                                            "Clear logs",
+                                            style = TextStyle(
+                                                fontSize = 16.sp,
+                                                fontWeight = FontWeight.Normal
+                                            )
+                                        )
+                                        Spacer(modifier = Modifier.weight(1f))
+                                        Icon(
+                                            imageVector = Icons.Default.Delete,
+                                            contentDescription = "Clear logs",
+                                            tint = if (isSystemInDarkTheme()) Color(0xFF007AFF) else Color(0xFF3C6DF5)
+                                        )
+                                    }
+                                },
+                                onClick = {
+                                    ServiceManager.getService()?.clearLogs()
+                                    expandedItems.value = emptySet()
+                                    showMenu.value = false
+                                }
+                            )
+                        }
+                    }
+                },
+                modifier = Modifier.hazeEffect(
+                    state = hazeState,
+                    style = CupertinoMaterials.thick(),
+                    block = fun HazeEffectScope.() {
+                        alpha = if (scrollOffset > 0) 1f else 0f
+                    }),
+                colors = TopAppBarDefaults.topAppBarColors(containerColor = Color.Transparent),
+            )
+        },
+        containerColor = if (isSystemInDarkTheme()) Color(0xFF000000) else Color(0xFFF2F2F7),
+    ) { paddingValues ->
+        Column(
+            modifier = Modifier
+                .fillMaxSize()
+                .hazeSource(hazeState)
+                .padding(top = paddingValues.calculateTopPadding())
+                .navigationBarsPadding()
+        ) {
+            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, horizontal = 4.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),
+                            )
+                        ) {
+                            Column(modifier = Modifier.padding(8.dp)) {
+                                Row(verticalAlignment = Alignment.CenterVertically) {
+                                    Icon(
+                                        imageVector = if (isSent) Icons.AutoMirrored.Filled.KeyboardArrowLeft else Icons.AutoMirrored.Filled.KeyboardArrowRight,
+                                        contentDescription = null,
+                                        tint = if (isSent) Color.Green else Color.Red,
+                                        modifier = Modifier.size(24.dp)
+                                    )
+                                    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 (shouldScrollToBottom.value && 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/screens/HeadTrackingScreen.kt

@@ -0,0 +1,859 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.screens
+
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+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.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.automirrored.filled.KeyboardArrowLeft
+import androidx.compose.material.icons.filled.PlayArrow
+import androidx.compose.material3.Button
+import androidx.compose.material3.ButtonDefaults
+import androidx.compose.material3.Card
+import androidx.compose.material3.CardDefaults
+import androidx.compose.material3.CenterAlignedTopAppBar
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBarDefaults
+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.draw.drawBehind
+import androidx.compose.ui.draw.scale
+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.SolidColor
+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.graphics.vector.ImageVector
+import androidx.compose.ui.graphics.vector.path
+import androidx.compose.ui.input.nestedscroll.nestedScroll
+import androidx.compose.ui.platform.LocalContext
+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.text.style.TextOverflow
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.navigation.NavController
+import dev.chrisbanes.haze.HazeEffectScope
+import dev.chrisbanes.haze.HazeState
+import dev.chrisbanes.haze.hazeEffect
+import dev.chrisbanes.haze.hazeSource
+import dev.chrisbanes.haze.materials.CupertinoMaterials
+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.composables.IndependentToggle
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.HeadTracking
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.abs
+import kotlin.math.cos
+import kotlin.math.sin
+import kotlin.random.Random
+
+@ExperimentalHazeMaterialsApi
+@RequiresApi(Build.VERSION_CODES.Q)
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalAnimationApi::class)
+@Composable
+fun HeadTrackingScreen(navController: NavController) {
+    DisposableEffect(Unit) {
+        ServiceManager.getService()?.startHeadTracking()
+        onDispose {
+            ServiceManager.getService()?.stopHeadTracking()
+        }
+    }
+    val sharedPreferences = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    val isDarkTheme = isSystemInDarkTheme()
+    val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+
+    val scrollState = rememberScrollState()
+    val scrollBehavior = TopAppBarDefaults.pinnedScrollBehavior()
+    val hazeState = remember { HazeState() }
+
+    var mDensity by remember { mutableFloatStateOf(0f) }
+    Scaffold(
+        modifier = Modifier.nestedScroll(scrollBehavior.nestedScrollConnection),
+        topBar = {
+            CenterAlignedTopAppBar(
+                modifier = Modifier.hazeEffect(
+                    state = hazeState,
+                    style = CupertinoMaterials.thick(),
+                    block = fun HazeEffectScope.() {
+                        alpha =
+                            if (scrollState.value > 60.dp.value * mDensity) 1f else 0f
+                    })
+                    .drawBehind {
+                        mDensity = density
+                        val strokeWidth = 0.7.dp.value * density
+                        val y = size.height - strokeWidth / 2
+                        if (scrollState.value > 60.dp.value * density) {
+                            drawLine(
+                                if (isDarkTheme) Color.DarkGray else Color.LightGray,
+                                Offset(0f, y),
+                                Offset(size.width, y),
+                                strokeWidth
+                            )
+                        }
+                    },
+                title = {
+                    Text(
+                        stringResource(R.string.head_tracking),
+                        fontFamily = FontFamily(Font(R.font.sf_pro)),
+                    )
+                },
+                navigationIcon = {
+                    TextButton(
+                        onClick = {
+                            navController.popBackStack()
+                            if (ServiceManager.getService()?.isHeadTrackingActive == true) ServiceManager.getService()?.stopHeadTracking()
+                        },
+                        shape = RoundedCornerShape(8.dp),
+                        modifier = Modifier.width(180.dp)
+                    ) {
+                        Icon(
+                            Icons.AutoMirrored.Filled.KeyboardArrowLeft,
+                            contentDescription = "Back",
+                            tint = if (isDarkTheme)  Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                            modifier = Modifier.scale(1.5f)
+                        )
+                        Text(
+                            sharedPreferences.getString("name", "AirPods")!!,
+                            style = TextStyle(
+                                fontSize = 18.sp,
+                                fontWeight = FontWeight.Medium,
+                                color = if (isDarkTheme) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                                fontFamily = FontFamily(Font(R.font.sf_pro))
+                            ),
+                            maxLines = 1,
+                            overflow = TextOverflow.Ellipsis,
+                            modifier = Modifier.weight(1f)
+                        )
+                    }
+                },
+                colors = TopAppBarDefaults.centerAlignedTopAppBarColors(
+                    containerColor = Color.Transparent
+                ),
+                actions = {
+                    var isActive by remember { mutableStateOf(ServiceManager.getService()?.isHeadTrackingActive == true) }
+                    IconButton(
+                        onClick = {
+                            if (ServiceManager.getService()?.isHeadTrackingActive == false) {
+                                ServiceManager.getService()?.startHeadTracking()
+                                Log.d("HeadTrackingScreen", "Head tracking started")
+                                isActive = true
+                            } else {
+                                ServiceManager.getService()?.stopHeadTracking()
+                                Log.d("HeadTrackingScreen", "Head tracking stopped")
+                                isActive = false
+                            }
+                      },
+                    ) {
+                        Icon(
+                            if (isActive) {
+                                ImageVector.Builder(
+                                    name = "Pause",
+                                    defaultWidth = 24.dp,
+                                    defaultHeight = 24.dp,
+                                    viewportWidth = 24f,
+                                    viewportHeight = 24f
+                                ).apply {
+                                    path(
+                                        fill = SolidColor(Color.Black),
+                                        pathBuilder = {
+                                            moveTo(6f, 5f)
+                                            lineTo(10f, 5f)
+                                            lineTo(10f, 19f)
+                                            lineTo(6f, 19f)
+                                            lineTo(6f, 5f)
+                                            moveTo(14f, 5f)
+                                            lineTo(18f, 5f)
+                                            lineTo(18f, 19f)
+                                            lineTo(14f, 19f)
+                                            lineTo(14f, 5f)
+                                        }
+                                    )
+                                }.build()
+                            } else Icons.Filled.PlayArrow,
+                            contentDescription = "Start",
+                            tint = if (isDarkTheme) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                            modifier = Modifier.scale(1.5f)
+                        )
+                    }
+                },
+                scrollBehavior = scrollBehavior
+            )
+        },
+        containerColor = if (isSystemInDarkTheme()) Color(0xFF000000)
+        else Color(0xFFF2F2F7),
+    ) { paddingValues ->
+        Column (
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues = paddingValues)
+                .padding(horizontal = 16.dp)
+                .padding(top = 8.dp)
+                .verticalScroll(scrollState)
+                .hazeSource(state = hazeState)
+        ) {
+            val sharedPreferences =
+                LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+
+            var gestureText by remember { mutableStateOf("") }
+            val coroutineScope = rememberCoroutineScope()
+
+            IndependentToggle(name = "Head Gestures", sharedPreferences = sharedPreferences)
+            Spacer(modifier = Modifier.height(2.dp))
+            Text(
+                stringResource(R.string.head_gestures_details),
+                style = TextStyle(
+                    fontSize = 14.sp,
+                    fontWeight = FontWeight.Normal,
+                    fontFamily = FontFamily(Font(R.font.sf_pro)),
+                    color = textColor.copy(0.6f)
+                ),
+                modifier = Modifier.padding(start = 4.dp)
+            )
+
+            Spacer(modifier = Modifier.height(16.dp))
+            Text(
+                "Head Orientation",
+                style = TextStyle(
+                    fontSize = 18.sp,
+                    fontWeight = FontWeight.Medium,
+                    fontFamily = FontFamily(Font(R.font.sf_pro)),
+                    color = textColor
+                ),
+                modifier = Modifier.padding(start = 4.dp, bottom = 8.dp, top = 8.dp)
+            )
+            HeadVisualization()
+
+            Spacer(modifier = Modifier.height(16.dp))
+            Text(
+                "Acceleration",
+                style = TextStyle(
+                    fontSize = 18.sp,
+                    fontWeight = FontWeight.Medium,
+                    fontFamily = FontFamily(Font(R.font.sf_pro)),
+                    color = textColor
+                ),
+                modifier = Modifier.padding(start = 4.dp, bottom = 8.dp, top = 8.dp)
+            )
+            AccelerationPlot()
+
+            Spacer(modifier = Modifier.height(16.dp))
+            Button (
+                onClick = {
+                    gestureText = "Shake your head or nod!"
+                    coroutineScope.launch {
+                        val accepted = ServiceManager.getService()?.testHeadGestures() ?: false
+                        gestureText = if (accepted) "\"Yes\" gesture detected." else "\"No\" gesture detected."
+                    }
+                },
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(55.dp),
+                colors = ButtonDefaults.buttonColors(
+                    containerColor = backgroundColor
+                ),
+                shape = RoundedCornerShape(8.dp)
+            ) {
+                Text(
+                    "Test Head Gestures",
+                    style = TextStyle(
+                        fontSize = 16.sp,
+                        fontWeight = FontWeight.Medium,
+                        fontFamily = FontFamily(Font(R.font.sf_pro)),
+                        color = textColor
+                    ),
+                )
+            }
+            var lastClickTime by remember { mutableLongStateOf(0L) }
+            var shouldExplode by remember { mutableStateOf(false) }
+
+            LaunchedEffect(gestureText) {
+                if (gestureText.isNotEmpty()) {
+                    lastClickTime = System.currentTimeMillis()
+                    delay(3000)
+                    if (System.currentTimeMillis() - lastClickTime >= 3000) {
+                        shouldExplode = true
+                    }
+                }
+            }
+
+            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 (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)))
+            }
+            textVisible = false
+        }
+
+        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
+        )
+    ) {
+        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 y1 = y
+                    val z1 = x * sinY + z * cosY
+
+                    val x2 = x1
+                    val y2 = y1 * cosP - z1 * sinP
+                    val z2 = y1 * sinP + z1 * cosP
+
+                    return Triple(x2, 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 = android.graphics.Paint().apply {
+                        style = android.graphics.Paint.Style.FILL
+                        shader = android.graphics.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),
+                            android.graphics.Shader.TileMode.CLAMP
+                        )
+                    }
+                    drawPath(spherePath.asAndroidPath(), paint)
+
+                    val highlightPaint = android.graphics.Paint().apply {
+                        style = android.graphics.Paint.Style.FILL
+                        shader = android.graphics.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),
+                            android.graphics.Shader.TileMode.CLAMP
+                        )
+                        alpha = if (darkTheme) 30 else 60
+                    }
+                    drawPath(spherePath.asAndroidPath(), highlightPaint)
+
+                    val secondaryHighlightPaint = android.graphics.Paint().apply {
+                        style = android.graphics.Paint.Style.FILL
+                        shader = android.graphics.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),
+                            android.graphics.Shader.TileMode.CLAMP
+                        )
+                        alpha = if (darkTheme) 15 else 30
+                    }
+                    drawPath(spherePath.asAndroidPath(), secondaryHighlightPaint)
+
+                    val shadowPaint = android.graphics.Paint().apply {
+                        style = android.graphics.Paint.Style.FILL
+                        shader = android.graphics.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),
+                            android.graphics.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 = android.graphics.Paint().apply {
+                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
+                        textSize = 12.sp.toPx()
+                        textAlign = android.graphics.Paint.Align.RIGHT
+                        typeface = android.graphics.Typeface.create(
+                            "SF Pro",
+                            android.graphics.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
+        )
+    ) {
+        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 = android.graphics.Paint().apply {
+                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
+                        textSize = 12.sp.toPx()
+                        textAlign = android.graphics.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 = android.graphics.Paint().apply {
+                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
+                        textSize = 12.sp.toPx()
+                        textAlign = android.graphics.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 = android.graphics.Paint().apply {
+                        color = if (darkTheme) android.graphics.Color.WHITE else android.graphics.Color.BLACK
+                        textSize = 12.sp.toPx()
+                        textAlign = android.graphics.Paint.Align.LEFT
+                    }
+                    drawText("Vertical", width - 60.dp.toPx(), textOffsetY, paint)
+                }
+            }
+        }
+    }
+}
+
+@ExperimentalHazeMaterialsApi
+@RequiresApi(Build.VERSION_CODES.Q)
+@Preview
+@Composable
+fun HeadTrackingScreenPreview() {
+    HeadTrackingScreen(navController = NavController(LocalContext.current))
+}

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

@@ -0,0 +1,386 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero 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.screens
+
+import android.content.Context
+import android.util.Log
+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.Arrangement
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+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.wrapContentWidth
+import androidx.compose.foundation.shape.RoundedCornerShape
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
+import androidx.compose.material3.CenterAlignedTopAppBar
+import androidx.compose.material3.Checkbox
+import androidx.compose.material3.CheckboxDefaults
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.HorizontalDivider
+import androidx.compose.material3.Icon
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBarDefaults
+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.draw.scale
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.ImageBitmap
+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.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.navigation.NavController
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.services.ServiceManager
+import me.kavishdevar.librepods.utils.AACPManager
+import kotlin.experimental.and
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@Composable()
+fun RightDivider() {
+    HorizontalDivider(
+        thickness = 1.5.dp,
+        color = Color(0x40888888),
+        modifier = Modifier
+            .padding(start = 72.dp)
+    )
+}
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun LongPress(navController: NavController, name: String) {
+    val isDarkTheme = isSystemInDarkTheme()
+    val textColor = if (isDarkTheme) Color.White else Color.Black
+
+    val modesByte = ServiceManager.getService()!!.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+
+    if (modesByte != null) {
+        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 0x02) != 0.toByte()}")
+        Log.d("PressAndHoldSettingsScreen", "Noise Cancellation mode: ${(modesByte and 0x04) != 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 deviceName = sharedPreferences.getString("name", "AirPods Pro")
+    Scaffold(
+        topBar = {
+            CenterAlignedTopAppBar(
+                title = {
+                        Text(
+                            name,
+                            fontFamily = FontFamily(Font(R.font.sf_pro)),
+                        )
+                    },
+                navigationIcon = {
+                    TextButton(
+                        onClick = {
+                            navController.popBackStack()
+                        },
+                        shape = RoundedCornerShape(8.dp),
+                    ) {
+                        Icon(
+                            Icons.AutoMirrored.Filled.KeyboardArrowLeft,
+                            contentDescription = "Back",
+                            tint = if (isDarkTheme)  Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                            modifier = Modifier.scale(1.5f)
+                        )
+                        Text(
+                            deviceName?: "AirPods Pro",
+                            style = TextStyle(
+                                fontSize = 18.sp,
+                                fontWeight = FontWeight.Medium,
+                                color = if (isDarkTheme) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                                fontFamily = FontFamily(Font(R.font.sf_pro))
+                            ),
+                        )
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = Color.Transparent
+                )
+            )
+        },
+        containerColor = if (isSystemInDarkTheme()) Color(0xFF000000)
+        else Color(0xFFF2F2F7),
+    ) { paddingValues ->
+        val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+        Column (
+          modifier = Modifier
+              .fillMaxSize()
+              .padding(paddingValues = paddingValues)
+              .padding(horizontal = 16.dp)
+              .padding(top = 8.dp)
+        ) {
+            Text(
+                text = "NOISE CONTROL",
+                style = TextStyle(
+                    fontSize = 14.sp,
+                    fontWeight = FontWeight.Light,
+                    color = textColor.copy(alpha = 0.6f),
+                ),
+                fontFamily = FontFamily(Font(R.font.sf_pro)),
+                modifier = Modifier
+                    .padding(8.dp, bottom = 4.dp)
+            )
+
+            Column(
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .background(backgroundColor, RoundedCornerShape(14.dp)),
+                horizontalAlignment = Alignment.CenterHorizontally
+            ) {
+                val offListeningModeValue = ServiceManager.getService()!!.aacpManager.controlCommandStatusList.find {
+                    it.identifier == AACPManager.Companion.ControlCommandIdentifiers.ALLOW_OFF_OPTION
+                }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+                val offListeningMode = offListeningModeValue == 1.toByte()
+                LongPressElement(
+                    name = "Off",
+                    enabled = offListeningMode,
+                    resourceId =  R.drawable.noise_cancellation,
+                    isFirst = true)
+                if (offListeningMode) RightDivider()
+                LongPressElement(
+                    name = "Transparency",
+                    resourceId = R.drawable.transparency,
+                    isFirst = !offListeningMode)
+                RightDivider()
+                LongPressElement(
+                    name = "Adaptive",
+                    resourceId = R.drawable.adaptive)
+                RightDivider()
+                LongPressElement(
+                    name = "Noise Cancellation",
+                    resourceId = R.drawable.noise_cancellation,
+                    isLast = true)
+            }
+            Text(
+                "Press and hold the stem to cycle between the selected noise control modes.",
+                fontSize = 16.sp,
+                fontFamily = FontFamily(Font(R.font.sf_pro)),
+                color = textColor.copy(alpha = 0.6f),
+                modifier = Modifier
+                    .padding(start = 16.dp, top = 4.dp)
+            )
+        }
+    }
+    Log.d("PressAndHoldSettingsScreen", "Current byte: ${ServiceManager.getService()!!.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)?.toString(2)}")
+}
+
+@Composable
+fun LongPressElement(name: String, enabled: Boolean = true, resourceId: Int, isFirst: Boolean = false, isLast: Boolean = false) {
+    val bit = when (name) {
+        "Off" -> 0x01
+        "Transparency" -> 0x02
+        "Noise Cancellation" -> 0x04
+        "Adaptive" -> 0x08
+        else -> -1
+    }
+    val context = LocalContext.current
+
+    val currentByteValue = ServiceManager.getService()!!.aacpManager.controlCommandStatusList.find {
+        it.identifier == AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS
+    }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+
+    val savedByte = context.getSharedPreferences("settings", Context.MODE_PRIVATE).getInt("long_press_byte", 0b0101.toInt())
+    val byteValue = currentByteValue ?: (savedByte and 0xFF).toByte()
+
+    val isChecked = (byteValue.toInt() and bit) != 0
+    val checked = remember { mutableStateOf(isChecked) }
+
+    Log.d("PressAndHoldSettingsScreen", "LongPressElement: $name, checked: ${checked.value}, byteValue: ${byteValue.toInt()}, in bits: ${byteValue.toInt().toString(2)}")
+    val darkMode = isSystemInDarkTheme()
+    val textColor = if (darkMode) Color.White else Color.Black
+    val desc = when (name) {
+        "Off" -> "Turns off noise management"
+        "Noise Cancellation" -> "Blocks out external sounds"
+        "Transparency" -> "Lets in external sounds"
+        "Adaptive" -> "Dynamically adjust external noise"
+        else -> ""
+    }
+
+    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++
+
+        Log.d("PressAndHoldSettingsScreen", "Byte: ${byteValue.toString(2)} Enabled modes: $count")
+        return count
+    }
+
+    fun valueChanged(value: Boolean = !checked.value) {
+        val latestByteValue = ServiceManager.getService()!!.aacpManager.controlCommandStatusList.find {
+            it.identifier == AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS
+        }?.value?.takeIf { it.isNotEmpty() }?.get(0)
+
+        val currentValue = (latestByteValue?.toInt() ?: byteValue.toInt()) and 0xFF
+
+        Log.d("PressAndHoldSettingsScreen", "Current value: $currentValue (binary: ${Integer.toBinaryString(currentValue)}), bit: $bit, value: $value")
+
+        if (!value) {
+            val newValue = currentValue and bit.inv()
+
+            Log.d("PressAndHoldSettingsScreen", "Bit to disable: $bit, inverted: ${bit.inv()}, after AND: ${Integer.toBinaryString(newValue)}")
+
+            val modeCount = countEnabledModes(newValue)
+
+            Log.d("PressAndHoldSettingsScreen", "After disabling, enabled modes count: $modeCount")
+
+            if (modeCount < 2) {
+                Log.d("PressAndHoldSettingsScreen", "Cannot disable $name mode - need at least 2 modes enabled")
+                return
+            }
+
+            val updatedByte = newValue.toByte()
+
+            Log.d("PressAndHoldSettingsScreen", "Sending updated byte: ${updatedByte.toInt() and 0xFF} (binary: ${Integer.toBinaryString(updatedByte.toInt() and 0xFF)})")
+
+            ServiceManager.getService()!!.aacpManager.sendControlCommand(
+                AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS.value,
+                updatedByte
+            )
+
+            context.getSharedPreferences("settings", Context.MODE_PRIVATE).edit()
+                .putInt("long_press_byte", newValue).apply()
+
+            checked.value = false
+            Log.d("PressAndHoldSettingsScreen", "Updated: $name, enabled: false, byte: ${updatedByte.toInt() and 0xFF}, bits: ${Integer.toBinaryString(updatedByte.toInt() and 0xFF)}")
+        } else {
+            val newValue = currentValue or bit
+            val updatedByte = newValue.toByte()
+
+            ServiceManager.getService()!!.aacpManager.sendControlCommand(
+                AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE_CONFIGS.value,
+                updatedByte
+            )
+
+            context.getSharedPreferences("settings", Context.MODE_PRIVATE).edit()
+                .putInt("long_press_byte", newValue).apply()
+
+            checked.value = true
+            Log.d("PressAndHoldSettingsScreen", "Updated: $name, enabled: true, byte: ${updatedByte.toInt() and 0xFF}, bits: ${newValue.toString(2)}")
+        }
+    }
+
+    val shape = when {
+        isFirst -> RoundedCornerShape(topStart = 14.dp, topEnd = 14.dp)
+        isLast -> RoundedCornerShape(bottomStart = 14.dp, bottomEnd = 14.dp)
+        else -> RoundedCornerShape(0.dp)
+    }
+    var backgroundColor by remember { mutableStateOf(if (darkMode) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)) }
+    val animatedBackgroundColor by animateColorAsState(targetValue = backgroundColor, animationSpec = tween(durationMillis = 500))
+    if (!enabled) {
+        valueChanged(false)
+    } else {
+        Row(
+            modifier = Modifier
+                .height(72.dp)
+                .background(animatedBackgroundColor, shape)
+                .pointerInput(Unit) {
+                    detectTapGestures(
+                        onPress = {
+                            backgroundColor = if (darkMode) Color(0x40888888) else Color(0x40D9D9D9)
+                            tryAwaitRelease()
+                            backgroundColor = if (darkMode) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+                            valueChanged()
+                        },
+                    )
+                }
+                .padding(horizontal = 16.dp, vertical = 0.dp),
+            verticalAlignment = Alignment.CenterVertically,
+            horizontalArrangement = Arrangement.SpaceBetween
+        ) {
+            Icon(
+                bitmap = ImageBitmap.imageResource(resourceId),
+                contentDescription = "Icon",
+                tint = Color(0xFF007AFF),
+                modifier = Modifier
+                    .height(48.dp)
+                    .wrapContentWidth()
+            )
+            Column (
+                modifier = Modifier
+                    .weight(1f)
+                    .padding(vertical = 2.dp)
+                    .padding(start = 8.dp)
+            )
+            {
+                Text(
+                    name,
+                    fontSize = 16.sp,
+                    fontFamily = FontFamily(Font(R.font.sf_pro)),
+                )
+                Text (
+                    desc,
+                    fontSize = 14.sp,
+                    color = textColor.copy(alpha = 0.6f),
+                    fontFamily = FontFamily(Font(R.font.sf_pro)),
+                )
+            }
+            Checkbox(
+                checked = checked.value,
+                onCheckedChange = { valueChanged() },
+                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
+                ),
+                modifier = Modifier
+                    .height(24.dp)
+                    .scale(1.5f),
+            )
+        }
+    }
+}

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

@@ -0,0 +1,204 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.screens
+
+import android.content.Context
+import androidx.compose.foundation.background
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.Row
+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.foundation.text.BasicTextField
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.filled.KeyboardArrowLeft
+import androidx.compose.material.icons.filled.Clear
+import androidx.compose.material3.CenterAlignedTopAppBar
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.IconButton
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBarDefaults
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+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.scale
+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.platform.LocalContext
+import androidx.compose.ui.platform.LocalSoftwareKeyboardController
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.TextRange
+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.tooling.preview.Preview
+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.services.ServiceManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun RenameScreen(navController: NavController) {
+    val sharedPreferences = LocalContext.current.getSharedPreferences("settings", Context.MODE_PRIVATE)
+    val isDarkTheme = isSystemInDarkTheme()
+    val name = remember { mutableStateOf(TextFieldValue(sharedPreferences.getString("name", "") ?: "")) }
+    val focusRequester = remember { FocusRequester() }
+    val keyboardController = LocalSoftwareKeyboardController.current
+
+    LaunchedEffect(Unit) {
+        focusRequester.requestFocus()
+        keyboardController?.show()
+        name.value = name.value.copy(selection = TextRange(name.value.text.length))
+    }
+
+    Scaffold(
+        topBar = {
+            CenterAlignedTopAppBar(
+                title = {
+                    Text(
+                        text = stringResource(R.string.name),
+                        fontFamily = FontFamily(Font(R.font.sf_pro)),
+                    )
+                },
+                navigationIcon = {
+                    TextButton(
+                        onClick = {
+                            navController.popBackStack()
+                        },
+                        shape = RoundedCornerShape(8.dp),
+                    ) {
+                        Icon(
+                            Icons.AutoMirrored.Filled.KeyboardArrowLeft,
+                            contentDescription = "Back",
+                            tint = if (isDarkTheme)  Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                            modifier = Modifier.scale(1.5f)
+                        )
+                        Text(
+                            text = name.value.text,
+                            style = TextStyle(
+                                fontSize = 18.sp,
+                                fontWeight = FontWeight.Medium,
+                                color = if (isDarkTheme) Color(0xFF007AFF) else Color(0xFF3C6DF5),
+                                fontFamily = FontFamily(Font(R.font.sf_pro))
+                            ),
+                        )
+                    }
+                },
+                colors = TopAppBarDefaults.topAppBarColors(
+                    containerColor = Color.Transparent
+                )
+            )
+        },
+        containerColor = if (isSystemInDarkTheme()) Color(0xFF000000)
+        else Color(0xFFF2F2F7),
+    ) { paddingValues ->
+        Column (
+            modifier = Modifier
+                .fillMaxSize()
+                .padding(paddingValues = paddingValues)
+                .padding(horizontal = 16.dp)
+                .padding(top = 8.dp)
+        ) {
+            val isDarkTheme = isSystemInDarkTheme()
+            val backgroundColor = if (isDarkTheme) Color(0xFF1C1C1E) else Color(0xFFFFFFFF)
+            val textColor = if (isDarkTheme) Color.White else Color.Black
+            val cursorColor =  if (isDarkTheme) Color.White else Color.Black
+            Row(
+                verticalAlignment = Alignment.CenterVertically,
+                modifier = Modifier
+                    .fillMaxWidth()
+                    .height(55.dp)
+                    .background(
+                        backgroundColor,
+                        RoundedCornerShape(14.dp)
+                    )
+                    .padding(horizontal = 16.dp, vertical = 8.dp)
+            ) {
+                BasicTextField(
+                    value = name.value,
+                    onValueChange = {
+                        name.value = it
+                        sharedPreferences.edit().putString("name", it.text).apply()
+                        ServiceManager.getService()?.setName(it.text)
+                    },
+                    textStyle = TextStyle(
+                        color = textColor,
+                        fontSize = 16.sp,
+                    ),
+                    singleLine = true,
+                    cursorBrush = SolidColor(cursorColor),
+                    decorationBox = { innerTextField ->
+                        Row(
+                            verticalAlignment = Alignment.CenterVertically,
+                        ) {
+                            Row(
+                                modifier = Modifier
+                                    .weight(1f)
+                            ) {
+                                innerTextField()
+                            }
+                            IconButton(
+                                onClick = {
+                                    name.value = TextFieldValue("")
+                                    sharedPreferences.edit().putString("name", "").apply()
+                                    ServiceManager.getService()?.setName("")
+                                }
+                            ) {
+                                Icon(
+                                    Icons.Default.Clear,
+                                    contentDescription = "Clear",
+                                    tint = if (isDarkTheme) Color.White else Color.Black
+                                )
+                            }
+                        }
+                    },
+                    modifier = Modifier
+                        .fillMaxWidth()
+                        .padding(start = 8.dp)
+                        .focusRequester(focusRequester)
+                )
+            }
+        }
+    }
+}
+
+@Preview
+@Composable
+fun RenameScreenPreview() {
+    RenameScreen(navController = NavController(LocalContext.current))
+}

android/app/src/main/java/me/kavishdevar/librepods/services/AirPodsQSService.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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.services
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.content.SharedPreferences
+import android.graphics.drawable.Icon
+import android.os.Build
+import android.service.quicksettings.Tile
+import android.service.quicksettings.TileService
+import android.util.Log
+import androidx.annotation.RequiresApi
+import me.kavishdevar.librepods.QuickSettingsDialogActivity
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.utils.AACPManager
+import me.kavishdevar.librepods.utils.AirPodsNotifications
+import me.kavishdevar.librepods.utils.NoiseControlMode
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+@RequiresApi(Build.VERSION_CODES.Q)
+class AirPodsQSService : TileService() {
+
+    private lateinit var sharedPreferences: SharedPreferences
+    private var currentAncMode: Int = NoiseControlMode.OFF.ordinal + 1
+    private var isAirPodsConnected: Boolean = false
+
+    private val ancStatusReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            if (intent.action == AirPodsNotifications.ANC_DATA) {
+                val newMode = intent.getIntExtra("data", NoiseControlMode.OFF.ordinal + 1)
+                Log.d("AirPodsQSService", "Received ANC update: $newMode")
+                currentAncMode = newMode
+                updateTile()
+            }
+        }
+    }
+
+    private val availabilityReceiver = object : BroadcastReceiver() {
+        override fun onReceive(context: Context, intent: Intent) {
+            when (intent.action) {
+                AirPodsNotifications.AIRPODS_CONNECTED -> {
+                    Log.d("AirPodsQSService", "Received AIRPODS_CONNECTED")
+                    isAirPodsConnected = true
+                    currentAncMode =
+                        ServiceManager.getService()?.getANC() ?: (NoiseControlMode.OFF.ordinal + 1)
+                    updateTile()
+                }
+                AirPodsNotifications.AIRPODS_DISCONNECTED -> {
+                    Log.d("AirPodsQSService", "Received AIRPODS_DISCONNECTED")
+                    isAirPodsConnected = false
+                    updateTile()
+                }
+            }
+        }
+    }
+
+    private val preferenceChangeListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
+        if (key == "off_listening_mode") {
+            Log.d("AirPodsQSService", "Preference changed: $key")
+            if (currentAncMode == NoiseControlMode.OFF.ordinal + 1 && !isOffModeEnabled()) {
+                currentAncMode = NoiseControlMode.TRANSPARENCY.ordinal + 1
+            }
+            updateTile()
+        }
+    }
+
+    override fun onCreate() {
+        super.onCreate()
+        sharedPreferences = getSharedPreferences("settings", MODE_PRIVATE)
+    }
+
+    @SuppressLint("InlinedApi", "UnspecifiedRegisterReceiverFlag")
+    override fun onStartListening() {
+        super.onStartListening()
+        Log.d("AirPodsQSService", "onStartListening")
+
+        val service = ServiceManager.getService()
+        isAirPodsConnected = service?.isConnectedLocally == true
+        currentAncMode = service?.getANC() ?: (NoiseControlMode.OFF.ordinal + 1)
+
+        if (currentAncMode == NoiseControlMode.OFF.ordinal + 1 && !isOffModeEnabled()) {
+             currentAncMode = NoiseControlMode.TRANSPARENCY.ordinal + 1
+        }
+
+        val ancIntentFilter = IntentFilter(AirPodsNotifications.ANC_DATA)
+        val availabilityIntentFilter = IntentFilter().apply {
+            addAction(AirPodsNotifications.AIRPODS_CONNECTED)
+            addAction(AirPodsNotifications.AIRPODS_DISCONNECTED)
+        }
+
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                registerReceiver(ancStatusReceiver, ancIntentFilter, RECEIVER_EXPORTED)
+                registerReceiver(availabilityReceiver, availabilityIntentFilter, RECEIVER_EXPORTED)
+            } else {
+                registerReceiver(ancStatusReceiver, ancIntentFilter)
+                registerReceiver(availabilityReceiver, availabilityIntentFilter)
+            }
+            sharedPreferences.registerOnSharedPreferenceChangeListener(preferenceChangeListener)
+            Log.d("AirPodsQSService", "Receivers registered")
+        } catch (e: Exception) {
+            Log.e("AirPodsQSService", "Error registering receivers: $e")
+        }
+
+        updateTile()
+    }
+
+    override fun onStopListening() {
+        super.onStopListening()
+        Log.d("AirPodsQSService", "onStopListening")
+        try {
+            unregisterReceiver(ancStatusReceiver)
+            unregisterReceiver(availabilityReceiver)
+            sharedPreferences.unregisterOnSharedPreferenceChangeListener(preferenceChangeListener)
+            Log.d("AirPodsQSService", "Receivers unregistered")
+        } catch (e: IllegalArgumentException) {
+            Log.e("AirPodsQSService", "Receiver not registered or already unregistered: $e")
+        } catch (e: Exception) {
+            Log.e("AirPodsQSService", "Error unregistering receivers: $e")
+        }
+    }
+
+    override fun onClick() {
+        super.onClick()
+        Log.d("AirPodsQSService", "onClick - Current state: $isAirPodsConnected, Current mode: $currentAncMode")
+        if (!isAirPodsConnected) {
+            Log.d("AirPodsQSService", "Tile clicked but AirPods not connected.")
+            return
+        }
+
+        val clickBehavior = sharedPreferences.getString("qs_click_behavior", "dialog") ?: "dialog"
+
+        if (clickBehavior == "dialog") {
+            launchDialogActivity()
+        } else {
+            cycleAncMode()
+        }
+    }
+
+    private fun launchDialogActivity() {
+        try {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                val pendingIntent = PendingIntent.getActivity(
+                    this,
+                    0,
+                    Intent(this, QuickSettingsDialogActivity::class.java).apply {
+                        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                    },
+                    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+                )
+                startActivityAndCollapse(pendingIntent)
+            } else {
+                val intent = Intent(this, QuickSettingsDialogActivity::class.java).apply {
+                    addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
+                }
+                @Suppress("DEPRECATION")
+                @SuppressLint("StartActivityAndCollapseDeprecated")
+                startActivityAndCollapse(intent)
+            }
+            Log.d("AirPodsQSService", "Called startActivityAndCollapse for QuickSettingsDialogActivity")
+        } catch (e: Exception) {
+            Log.e("AirPodsQSService", "Error launching QuickSettingsDialogActivity: $e")
+        }
+    }
+
+    private fun cycleAncMode() {
+        val service = ServiceManager.getService()
+        if (service == null) {
+            Log.d("AirPodsQSService", "Tile clicked (cycle mode) but service is null.")
+            return
+        }
+        val nextMode = getNextAncMode()
+        Log.d("AirPodsQSService", "Cycling ANC mode to: $nextMode")
+        service.aacpManager.sendControlCommand(
+            AACPManager.Companion.ControlCommandIdentifiers.LISTENING_MODE.value,
+            nextMode
+        )
+    }
+
+    private fun updateTile() {
+        val tile = qsTile ?: return
+        Log.d("AirPodsQSService", "updateTile - Connected: $isAirPodsConnected, Mode: $currentAncMode")
+
+        val deviceName = sharedPreferences.getString("name", "AirPods") ?: "AirPods"
+
+        if (isAirPodsConnected) {
+            tile.state = Tile.STATE_ACTIVE
+            tile.label = getModeLabel(currentAncMode)
+            tile.subtitle = deviceName
+            tile.icon = Icon.createWithResource(this, getModeIcon(currentAncMode))
+        } else {
+            tile.state = Tile.STATE_UNAVAILABLE
+            tile.label = "AirPods"
+            tile.subtitle = "Disconnected"
+            tile.icon = Icon.createWithResource(this, R.drawable.airpods)
+        }
+
+        try {
+            tile.updateTile()
+            Log.d("AirPodsQSService", "Tile updated successfully")
+        } catch (e: Exception) {
+            Log.e("AirPodsQSService", "Error updating tile: $e")
+        }
+    }
+
+    private fun isOffModeEnabled(): Boolean {
+        return sharedPreferences.getBoolean("off_listening_mode", true)
+    }
+
+    private fun getAvailableModes(): List<Int> {
+        val modes = mutableListOf(
+            NoiseControlMode.TRANSPARENCY.ordinal + 1,
+            NoiseControlMode.ADAPTIVE.ordinal + 1,
+            NoiseControlMode.NOISE_CANCELLATION.ordinal + 1
+        )
+        if (isOffModeEnabled()) {
+            modes.add(0, NoiseControlMode.OFF.ordinal + 1)
+        }
+        return modes
+    }
+
+    private fun getNextAncMode(): Int {
+        val availableModes = getAvailableModes()
+        val currentIndex = availableModes.indexOf(currentAncMode)
+        val nextIndex = (currentIndex + 1) % availableModes.size
+        return availableModes[nextIndex]
+    }
+
+    private fun getModeLabel(mode: Int): String {
+        return when (mode) {
+            NoiseControlMode.OFF.ordinal + 1 -> "Off"
+            NoiseControlMode.TRANSPARENCY.ordinal + 1 -> "Transparency"
+            NoiseControlMode.ADAPTIVE.ordinal + 1 -> "Adaptive"
+            NoiseControlMode.NOISE_CANCELLATION.ordinal + 1 -> "Noise Cancellation"
+            else -> "Unknown"
+        }
+    }
+
+     private fun getModeIcon(mode: Int): Int {
+         return when (mode) {
+             NoiseControlMode.OFF.ordinal + 1 -> R.drawable.noise_cancellation
+             NoiseControlMode.TRANSPARENCY.ordinal + 1 -> R.drawable.transparency
+             NoiseControlMode.ADAPTIVE.ordinal + 1 -> R.drawable.adaptive
+             NoiseControlMode.NOISE_CANCELLATION.ordinal + 1 -> R.drawable.noise_cancellation
+             else -> R.drawable.airpods
+         }
+     }
+
+    override fun onTileAdded() {
+        super.onTileAdded()
+        Log.d("AirPodsQSService", "Tile added")
+    }
+}

android/app/src/main/java/me/kavishdevar/librepods/ui/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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+package me.kavishdevar.librepods.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/ui/theme/Theme.kt

@@ -1,4 +1,22 @@
-package me.kavishdevar.aln.ui.theme
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.ui.theme
 
 import android.os.Build
 import androidx.compose.foundation.isSystemInDarkTheme
@@ -20,21 +38,11 @@ private val LightColorScheme = lightColorScheme(
     primary = Purple40,
     secondary = PurpleGrey40,
     tertiary = Pink40
-    /* Other default colors to override
-    background = Color(0xFFFFFBFE),
-    surface = Color(0xFFFFFBFE),
-    onPrimary = Color.White,
-    onSecondary = Color.White,
-    onTertiary = Color.White,
-    onBackground = Color(0xFF1C1B1F),
-    onSurface = Color(0xFF1C1B1F),
-    */
 )
 
 @Composable
-fun ALNTheme(
+fun LibrePodsTheme(
     darkTheme: Boolean = isSystemInDarkTheme(),
-    // Dynamic color is available on Android 12+
     dynamicColor: Boolean = true,
     content: @Composable () -> Unit
 ) {

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

@@ -1,4 +1,22 @@
-package me.kavishdevar.aln.ui.theme
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ * 
+ * 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 Affero General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.ui.theme
 
 import androidx.compose.material3.Typography
 import androidx.compose.ui.text.TextStyle

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

@@ -0,0 +1,478 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.utils
+
+import android.util.Log
+import me.kavishdevar.librepods.utils.AACPManager.Companion.ControlCommandIdentifiers.entries
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+/**
+ * Manager class for Apple Accessory Communication Protocol (AACP)
+ * This class is responsible for handling the L2CAP socket management,
+ * constructing and parsing packets for communication with Apple accessories.
+ */
+class AACPManager {
+    companion object {
+        private const val TAG = "AACPManager"
+
+        object Opcodes {
+            const val SET_FEATURE_FLAGS: Byte = 0x4d
+            const val REQUEST_NOTIFICATIONS: Byte = 0x0f
+            const val BATTERY_INFO: Byte = 0x04
+            const val CONTROL_COMMAND: Byte = 0x09
+            const val EAR_DETECTION: Byte = 0x06
+            const val CONVERSATION_AWARENESS: Byte = 0x4b
+            const val DEVICE_METADATA: Byte = 0x1d
+            const val RENAME: Byte = 0x1E
+            const val HEADTRACKING: Byte = 0x17
+            const val PROXIMITY_KEYS_REQ: Byte = 0x30
+            const val PROXIMITY_KEYS_RSP: Byte = 0x31
+        }
+
+        private val HEADER_BYTES = byteArrayOf(0x04, 0x00, 0x04, 0x00)
+
+        data class ControlCommandStatus(
+            val identifier: ControlCommandIdentifiers,
+            val value: ByteArray
+        ) {
+            override fun equals(other: Any?): Boolean {
+                if (this === other) return true
+                if (javaClass != other?.javaClass) return false
+
+                other as ControlCommandStatus
+
+                if (identifier != other.identifier) return false
+                if (!value.contentEquals(other.value)) return false
+
+                return true
+            }
+
+            override fun hashCode(): Int {
+                var result: Int = identifier.hashCode()
+                result = 31 * result + value.contentHashCode()
+                return result
+            }
+        }
+
+//        @Suppress("unused")
+        enum class ControlCommandIdentifiers(val value: Byte) {
+            MIC_MODE(0x01),
+            BUTTON_SEND_MODE(0x05),
+            VOICE_TRIGGER(0x12),
+            SINGLE_CLICK_MODE(0x14),
+            DOUBLE_CLICK_MODE(0x15),
+            CLICK_HOLD_MODE(0x16),
+            DOUBLE_CLICK_INTERVAL(0x17),
+            CLICK_HOLD_INTERVAL(0x18),
+            LISTENING_MODE_CONFIGS(0x1A),
+            ONE_BUD_ANC_MODE(0x1B),
+            CROWN_ROTATION_DIRECTION(0x1C),
+            LISTENING_MODE(0x0D),
+            AUTO_ANSWER_MODE(0x1E),
+            CHIME_VOLUME(0x1F),
+            VOLUME_SWIPE_INTERVAL(0x23),
+            CALL_MANAGEMENT_CONFIG(0x24),
+            VOLUME_SWIPE_MODE(0x25),
+            ADAPTIVE_VOLUME_CONFIG(0x26),
+            SOFTWARE_MUTE_CONFIG(0x27),
+            CONVERSATION_DETECT_CONFIG(0x28),
+            SSL(0x29),
+            HEARING_AID(0x2C),
+            AUTO_ANC_STRENGTH(0x2E),
+            HPS_GAIN_SWIPE(0x2F),
+            HRM_STATE(0x30),
+            IN_CASE_TONE_CONFIG(0x31),
+            SIRI_MULTITONE_CONFIG(0x32),
+            HEARING_ASSIST_CONFIG(0x33),
+            ALLOW_OFF_OPTION(0x34);
+
+            companion object {
+                fun fromByte(byte: Byte): ControlCommandIdentifiers? =
+                    entries.find { it.value == byte }
+            }
+        }
+
+        enum class ProximityKeyType(val value: Byte) {
+            IRK(0x01),
+            ENC_KEY(0x04);
+
+            companion object {
+                fun fromByte(byte: Byte): ProximityKeyType =
+                    ProximityKeyType.entries.find { it.value == byte }?: throw IllegalArgumentException("Unknown ProximityKeyType: $byte")
+            }
+        }
+    }
+    var controlCommandStatusList: MutableList<ControlCommandStatus> = mutableListOf<ControlCommandStatus>()
+    var controlCommandListeners: MutableMap<ControlCommandIdentifiers, MutableList<ControlCommandListener>> = mutableMapOf()
+
+    fun getControlCommandStatus(identifier: ControlCommandIdentifiers): ControlCommandStatus? {
+        return controlCommandStatusList.find { it.identifier == identifier }
+    }
+
+    private fun setControlCommandStatusValue(identifier: ControlCommandIdentifiers, value: ByteArray) {
+        val existingStatus = getControlCommandStatus(identifier)
+        if (existingStatus == value) {
+            controlCommandStatusList.remove(existingStatus)
+        }
+        if (existingStatus != null) {
+            controlCommandStatusList.remove(existingStatus)
+        }
+        controlCommandListeners[identifier]?.forEach { listener ->
+            listener.onControlCommandReceived(ControlCommand(identifier.value, value))
+        }
+        controlCommandStatusList.add(ControlCommandStatus(identifier, value))
+    }
+
+    interface PacketCallback {
+        fun onBatteryInfoReceived(batteryInfo: ByteArray)
+        fun onEarDetectionReceived(earDetection: ByteArray)
+        fun onConversationAwarenessReceived(conversationAwareness: ByteArray)
+        fun onControlCommandReceived(controlCommand: ByteArray)
+        fun onDeviceMetadataReceived(deviceMetadata: ByteArray)
+        fun onHeadTrackingReceived(headTracking: ByteArray)
+        fun onUnknownPacketReceived(packet: ByteArray)
+        fun onProximityKeysReceived(proximityKeys: ByteArray)
+    }
+
+    interface ControlCommandListener {
+        fun onControlCommandReceived(controlCommand: ControlCommand)
+    }
+
+    fun registerControlCommandListener(identifier: ControlCommandIdentifiers, callback: ControlCommandListener) {
+        controlCommandListeners.getOrPut(identifier) { mutableListOf() }.add(callback)
+    }
+
+    private var callback: PacketCallback? = null
+
+    fun setPacketCallback(callback: PacketCallback) {
+        this.callback = callback
+    }
+
+    fun createDataPacket(data: ByteArray): ByteArray {
+        return HEADER_BYTES + data
+    }
+
+    fun createControlCommandPacket(identifier: Byte, data: ByteArray): ByteArray {
+        val opcode = byteArrayOf(Opcodes.CONTROL_COMMAND, 0x00)
+        val payload = ByteArray(7)
+
+        System.arraycopy(opcode, 0, payload, 0, 2)
+        payload[2] = identifier
+
+        val dataLength = minOf(data.size, 4)
+        System.arraycopy(data, 0, payload, 3, dataLength)
+
+        return payload
+    }
+
+    fun sendDataPacket(data: ByteArray): Boolean {
+        return sendPacket(createDataPacket(data))
+    }
+
+    fun sendControlCommand(identifier: Byte, value: ByteArray): Boolean {
+        val controlPacket = createControlCommandPacket(identifier, value)
+        setControlCommandStatusValue(
+            ControlCommandIdentifiers.fromByte(identifier) ?: return false,
+            value
+        )
+        return sendDataPacket(controlPacket)
+    }
+
+    fun sendControlCommand(identifier: Byte, value: Byte): Boolean {
+        val controlPacket = createControlCommandPacket(identifier, byteArrayOf(value))
+        setControlCommandStatusValue(
+            ControlCommandIdentifiers.fromByte(identifier) ?: return false,
+            byteArrayOf(value)
+        )
+        return sendDataPacket(controlPacket)
+    }
+
+    fun sendControlCommand(identifier: Byte, value: Boolean): Boolean {
+        val controlPacket = createControlCommandPacket(identifier, if (value) byteArrayOf(0x01) else byteArrayOf(0x02))
+        setControlCommandStatusValue(
+            ControlCommandIdentifiers.fromByte(identifier) ?: return false,
+            if (value) byteArrayOf(0x01) else byteArrayOf(0x02)
+        )
+        return sendDataPacket(controlPacket)
+    }
+
+    fun sendControlCommand(identifier: Byte, value: Int): Boolean {
+        val controlPacket = createControlCommandPacket(identifier, byteArrayOf(value.toByte()))
+        setControlCommandStatusValue(
+            ControlCommandIdentifiers.fromByte(identifier) ?: return false,
+            byteArrayOf(value.toByte())
+        )
+        return sendDataPacket(controlPacket)
+    }
+
+    fun parseProximityKeysResponse(data: ByteArray): Map<ProximityKeyType, ByteArray> {
+        Log.d(TAG, "Parsing Proximity Keys Response: ${data.joinToString(" ") { "%02X".format(it) }}")
+        if (data.size < 4) {
+            throw IllegalArgumentException("Data array too short to parse Proximity Keys Response")
+        }
+        if (data[4] != Opcodes.PROXIMITY_KEYS_RSP) {
+            throw IllegalArgumentException("Data array does not start with PROXIMITY_KEYS_RSP opcode")
+        }
+        val keyCount = data[6].toInt()
+        val keys = mutableMapOf<ProximityKeyType, ByteArray>()
+        var offset = 7
+        for (i in 0 until keyCount) {
+            Log.d(TAG, "Parsing Proximity Key $i")
+            if (offset + 3 >= data.size) {
+                throw IllegalArgumentException("Data array too short to parse Proximity Keys Response")
+            }
+            val keyType = data[offset]
+            val keyLength = data[offset + 2].toInt()
+            Log.d(TAG, "Key Type: ${keyType.toString(16)}, Key Length: $keyLength")
+            offset += 4
+            if (offset + keyLength > data.size) {
+                throw IllegalArgumentException("Data array too short to parse Proximity Keys Response")
+            }
+            val key = ByteArray(keyLength)
+            System.arraycopy(data, offset, key, 0, keyLength)
+            keys[ProximityKeyType.fromByte(keyType)] = key
+            offset += keyLength
+            Log.d(TAG, "Parsed Proximity Key: Type: ${keyType}, Length: $keyLength, Key: ${key.joinToString(" ") { "%02X".format(it) }}")
+        }
+        return keys
+    }
+
+    fun sendRequestProximityKeys(type: Byte): Boolean {
+        Log.d(TAG, "Requesting proximity keys of type: ${type.toString(16)}")
+        return sendDataPacket(createRequestProximityKeysPacket(type))
+    }
+
+    fun createRequestProximityKeysPacket(type: Byte): ByteArray {
+        val opcode = byteArrayOf(Opcodes.PROXIMITY_KEYS_REQ, 0x00)
+        val data = byteArrayOf(type, 0x00)
+        return opcode + data
+    }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    fun receivePacket(packet: ByteArray) {
+        if (!packet.toHexString().startsWith("04000400")) {
+            Log.w(TAG, "Received packet does not start with expected header: ${packet.joinToString(" ") { "%02X".format(it) }}")
+            return
+        }
+        if (packet.size < 6) {
+            Log.w(TAG, "Received packet too short: ${packet.joinToString(" ") { "%02X".format(it) }}")
+            return
+        }
+
+        val opcode = packet[4]
+
+        when (opcode) {
+            Opcodes.BATTERY_INFO -> {
+                callback?.onBatteryInfoReceived(packet)
+            }
+            Opcodes.CONTROL_COMMAND -> {
+                val controlCommand = ControlCommand.fromByteArray(packet)
+                setControlCommandStatusValue(
+                    ControlCommandIdentifiers.fromByte(controlCommand.identifier) ?: return,
+                    controlCommand.value
+                )
+                Log.d(TAG, "Control command received: ${controlCommand.identifier.toHexString()} - ${controlCommand.value.joinToString(" ") { "%02X".format(it) }}")
+                Log.d(TAG, "Control command list is now: ${
+                    controlCommandStatusList.joinToString(", ") { "${it.identifier.name} (${it.identifier.value.toHexString()}) - ${it.value.joinToString(" ") { "%02X".format(it) }}" }
+                }")
+
+                val controlCommandIdentifier = ControlCommandIdentifiers.fromByte(controlCommand.identifier)
+                if (controlCommandIdentifier != null) {
+                    controlCommandListeners[controlCommandIdentifier]?.forEach { listener ->
+                        listener.onControlCommandReceived(controlCommand)
+                    }
+                } else {
+                    Log.w(TAG, "Unknown control command identifier: ${controlCommand.identifier.toHexString()}")
+                }
+
+                callback?.onControlCommandReceived(packet)
+            }
+            Opcodes.EAR_DETECTION -> {
+                callback?.onEarDetectionReceived(packet)
+            }
+            Opcodes.CONVERSATION_AWARENESS -> {
+                callback?.onConversationAwarenessReceived(packet)
+            }
+            Opcodes.DEVICE_METADATA -> {
+                callback?.onDeviceMetadataReceived(packet)
+            }
+            Opcodes.HEADTRACKING -> {
+                if (packet.size < 70) {
+                    Log.w(TAG, "Received HEADTRACKING packet too short: ${packet.joinToString(" ") { "%02X".format(it) }}")
+                    return
+                }
+                callback?.onHeadTrackingReceived(packet)
+            }
+            Opcodes.PROXIMITY_KEYS_RSP -> {
+                callback?.onProximityKeysReceived(packet)
+            }
+            else -> {
+                callback?.onUnknownPacketReceived(packet)
+            }
+        }
+    }
+
+    fun sendNotificationRequest(): Boolean {
+        return sendDataPacket(createRequestNotificationPacket())
+    }
+
+    fun createRequestNotificationPacket(): ByteArray {
+        val opcode = byteArrayOf(Opcodes.REQUEST_NOTIFICATIONS, 0x00)
+        val data = byteArrayOf(0xFF.toByte(), 0xFF.toByte(), 0xFF.toByte(), 0xFF.toByte())
+        return opcode + data
+    }
+
+    fun sendSetFeatureFlagsPacket(): Boolean {
+        return sendDataPacket(createSetFeatureFlagsPacket())
+    }
+
+    fun createSetFeatureFlagsPacket(): ByteArray {
+        val opcode = byteArrayOf(Opcodes.SET_FEATURE_FLAGS, 0x00)
+        val data = byteArrayOf(0xFF.toByte(), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
+        return opcode + data
+    }
+
+    fun createHandshakePacket(): ByteArray {
+        return byteArrayOf(
+            0x00, 0x00, 0x04, 0x00,
+            0x01, 0x00, 0x02, 0x00,
+            0x00, 0x00, 0x00, 0x00,
+            0x00, 0x00, 0x00, 0x00
+        )
+    }
+
+    fun sendStartHeadTracking(): Boolean {
+        return sendDataPacket(createStartHeadTrackingPacket())
+    }
+
+    fun createStartHeadTrackingPacket(): ByteArray {
+        val opcode = byteArrayOf(Opcodes.HEADTRACKING, 0x00)
+        val data = byteArrayOf(
+            0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x08, 0xA1.toByte(), 0x02, 0x42, 0x0B, 0x08, 0x0E, 0x10, 0x02, 0x1A, 0x05, 0x01, 0x40, 0x9C.toByte(), 0x00, 0x00,
+        )
+        return opcode + data
+    }
+
+    fun sendStopHeadTracking(): Boolean {
+        return sendDataPacket(createStopHeadTrackingPacket())
+    }
+
+    fun createStopHeadTrackingPacket(): ByteArray {
+        val opcode = byteArrayOf(Opcodes.HEADTRACKING, 0x00)
+        val data = byteArrayOf(
+            0x00, 0x00, 0x10, 0x00, 0x11, 0x00, 0x08, 0x7E, 0x10, 0x02, 0x42, 0x0B, 0x08, 0x4E, 0x10, 0x02, 0x1A, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00
+        )
+        return opcode + data
+    }
+
+    fun sendRename(name: String): Boolean {
+        return sendDataPacket(createRenamePacket(name))
+    }
+
+    fun createRenamePacket(name: String): ByteArray {
+        val nameBytes = name.toByteArray()
+        val size = nameBytes.size
+        val packet = ByteArray(5 + size)
+        packet[0] = Opcodes.RENAME
+        packet[1] = 0x00
+        packet[2] = size.toByte()
+        packet[3] = 0x00
+        System.arraycopy(nameBytes, 0, packet, 4, size)
+
+        return packet
+    }
+
+
+    data class ControlCommand(
+        val identifier: Byte,
+        val value: ByteArray
+    ) {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (javaClass != other?.javaClass) return false
+
+            other as ControlCommand
+
+            if (identifier != other.identifier) return false
+            if (!value.contentEquals(other.value)) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result: Int = identifier.toInt()
+            result = 31 * result + value.contentHashCode()
+            return result
+        }
+
+        companion object {
+            fun fromByteArray(data: ByteArray): ControlCommand {
+                if (data.size < 4) {
+                    throw IllegalArgumentException("Data array too short to parse ControlCommand")
+                }
+                if (data[0] == 0x04.toByte() && data[1] == 0x00.toByte() && data[2] == 0x04.toByte() && data[3] == 0x00.toByte()) {
+                    val newData = ByteArray(data.size - 4)
+                    System.arraycopy(data, 4, newData, 0, data.size - 4)
+                    return fromByteArray(newData)
+                }
+                if (data[0] != Opcodes.CONTROL_COMMAND) {
+                    throw IllegalArgumentException("Data array does not start with CONTROL_COMMAND opcode")
+                }
+                val identifier = data[2]
+
+                val value = ByteArray(4)
+                System.arraycopy(data, 3, value, 0, 4)
+
+                // drop trailing zeroes in the array, and return the bytearray of the reduced array
+                val trimmedValue = value.takeWhile { it != 0x00.toByte() }.toByteArray()
+                return ControlCommand(identifier, trimmedValue)
+            }
+        }
+    }
+
+   @OptIn(ExperimentalStdlibApi::class)
+   fun sendPacket(packet: ByteArray): Boolean {
+        try {
+            Log.d(TAG, "Sending packet: ${packet.joinToString(" ") { "%02X".format(it) }}")
+
+            if (packet[4] == Opcodes.CONTROL_COMMAND) {
+                val controlCommand = ControlCommand.fromByteArray(packet)
+                Log.d(TAG, "Control command: ${controlCommand.identifier.toHexString()} - ${controlCommand.value.joinToString(" ") { "%02X".format(it) }}")
+                setControlCommandStatusValue(
+                    ControlCommandIdentifiers.fromByte(controlCommand.identifier) ?: return false,
+                    controlCommand.value
+                )
+            }
+
+            val socket = BluetoothConnectionManager.getCurrentSocket()
+            if (socket?.isConnected == true) {
+                socket.outputStream?.write(packet)
+                socket.outputStream?.flush()
+                return true
+            } else {
+                Log.d(TAG, "Can't send packet: Socket not initialized or connected")
+                return false
+            }
+        } catch (e: Exception) {
+            Log.e(TAG, "Error sending packet: ${e.message}")
+            return false
+        }
+    }
+}

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

@@ -0,0 +1,490 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.utils
+
+import android.annotation.SuppressLint
+import 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.services.ServiceManager
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+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)
+    }
+
+    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
+        }
+    }
+
+    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 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}")
+        }
+    }
+
+    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 = 30000L
+        private const val STALE_DEVICE_TIMEOUT_MS = 60000L
+        private const val LID_CLOSE_TIMEOUT_MS = 2000L
+    }
+}

android/app/src/main/java/me/kavishdevar/librepods/utils/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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.utils
+
+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/utils/BluetoothCryptography.kt

@@ -0,0 +1,74 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.utils
+
+import javax.crypto.Cipher
+import javax.crypto.spec.SecretKeySpec
+
+/**
+ * Utilities for Bluetooth cryptography operations, particularly for
+ * verifying Resolvable Private Addresses (RPA) used by AirPods.
+ */
+object BluetoothCryptography {
+    
+    /**
+     * Verifies if the provided Bluetooth address is an RPA that matches the given Identity Resolving Key (IRK)
+     * 
+     * @param addr The Bluetooth address to verify
+     * @param irk The Identity Resolving Key to use for verification
+     * @return true if the address is verified as an RPA matching the IRK
+     */
+    fun verifyRPA(addr: String, irk: ByteArray): Boolean {
+        val rpa = addr.split(":").map { it.toInt(16).toByte() }.reversed().toByteArray()
+        val prand = rpa.copyOfRange(3, 6)
+        val hash = rpa.copyOfRange(0, 3)
+        val computedHash = ah(irk, prand)
+        return hash.contentEquals(computedHash)
+    }
+
+    /**
+     * Performs E function (AES-128) as specified in Bluetooth Core Specification
+     * 
+     * @param key The key for encryption
+     * @param data The data to encrypt
+     * @return The encrypted data
+     */
+    fun e(key: ByteArray, data: ByteArray): ByteArray {
+        val swappedKey = key.reversedArray()
+        val swappedData = data.reversedArray()
+        val cipher = Cipher.getInstance("AES/ECB/NoPadding")
+        val secretKey = SecretKeySpec(swappedKey, "AES")
+        cipher.init(Cipher.ENCRYPT_MODE, secretKey)
+        return cipher.doFinal(swappedData).reversedArray()
+    }
+
+    /**
+     * Performs the ah function as specified in Bluetooth Core Specification
+     * 
+     * @param k The IRK key
+     * @param r The random part of the address
+     * @return The hash part of the address
+     */
+    fun ah(k: ByteArray, r: ByteArray): ByteArray {
+        val rPadded = ByteArray(16)
+        r.copyInto(rPadded, 0, 0, 3)
+        val encrypted = e(k, rPadded)
+        return encrypted.copyOfRange(0, 3)
+    }
+}

android/app/src/main/java/me/kavishdevar/librepods/utils/CrossDevice.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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.utils
+
+import android.annotation.SuppressLint
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothServerSocket
+import android.bluetooth.BluetoothSocket
+import android.bluetooth.le.AdvertiseCallback
+import android.bluetooth.le.AdvertiseData
+import android.bluetooth.le.AdvertiseSettings
+import android.bluetooth.le.BluetoothLeAdvertiser
+import android.content.Context
+import android.content.Intent
+import android.content.SharedPreferences
+import android.os.ParcelUuid
+import android.util.Log
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import me.kavishdevar.librepods.services.ServiceManager
+import java.io.IOException
+import java.util.UUID
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+enum class CrossDevicePackets(val packet: ByteArray) {
+    AIRPODS_CONNECTED(byteArrayOf(0x00, 0x01, 0x00, 0x01)),
+    AIRPODS_DISCONNECTED(byteArrayOf(0x00, 0x01, 0x00, 0x00)),
+    REQUEST_DISCONNECT(byteArrayOf(0x00, 0x02, 0x00, 0x00)),
+    REQUEST_BATTERY_BYTES(byteArrayOf(0x00, 0x02, 0x00, 0x01)),
+    REQUEST_ANC_BYTES(byteArrayOf(0x00, 0x02, 0x00, 0x02)),
+    REQUEST_CONNECTION_STATUS(byteArrayOf(0x00, 0x02, 0x00, 0x03)),
+    AIRPODS_DATA_HEADER(byteArrayOf(0x00, 0x04, 0x00, 0x01)),
+}
+
+
+object CrossDevice {
+    var initialized = false
+    private val uuid = UUID.fromString("1abbb9a4-10e4-4000-a75c-8953c5471342")
+    private var serverSocket: BluetoothServerSocket? = null
+    private var clientSocket: BluetoothSocket? = null
+    private lateinit var bluetoothAdapter: BluetoothAdapter
+    private lateinit var bluetoothLeAdvertiser: BluetoothLeAdvertiser
+    private const val MANUFACTURER_ID = 0x1234
+    private const val MANUFACTURER_DATA = "ALN_AirPods"
+    var isAvailable: Boolean = false // set to true when airpods are connected to another device
+    var batteryBytes: ByteArray = byteArrayOf()
+    var ancBytes: ByteArray = byteArrayOf()
+    private lateinit var sharedPreferences: SharedPreferences
+    private const val PACKET_LOG_KEY = "packet_log"
+    private var earDetectionStatus = listOf(false, false)
+    var disconnectionRequested = false
+
+    @SuppressLint("MissingPermission")
+    fun init(context: Context) {
+        CoroutineScope(Dispatchers.IO).launch {
+            Log.d("CrossDevice", "Initializing CrossDevice")
+            sharedPreferences = context.getSharedPreferences("packet_logs", Context.MODE_PRIVATE)
+            sharedPreferences.edit().putBoolean("CrossDeviceIsAvailable", false).apply()
+            this@CrossDevice.bluetoothAdapter = context.getSystemService(BluetoothManager::class.java).adapter
+            this@CrossDevice.bluetoothLeAdvertiser = bluetoothAdapter.bluetoothLeAdvertiser
+            // startAdvertising()
+            startServer()
+            initialized = true
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun startServer() {
+        CoroutineScope(Dispatchers.IO).launch {
+            if (!bluetoothAdapter.isEnabled) return@launch
+//            serverSocket = bluetoothAdapter.listenUsingRfcommWithServiceRecord("ALNCrossDevice", uuid)
+            Log.d("CrossDevice", "Server started")
+            while (serverSocket != null) {
+                if (!bluetoothAdapter.isEnabled) {
+                    serverSocket?.close()
+                    break
+                }
+                if (clientSocket != null) {
+                    try {
+                        clientSocket!!.close()
+                    } catch (e: IOException) {
+                        e.printStackTrace()
+                    }
+                }
+                try {
+                    val socket = serverSocket!!.accept()
+                    handleClientConnection(socket)
+                } catch (e: IOException) { }
+            }
+        }
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun startAdvertising() {
+        CoroutineScope(Dispatchers.IO).launch {
+            val settings = AdvertiseSettings.Builder()
+                .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY)
+                .setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_HIGH)
+                .setConnectable(true)
+                .build()
+
+            val data = AdvertiseData.Builder()
+                .setIncludeDeviceName(true)
+                .addManufacturerData(MANUFACTURER_ID, MANUFACTURER_DATA.toByteArray())
+                .addServiceUuid(ParcelUuid(uuid))
+                .build()
+            try {
+                bluetoothLeAdvertiser.startAdvertising(settings, data, advertiseCallback)
+            } catch (e: Exception) {
+                Log.e("CrossDevice", "Failed to start BLE Advertising: ${e.message}")
+            }
+            Log.d("CrossDevice", "BLE Advertising started")
+        }
+    }
+
+    private val advertiseCallback = object : AdvertiseCallback() {
+        override fun onStartSuccess(settingsInEffect: AdvertiseSettings) {
+            Log.d("CrossDevice", "BLE Advertising started successfully")
+        }
+
+        override fun onStartFailure(errorCode: Int) {
+            Log.e("CrossDevice", "BLE Advertising failed with error code: $errorCode")
+        }
+    }
+
+    fun setAirPodsConnected(connected: Boolean) {
+        if (connected) {
+            isAvailable = false
+            sharedPreferences.edit().putBoolean("CrossDeviceIsAvailable", false).apply()
+            clientSocket?.outputStream?.write(CrossDevicePackets.AIRPODS_CONNECTED.packet)
+        } else {
+            clientSocket?.outputStream?.write(CrossDevicePackets.AIRPODS_DISCONNECTED.packet)
+            // Reset state variables
+            isAvailable = true
+        }
+    }
+
+    fun sendReceivedPacket(packet: ByteArray) {
+        if (clientSocket == null || clientSocket!!.outputStream != null) {
+            return
+        }
+        clientSocket?.outputStream?.write(CrossDevicePackets.AIRPODS_DATA_HEADER.packet + packet)
+    }
+
+    private fun logPacket(packet: ByteArray, source: String) {
+        val packetHex = packet.joinToString(" ") { "%02X".format(it) }
+        val logEntry = "$source: $packetHex"
+        val logs = sharedPreferences.getStringSet(PACKET_LOG_KEY, mutableSetOf())?.toMutableSet() ?: mutableSetOf()
+        logs.add(logEntry)
+        sharedPreferences.edit().putStringSet(PACKET_LOG_KEY, logs).apply()
+    }
+
+    @SuppressLint("MissingPermission")
+    private fun handleClientConnection(socket: BluetoothSocket) {
+        Log.d("CrossDevice", "Client connected")
+        notifyAirPodsConnectedRemotely(ServiceManager.getService()?.applicationContext!!)
+        clientSocket = socket
+        val inputStream = socket.inputStream
+        val buffer = ByteArray(1024)
+        var bytes: Int
+        setAirPodsConnected(ServiceManager.getService()?.isConnectedLocally == true)
+        while (true) {
+            try {
+                bytes = inputStream.read(buffer)
+            } catch (e: IOException) {
+                e.printStackTrace()
+                notifyAirPodsDisconnectedRemotely(ServiceManager.getService()?.applicationContext!!)
+                val s = serverSocket?.accept()
+                if (s != null) {
+                    handleClientConnection(s)
+                }
+                break
+            }
+            var packet = buffer.copyOf(bytes)
+            logPacket(packet, "Relay")
+            Log.d("CrossDevice", "Received packet: ${packet.joinToString("") { "%02x".format(it) }}")
+            if (bytes == -1) {
+                notifyAirPodsDisconnectedRemotely(ServiceManager.getService()?.applicationContext!!)
+                break
+            } else if (packet.contentEquals(CrossDevicePackets.REQUEST_DISCONNECT.packet) || packet.contentEquals(CrossDevicePackets.REQUEST_DISCONNECT.packet + CrossDevicePackets.AIRPODS_DATA_HEADER.packet)) {
+                ServiceManager.getService()?.disconnect()
+                disconnectionRequested = true
+                CoroutineScope(Dispatchers.IO).launch {
+                    delay(1000)
+                    disconnectionRequested = false
+                }
+            } else if (packet.contentEquals(CrossDevicePackets.AIRPODS_CONNECTED.packet)) {
+                isAvailable = true
+                sharedPreferences.edit().putBoolean("CrossDeviceIsAvailable", true).apply()
+            } else if (packet.contentEquals(CrossDevicePackets.AIRPODS_DISCONNECTED.packet)) {
+                isAvailable = false
+                sharedPreferences.edit().putBoolean("CrossDeviceIsAvailable", false).apply()
+            } else if (packet.contentEquals(CrossDevicePackets.REQUEST_BATTERY_BYTES.packet)) {
+                Log.d("CrossDevice", "Received battery request, battery data: ${batteryBytes.joinToString("") { "%02x".format(it) }}")
+                sendRemotePacket(batteryBytes)
+            } else if (packet.contentEquals(CrossDevicePackets.REQUEST_ANC_BYTES.packet)) {
+                Log.d("CrossDevice", "Received ANC request")
+                sendRemotePacket(ancBytes)
+            } else if (packet.contentEquals(CrossDevicePackets.REQUEST_CONNECTION_STATUS.packet)) {
+                Log.d("CrossDevice", "Received connection status request")
+                sendRemotePacket(if (ServiceManager.getService()?.isConnectedLocally == true) CrossDevicePackets.AIRPODS_CONNECTED.packet else CrossDevicePackets.AIRPODS_DISCONNECTED.packet)
+            } else {
+                if (packet.sliceArray(0..3).contentEquals(CrossDevicePackets.AIRPODS_DATA_HEADER.packet)) {
+                    isAvailable = true
+                    sharedPreferences.edit().putBoolean("CrossDeviceIsAvailable", true).apply()
+                    if (packet.size % 2 == 0) {
+                        val half = packet.size / 2
+                        if (packet.sliceArray(0 until half).contentEquals(packet.sliceArray(half until packet.size))) {
+                            Log.d("CrossDevice", "Duplicated packet, trimming")
+                            packet = packet.sliceArray(0 until half)
+                        }
+                    }
+                    var trimmedPacket = packet.drop(CrossDevicePackets.AIRPODS_DATA_HEADER.packet.size).toByteArray()
+                    Log.d("CrossDevice", "Received relayed packet: ${trimmedPacket.joinToString("") { "%02x".format(it) }}")
+                    if (ServiceManager.getService()?.isConnectedLocally == true) {
+                        val packetInHex = trimmedPacket.joinToString("") { "%02x".format(it) }
+//                        ServiceManager.getService()?.sendPacket(packetInHex)
+                    } else if (ServiceManager.getService()?.batteryNotification?.isBatteryData(trimmedPacket) == true) {
+                        batteryBytes = trimmedPacket
+                        ServiceManager.getService()?.batteryNotification?.setBattery(trimmedPacket)
+                        Log.d("CrossDevice", "Battery data: ${ServiceManager.getService()?.batteryNotification?.getBattery()[0]?.level}")
+                        ServiceManager.getService()?.updateBattery()
+                        ServiceManager.getService()?.sendBatteryBroadcast()
+                        ServiceManager.getService()?.sendBatteryNotification()
+                    } else if (ServiceManager.getService()?.ancNotification?.isANCData(trimmedPacket) == true) {
+                        ServiceManager.getService()?.ancNotification?.setStatus(trimmedPacket)
+                        ServiceManager.getService()?.sendANCBroadcast()
+                        ServiceManager.getService()?.updateNoiseControlWidget()
+                        ancBytes = trimmedPacket
+                    } else if (ServiceManager.getService()?.earDetectionNotification?.isEarDetectionData(trimmedPacket) == true) {
+                        Log.d("CrossDevice", "Ear detection data: ${trimmedPacket.joinToString("") { "%02x".format(it) }}")
+                        ServiceManager.getService()?.earDetectionNotification?.setStatus(trimmedPacket)
+                        val newEarDetectionStatus = listOf(
+                            ServiceManager.getService()?.earDetectionNotification?.status?.get(0) == 0x00.toByte(),
+                            ServiceManager.getService()?.earDetectionNotification?.status?.get(1) == 0x00.toByte()
+                        )
+                        if (earDetectionStatus == listOf(false, false) && newEarDetectionStatus.contains(true)) {
+                            ServiceManager.getService()?.applicationContext?.sendBroadcast(
+                                Intent("me.kavishdevar.librepods.cross_device_island")
+                            )
+                        }
+                        earDetectionStatus = newEarDetectionStatus
+                    }
+                }
+            }
+        }
+    }
+
+    fun sendRemotePacket(byteArray: ByteArray) {
+        if (clientSocket == null || clientSocket!!.outputStream == null) {
+            return
+        }
+        clientSocket?.outputStream?.write(byteArray)
+        clientSocket?.outputStream?.flush()
+        logPacket(byteArray, "Sent")
+        Log.d("CrossDevice", "Sent packet to remote device")
+    }
+
+    fun notifyAirPodsConnectedRemotely(context: Context) {
+        val intent = Intent("me.kavishdevar.librepods.AIRPODS_CONNECTED_REMOTELY")
+        context.sendBroadcast(intent)
+    }
+    fun notifyAirPodsDisconnectedRemotely(context: Context) {
+        val intent = Intent("me.kavishdevar.librepods.AIRPODS_DISCONNECTED_REMOTELY")
+        context.sendBroadcast(intent)
+    }
+}

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

@@ -0,0 +1,399 @@
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.utils
+
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import me.kavishdevar.librepods.services.AirPodsService
+import me.kavishdevar.librepods.services.ServiceManager
+import java.util.Collections
+import java.util.concurrent.CopyOnWriteArrayList
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.abs
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.pow
+
+@RequiresApi(Build.VERSION_CODES.Q)
+class GestureDetector(
+    private val airPodsService: AirPodsService
+) {
+    companion object {
+        private const val TAG = "GestureDetector"
+
+        private const val IMMEDIATE_FEEDBACK_THRESHOLD = 600
+        private const val DIRECTION_CHANGE_SENSITIVITY = 150
+
+        private const val FAST_MOVEMENT_THRESHOLD = 300.0
+        private const val MIN_REQUIRED_EXTREMES = 3
+        private const val MAX_REQUIRED_EXTREMES = 4
+
+        private const val MAX_VALID_ORIENTATION_VALUE = 6000
+    }
+
+    val audio = GestureFeedback(ServiceManager.getService()?.baseContext!!)
+
+    private val horizontalBuffer = Collections.synchronizedList(ArrayList<Double>())
+    private val verticalBuffer = Collections.synchronizedList(ArrayList<Double>())
+
+    private val horizontalAvgBuffer = Collections.synchronizedList(ArrayList<Double>())
+    private val verticalAvgBuffer = Collections.synchronizedList(ArrayList<Double>())
+
+    private var prevHorizontal: Double = 0.0
+    private var prevVertical: Double = 0.0
+
+    private val horizontalPeaks = CopyOnWriteArrayList<Triple<Int, Double, Long>>()
+    private val horizontalTroughs = CopyOnWriteArrayList<Triple<Int, Double, Long>>()
+    private val verticalPeaks = CopyOnWriteArrayList<Triple<Int, Double, Long>>()
+    private val verticalTroughs = CopyOnWriteArrayList<Triple<Int, Double, Long>>()
+
+    private var lastPeakTime: Long = 0
+    private val peakIntervals = Collections.synchronizedList(ArrayList<Double>())
+
+    private val movementSpeedIntervals = Collections.synchronizedList(ArrayList<Long>())
+
+    private val peakThreshold = 400
+    private val directionChangeThreshold = DIRECTION_CHANGE_SENSITIVITY
+    private val rhythmConsistencyThreshold = 0.5
+
+    private var horizontalIncreasing: Boolean? = null
+    private var verticalIncreasing: Boolean? = null
+
+    private val minConfidenceThreshold = 0.7
+
+    private var isRunning = false
+    private var detectionJob: Job? = null
+    private var gestureDetectedCallback: ((Boolean) -> Unit)? = null
+
+    private var significantMotion = false
+    private var lastSignificantMotionTime = 0L
+
+    init {
+        while (horizontalAvgBuffer.size < 3) horizontalAvgBuffer.add(0.0)
+        while (verticalAvgBuffer.size < 3) verticalAvgBuffer.add(0.0)
+    }
+
+fun startDetection(doNotStop: Boolean = false, onGestureDetected: (Boolean) -> Unit) {
+        if (isRunning) return
+
+        Log.d(TAG, "Starting gesture detection...")
+        isRunning = true
+        gestureDetectedCallback = onGestureDetected
+
+        Log.d(TAG, "started: ${airPodsService.startHeadTracking()}")
+
+        clearData()
+
+        prevHorizontal = 0.0
+        prevVertical = 0.0
+
+        detectionJob = CoroutineScope(Dispatchers.Default).launch {
+            while (isRunning) {
+                delay(50)
+
+                val gesture = detectGestures()
+                if (gesture != null) {
+                    withContext(Dispatchers.Main) {
+                        audio.playConfirmation(gesture)
+
+                        gestureDetectedCallback?.invoke(gesture)
+                        stopDetection(doNotStop)
+                    }
+                    break
+                }
+            }
+        }
+    }
+    fun stopDetection(doNotStop: Boolean = false) {
+        if (!isRunning) return
+
+        Log.d(TAG, "Stopping gesture detection")
+        isRunning = false
+
+        if (!doNotStop) airPodsService.stopHeadTracking()
+
+        detectionJob?.cancel()
+        detectionJob = null
+        gestureDetectedCallback = null
+    }
+
+    @RequiresApi(Build.VERSION_CODES.R)
+    fun processHeadOrientation(horizontal: Int, vertical: Int) {
+        if (!isRunning) return
+
+        if (abs(horizontal) > MAX_VALID_ORIENTATION_VALUE || abs(vertical) > MAX_VALID_ORIENTATION_VALUE) {
+            Log.d(TAG, "Ignoring likely calibration data: h=$horizontal, v=$vertical")
+            return
+        }
+
+        val horizontalDelta = horizontal - prevHorizontal
+        val verticalDelta = vertical - prevVertical
+
+        val significantHorizontal = abs(horizontalDelta) > IMMEDIATE_FEEDBACK_THRESHOLD
+        val significantVertical = abs(verticalDelta) > IMMEDIATE_FEEDBACK_THRESHOLD
+
+        if (significantHorizontal && (!significantVertical || abs(horizontalDelta) > abs(verticalDelta))) {
+            CoroutineScope(Dispatchers.Main).launch {
+                audio.playDirectional(isVertical = false, value = horizontalDelta)
+            }
+            significantMotion = true
+            lastSignificantMotionTime = System.currentTimeMillis()
+            Log.d(TAG, "Significant HORIZONTAL movement: $horizontalDelta")
+        }
+        else if (significantVertical) {
+            CoroutineScope(Dispatchers.Main).launch {
+                audio.playDirectional(isVertical = true, value = verticalDelta)
+            }
+            significantMotion = true
+            lastSignificantMotionTime = System.currentTimeMillis()
+            Log.d(TAG, "Significant VERTICAL movement: $verticalDelta")
+        }
+        else if (significantMotion &&
+                 (System.currentTimeMillis() - lastSignificantMotionTime) > 300) {
+            significantMotion = false
+        }
+
+        prevHorizontal = horizontal.toDouble()
+        prevVertical = vertical.toDouble()
+
+        val smoothHorizontal = applySmoothing(horizontal.toDouble(), horizontalAvgBuffer)
+        val smoothVertical = applySmoothing(vertical.toDouble(), verticalAvgBuffer)
+
+        synchronized(horizontalBuffer) {
+            horizontalBuffer.add(smoothHorizontal)
+            if (horizontalBuffer.size > 100) horizontalBuffer.removeAt(0)
+        }
+
+        synchronized(verticalBuffer) {
+            verticalBuffer.add(smoothVertical)
+            if (verticalBuffer.size > 100) verticalBuffer.removeAt(0)
+        }
+
+        detectPeaksAndTroughs()
+    }
+
+    private fun applySmoothing(newValue: Double, buffer: MutableList<Double>): Double {
+        synchronized(buffer) {
+            buffer.add(newValue)
+            if (buffer.size > 3) buffer.removeAt(0)
+            return buffer.average()
+        }
+    }
+
+
+    private fun detectPeaksAndTroughs() {
+        if (horizontalBuffer.size < 4 || verticalBuffer.size < 4) return
+
+        val hValues = horizontalBuffer.takeLast(4)
+        val vValues = verticalBuffer.takeLast(4)
+        val hVariance = calculateVariance(hValues)
+        val vVariance = calculateVariance(vValues)
+
+        processDirectionChanges(
+            horizontalBuffer,
+            horizontalIncreasing,
+            hVariance,
+            horizontalPeaks,
+            horizontalTroughs
+        )?.let { horizontalIncreasing = it }
+
+        processDirectionChanges(
+            verticalBuffer,
+            verticalIncreasing,
+            vVariance,
+            verticalPeaks,
+            verticalTroughs
+        )?.let { verticalIncreasing = it }
+    }
+
+    private fun processDirectionChanges(
+        buffer: List<Double>,
+        isIncreasing: Boolean?,
+        variance: Double,
+        peaks: MutableList<Triple<Int, Double, Long>>,
+        troughs: MutableList<Triple<Int, Double, Long>>
+    ): Boolean? {
+        if (buffer.size < 2) return isIncreasing
+
+        val current = buffer.last()
+        val prev = buffer[buffer.size - 2]
+        var increasing = isIncreasing ?: (current > prev)
+
+        val dynamicThreshold = max(50.0, min(directionChangeThreshold.toDouble(), variance / 3))
+
+        val now = System.currentTimeMillis()
+
+        if (increasing && current < prev - dynamicThreshold) {
+            if (abs(prev) > peakThreshold) {
+                peaks.add(Triple(buffer.size - 1, prev, now))
+                if (lastPeakTime > 0) {
+                    val interval = (now - lastPeakTime) / 1000.0
+                    val timeDiff = now - lastPeakTime
+
+                    synchronized(peakIntervals) {
+                        peakIntervals.add(interval)
+                        if (peakIntervals.size > 5) peakIntervals.removeAt(0)
+                    }
+
+                    synchronized(movementSpeedIntervals) {
+                        movementSpeedIntervals.add(timeDiff)
+                        if (movementSpeedIntervals.size > 5) movementSpeedIntervals.removeAt(0)
+                    }
+                }
+                lastPeakTime = now
+            }
+            increasing = false
+        } else if (!increasing && current > prev + dynamicThreshold) {
+            if (abs(prev) > peakThreshold) {
+                troughs.add(Triple(buffer.size - 1, prev, now))
+
+                if (lastPeakTime > 0) {
+                    val interval = (now - lastPeakTime) / 1000.0
+                    val timeDiff = now - lastPeakTime
+
+                    synchronized(peakIntervals) {
+                        peakIntervals.add(interval)
+                        if (peakIntervals.size > 5) peakIntervals.removeAt(0)
+                    }
+
+                    synchronized(movementSpeedIntervals) {
+                        movementSpeedIntervals.add(timeDiff)
+                        if (movementSpeedIntervals.size > 5) movementSpeedIntervals.removeAt(0)
+                    }
+                }
+                lastPeakTime = now
+            }
+            increasing = true
+        }
+
+        return increasing
+    }
+
+    private fun calculateVariance(values: List<Double>): Double {
+        if (values.size <= 1) return 0.0
+
+        val mean = values.average()
+        val squaredDiffs = values.map { (it - mean) * (it - mean) }
+        return squaredDiffs.average()
+    }
+
+
+    private fun calculateRhythmConsistency(): Double {
+        if (peakIntervals.size < 2) return 0.0
+
+        val meanInterval = peakIntervals.average()
+        if (meanInterval == 0.0) return 0.0
+
+        val variances = peakIntervals.map { (it / meanInterval - 1.0).pow(2) }
+        val consistency = 1.0 - min(1.0, variances.average() / rhythmConsistencyThreshold)
+        return max(0.0, consistency)
+    }
+
+
+    private fun calculateConfidenceScore(extremes: List<Triple<Int, Double, Long>>, isVertical: Boolean): Double {
+        if (extremes.size < getRequiredExtremes()) return 0.0
+
+        val sortedExtremes = extremes.sortedBy { it.first }
+
+        val recent = sortedExtremes.takeLast(getRequiredExtremes())
+
+        val avgAmplitude = recent.map { abs(it.second) }.average()
+        val amplitudeFactor = min(1.0, avgAmplitude / 600)
+
+        val rhythmFactor = calculateRhythmConsistency()
+
+        val signs = recent.map { if (it.second > 0) 1 else -1 }
+        val alternating = (1 until signs.size).all { signs[it] != signs[it - 1] }
+        val alternationFactor = if (alternating) 1.0 else 0.5
+
+        val isolationFactor = if (isVertical) {
+            val vertAmplitude = recent.map { abs(it.second) }.average()
+            val horizVals = horizontalBuffer.takeLast(recent.size * 2)
+            val horizAmplitude = horizVals.map { abs(it) }.average()
+            min(1.0, vertAmplitude / (horizAmplitude + 0.1) * 1.2)
+        } else {
+            val horizAmplitude = recent.map { abs(it.second) }.average()
+            val vertVals = verticalBuffer.takeLast(recent.size * 2)
+            val vertAmplitude = vertVals.map { abs(it) }.average()
+            min(1.0, horizAmplitude / (vertAmplitude + 0.1) * 1.2)
+        }
+
+        return (
+            amplitudeFactor * 0.4 +
+            rhythmFactor * 0.2 +
+            alternationFactor * 0.2 +
+            isolationFactor * 0.2
+        )
+    }
+
+    private fun getRequiredExtremes(): Int {
+        if (movementSpeedIntervals.isEmpty()) return MIN_REQUIRED_EXTREMES
+
+        val avgInterval = movementSpeedIntervals.average()
+        Log.d(TAG, "Average movement interval: $avgInterval ms")
+
+        return if (avgInterval < FAST_MOVEMENT_THRESHOLD) {
+            MAX_REQUIRED_EXTREMES
+        } else {
+            MIN_REQUIRED_EXTREMES
+        }
+    }
+
+    private fun detectGestures(): Boolean? {
+        val requiredExtremes = getRequiredExtremes()
+        Log.d(TAG, "Current required extremes: $requiredExtremes")
+
+        if (verticalPeaks.size + verticalTroughs.size >= requiredExtremes) {
+            val allExtremes = (verticalPeaks + verticalTroughs).sortedBy { it.first }
+
+            val confidence = calculateConfidenceScore(allExtremes, isVertical = true)
+
+            Log.d(TAG, "Vertical motion confidence: $confidence (need $minConfidenceThreshold)")
+
+            if (confidence >= minConfidenceThreshold) {
+                Log.d(TAG, "\"Yes\" Gesture Detected (confidence: $confidence, extremes: ${allExtremes.size}/$requiredExtremes)")
+                return true
+            }
+        }
+
+        if (horizontalPeaks.size + horizontalTroughs.size >= requiredExtremes) {
+            val allExtremes = (horizontalPeaks + horizontalTroughs).sortedBy { it.first }
+
+            val confidence = calculateConfidenceScore(allExtremes, isVertical = false)
+
+            Log.d(TAG, "Horizontal motion confidence: $confidence (need $minConfidenceThreshold)")
+
+            if (confidence >= minConfidenceThreshold) {
+                Log.d(TAG, "\"No\" Gesture Detected (confidence: $confidence, extremes: ${allExtremes.size}/$requiredExtremes)")
+                return false
+            }
+        }
+
+        return null
+    }
+
+    private fun clearData() {
+        horizontalBuffer.clear()
+        verticalBuffer.clear()
+        horizontalPeaks.clear()
+        horizontalTroughs.clear()
+        verticalPeaks.clear()
+        verticalTroughs.clear()
+        peakIntervals.clear()
+        movementSpeedIntervals.clear()
+        horizontalIncreasing = null
+        verticalIncreasing = null
+        lastPeakTime = 0
+        significantMotion = false
+        lastSignificantMotionTime = 0L
+    }
+
+    private fun Double.pow(exponent: Int): Double = this.pow(exponent.toDouble())
+}

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

@@ -0,0 +1,163 @@
+@file:Suppress("PrivatePropertyName")
+
+package me.kavishdevar.librepods.utils
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.SoundPool
+import android.os.Build
+import android.os.SystemClock
+import android.util.Log
+import androidx.annotation.RequiresApi
+import me.kavishdevar.librepods.R
+import java.util.concurrent.atomic.AtomicBoolean
+
+@RequiresApi(Build.VERSION_CODES.Q)
+class GestureFeedback(private val context: Context) {
+
+    private val TAG = "GestureFeedback"
+
+    private val soundsLoaded = AtomicBoolean(false)
+
+    private val soundPool = SoundPool.Builder()
+        .setMaxStreams(3)
+        .setAudioAttributes(
+            AudioAttributes.Builder()
+                .setUsage(AudioAttributes.USAGE_ASSISTANCE_ACCESSIBILITY)
+                .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+                .setFlags(AudioAttributes.FLAG_LOW_LATENCY or
+                         AudioAttributes.FLAG_AUDIBILITY_ENFORCED)
+                .build()
+        )
+        .build()
+
+
+    private var soundId = 0
+    private var confirmYesId = 0
+    private var confirmNoId = 0
+
+    private var lastHorizontalTime = 0L
+    private var lastLeftTime = 0L
+    private var lastRightTime = 0L
+
+    private var lastVerticalTime = 0L
+    private var lastUpTime = 0L
+    private var lastDownTime = 0L
+
+    private val MIN_TIME_BETWEEN_SOUNDS = 150L
+    private val MIN_TIME_BETWEEN_DIRECTION = 200L
+
+    private var currentHorizontalStreamId = 0
+    private var currentVerticalStreamId = 0
+
+
+    private val LEFT_VOLUME = Pair(1.0f, 0.0f)
+    private val RIGHT_VOLUME = Pair(0.0f, 1.0f)
+    private val VERTICAL_VOLUME = Pair(1.0f, 1.0f)
+
+    init {
+        soundId = soundPool.load(context, R.raw.blip_no, 1)
+        confirmYesId = soundPool.load(context, R.raw.confirm_yes, 1)
+        confirmNoId = soundPool.load(context, R.raw.confirm_no, 1)
+
+        soundPool.setOnLoadCompleteListener { _, _, _ ->
+            Log.d(TAG, "Sounds loaded")
+            soundsLoaded.set(true)
+
+            soundPool.play(soundId, 0.0f, 0.0f, 1, 0, 1.0f)
+        }
+    }
+
+    @RequiresApi(Build.VERSION_CODES.R)
+    fun playDirectional(isVertical: Boolean, value: Double) {
+        if (!soundsLoaded.get()) {
+            Log.d(TAG, "Sounds not yet loaded, skipping playback")
+            return
+        }
+
+        val now = SystemClock.uptimeMillis()
+
+        if (isVertical) {
+            val isUp = value > 0
+
+            if (now - lastVerticalTime < MIN_TIME_BETWEEN_SOUNDS) {
+                Log.d(TAG, "Skipping vertical sound due to general vertical debounce")
+                return
+            }
+
+            if (isUp && now - lastUpTime < MIN_TIME_BETWEEN_DIRECTION) {
+                Log.d(TAG, "Skipping UP sound due to direction debounce")
+                return
+            }
+
+            if (!isUp && now - lastDownTime < MIN_TIME_BETWEEN_DIRECTION) {
+                Log.d(TAG, "Skipping DOWN sound due to direction debounce")
+                return
+            }
+
+            if (currentVerticalStreamId > 0) {
+                soundPool.stop(currentVerticalStreamId)
+            }
+
+            val (leftVol, rightVol) = VERTICAL_VOLUME
+
+            currentVerticalStreamId = soundPool.play(soundId, leftVol, rightVol, 1, 0, 1.0f)
+            Log.d(TAG, "Playing VERTICAL sound: ${if (isUp) "UP" else "DOWN"} - streamID=$currentVerticalStreamId")
+
+            lastVerticalTime = now
+            if (isUp) {
+                lastUpTime = now
+            } else {
+                lastDownTime = now
+            }
+        } else {
+            if (now - lastHorizontalTime < MIN_TIME_BETWEEN_SOUNDS) {
+                Log.d(TAG, "Skipping horizontal sound due to general horizontal debounce")
+                return
+            }
+
+            val isRight = value > 0
+
+            if (isRight && now - lastRightTime < MIN_TIME_BETWEEN_DIRECTION) {
+                Log.d(TAG, "Skipping RIGHT sound due to direction debounce")
+                return
+            }
+
+            if (!isRight && now - lastLeftTime < MIN_TIME_BETWEEN_DIRECTION) {
+                Log.d(TAG, "Skipping LEFT sound due to direction debounce")
+                return
+            }
+
+            if (currentHorizontalStreamId > 0) {
+                soundPool.stop(currentHorizontalStreamId)
+            }
+
+            val (leftVol, rightVol) = if (isRight) RIGHT_VOLUME else LEFT_VOLUME
+
+            currentHorizontalStreamId = soundPool.play(soundId, leftVol, rightVol, 1, 0, 1.0f)
+            Log.d(TAG, "Playing HORIZONTAL sound: ${if (isRight) "RIGHT" else "LEFT"} - streamID=$currentHorizontalStreamId")
+
+            lastHorizontalTime = now
+            if (isRight) {
+                lastRightTime = now
+            } else {
+                lastLeftTime = now
+            }
+        }
+    }
+
+    fun playConfirmation(isYes: Boolean) {
+        if (currentHorizontalStreamId > 0) {
+            soundPool.stop(currentHorizontalStreamId)
+        }
+        if (currentVerticalStreamId > 0) {
+            soundPool.stop(currentVerticalStreamId)
+        }
+
+        val soundId = if (isYes) confirmYesId else confirmNoId
+        if (soundId != 0 && soundsLoaded.get()) {
+            val streamId = soundPool.play(soundId, 1.0f, 1.0f, 1, 0, 1.0f)
+            Log.d(TAG, "Playing ${if (isYes) "YES" else "NO"} confirmation - streamID=$streamId")
+        }
+    }
+}

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

@@ -0,0 +1,83 @@
+package me.kavishdevar.librepods.utils
+
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlin.math.roundToInt
+
+data class Orientation(val pitch: Float = 0f, val yaw: Float = 0f)
+data class Acceleration(val vertical: Float = 0f, val horizontal: Float = 0f)
+
+object HeadTracking {
+    private val _orientation = MutableStateFlow(Orientation())
+    val orientation = _orientation.asStateFlow()
+
+    private val _acceleration = MutableStateFlow(Acceleration())
+    val acceleration = _acceleration.asStateFlow()
+
+    private val calibrationSamples = mutableListOf<Triple<Int, Int, Int>>()
+    private var isCalibrated = false
+    private var o1Neutral = 19000
+    private var o2Neutral = 0
+    private var o3Neutral = 0
+
+    private const val CALIBRATION_SAMPLE_COUNT = 10
+    private const val ORIENTATION_OFFSET = 5500
+
+    fun processPacket(packet: ByteArray) {
+        val o1 = bytesToInt(packet[43], packet[44])
+        val o2 = bytesToInt(packet[45], packet[46])
+        val o3 = bytesToInt(packet[47], packet[48])
+
+        val horizontalAccel = bytesToInt(packet[51], packet[52]).toFloat()
+        val verticalAccel = bytesToInt(packet[53], packet[54]).toFloat()
+
+        if (!isCalibrated) {
+            calibrationSamples.add(Triple(o1, o2, o3))
+            if (calibrationSamples.size >= CALIBRATION_SAMPLE_COUNT) {
+                calibrate()
+            }
+            return
+        }
+
+        val orientation = calculateOrientation(o1, o2, o3)
+        _orientation.value = orientation
+
+        _acceleration.value = Acceleration(verticalAccel, horizontalAccel)
+    }
+
+    private fun calibrate() {
+        if (calibrationSamples.size < 3) return
+
+        // Add offset during calibration
+        o1Neutral = calibrationSamples.map { it.first + ORIENTATION_OFFSET }.average().roundToInt()
+        o2Neutral = calibrationSamples.map { it.second + ORIENTATION_OFFSET }.average().roundToInt()
+        o3Neutral = calibrationSamples.map { it.third + ORIENTATION_OFFSET }.average().roundToInt()
+
+        isCalibrated = true
+    }
+
+    @Suppress("UnusedVariable")
+    private fun calculateOrientation(o1: Int, o2: Int, o3: Int): Orientation {
+        if (!isCalibrated) return Orientation()
+
+        val o1Norm = (o1 + ORIENTATION_OFFSET) - o1Neutral
+        val o2Norm = (o2 + ORIENTATION_OFFSET) - o2Neutral
+        val o3Norm = (o3 + ORIENTATION_OFFSET) - o3Neutral
+
+        val pitch = (o2Norm + o3Norm) / 2f / 32000f * 180f
+        val yaw = (o2Norm - o3Norm) / 2f / 32000f * 180f
+
+        return Orientation(pitch, yaw)
+    }
+
+    private fun bytesToInt(b1: Byte, b2: Byte): Int {
+        return (b2.toInt() shl 8) or (b1.toInt() and 0xFF)
+    }
+
+    fun reset() {
+        calibrationSamples.clear()
+        isCalibrated = false
+        _orientation.value = Orientation()
+        _acceleration.value = Acceleration()
+    }
+}

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

@@ -0,0 +1,684 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.utils
+
+import android.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.net.Uri
+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.LinearLayout
+import android.widget.ProgressBar
+import android.widget.TextView
+import android.widget.VideoView
+import androidx.core.content.ContextCompat.getString
+import androidx.dynamicanimation.animation.DynamicAnimation
+import androidx.dynamicanimation.animation.SpringAnimation
+import androidx.dynamicanimation.animation.SpringForce
+import me.kavishdevar.librepods.R
+import me.kavishdevar.librepods.services.ServiceManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+import kotlin.math.abs
+
+enum class IslandType {
+    CONNECTED,
+    TAKING_OVER,
+    MOVED_TO_REMOTE,
+}
+
+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 = intent.getParcelableArrayListExtra<Battery>("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
+
+    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
+        val leftStatus = leftBattery?.status ?: BatteryStatus.DISCONNECTED
+        val rightStatus = 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")
+    fun show(name: String, batteryPercentage: Int, context: Context, type: IslandType = IslandType.CONNECTED) {
+        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 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, deltaY)
+                        }
+                    }
+
+                    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
+                        val significantVelocity = 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 = getString(context, R.string.island_connected_text)
+            }
+            IslandType.TAKING_OVER -> {
+                islandView.findViewById<TextView>(R.id.island_connected_text).text = getString(context, R.string.island_taking_over_text)
+            }
+            IslandType.MOVED_TO_REMOTE -> {
+                islandView.findViewById<TextView>(R.id.island_connected_text).text = getString(context, R.string.island_moved_to_remote_text)
+            }
+        }
+
+        val videoView = islandView.findViewById<VideoView>(R.id.island_video_view)
+        val videoUri = Uri.parse("android.resource://me.kavishdevar.librepods/${R.raw.island}")
+        videoView.setVideoURI(videoUri)
+        videoView.setOnPreparedListener { mediaPlayer ->
+            mediaPlayer.isLooping = true
+            videoView.start()
+        }
+
+        windowManager.addView(containerView, params)
+
+        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, dragY: 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 batteryView = islandView.findViewById<FrameLayout>(R.id.island_battery_container)
+            val videoView = 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(velocity)
+
+        if (params != null) {
+            params!!.height = WindowManager.LayoutParams.WRAP_CONTENT
+            try {
+                windowManager.updateViewLayout(containerView, params)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+        }
+
+        springAnimation.start()
+    }
+
+    private fun resetStretchEffects(velocity: Float) {
+        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, expandDuration)
+        }
+
+        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, duration: Long) {
+        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() {
+        try {
+            if (isClosing) return
+            isClosing = true
+
+            try {
+                context.unregisterReceiver(batteryReceiver)
+            } catch (e: Exception) {
+                e.printStackTrace()
+            }
+
+            ServiceManager.getService()?.islandOpen = false
+            autoCloseHandler?.removeCallbacks(autoCloseRunnable ?: return)
+
+            resetStretchEffects(0f)
+
+            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() {
+        containerView.visibility = View.GONE
+        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() {
+        try {
+            if (isClosing) return
+            isClosing = true
+            
+            try {
+                context.unregisterReceiver(batteryReceiver)
+            } catch (e: Exception) {
+                // Silent catch - receiver might already be unregistered
+            }
+            
+            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/utils/KotlinModule.kt

@@ -0,0 +1,822 @@
+package me.kavishdevar.librepods.utils
+
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.content.res.ColorStateList
+import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
+import android.os.ParcelUuid
+import android.util.Log
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import android.view.animation.AccelerateInterpolator
+import android.view.animation.DecelerateInterpolator
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.ImageView
+import android.widget.LinearLayout
+import io.github.libxposed.api.XposedInterface
+import io.github.libxposed.api.XposedInterface.AfterHookCallback
+import io.github.libxposed.api.XposedModule
+import io.github.libxposed.api.XposedModuleInterface
+import io.github.libxposed.api.XposedModuleInterface.ModuleLoadedParam
+import io.github.libxposed.api.annotations.AfterInvocation
+import io.github.libxposed.api.annotations.XposedHooker
+
+private const val TAG = "AirPodsHook"
+private lateinit var module: KotlinModule
+
+class KotlinModule(base: XposedInterface, param: ModuleLoadedParam): XposedModule(base, param) {
+    init {
+        Log.i(TAG, "AirPodsHook module initialized at :: ${param.processName}")
+        module = this
+    }
+
+    override fun onPackageLoaded(param: XposedModuleInterface.PackageLoadedParam) {
+        super.onPackageLoaded(param)
+        Log.i(TAG, "onPackageLoaded :: ${param.packageName}")
+
+        if (param.packageName == "com.google.android.bluetooth" || param.packageName == "com.android.bluetooth") {
+            Log.i(TAG, "Bluetooth app detected, hooking l2c_fcr_chk_chan_modes")
+
+            try {
+                if (param.isFirstPackage) {
+                    Log.i(TAG, "Loading native library for Bluetooth hook")
+                    System.loadLibrary("l2c_fcr_hook")
+                    Log.i(TAG, "Native library loaded successfully")
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to load native library: ${e.message}", e)
+            }
+        }
+
+        if (param.packageName == "com.google.android.settings") {
+            Log.i(TAG, "Settings app detected, hooking Bluetooth icon handling")
+            try {
+                val headerControllerClass = param.classLoader.loadClass(
+                    "com.google.android.settings.bluetooth.AdvancedBluetoothDetailsHeaderController")
+
+                val updateIconMethod = headerControllerClass.getDeclaredMethod(
+                    "updateIcon",
+                    android.widget.ImageView::class.java,
+                    String::class.java)
+
+                hook(updateIconMethod, BluetoothIconHooker::class.java)
+                Log.i(TAG, "Successfully hooked updateIcon method in Bluetooth settings")
+
+                try {
+                    val displayPreferenceMethod = headerControllerClass.getDeclaredMethod(
+                        "displayPreference",
+                        param.classLoader.loadClass("androidx.preference.PreferenceScreen"))
+
+                    hook(displayPreferenceMethod, BluetoothSettingsAirPodsHooker::class.java)
+                    Log.i(TAG, "Successfully hooked displayPreference for AirPods button injection")
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to hook displayPreference: ${e.message}", e)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to hook Bluetooth icon handler: ${e.message}", e)
+            }
+        }
+
+        if (param.packageName == "com.android.settings") {
+            Log.i(TAG, "Settings app detected, hooking Bluetooth icon handling")
+            try {
+                val headerControllerClass = param.classLoader.loadClass(
+                    "com.android.settings.bluetooth.AdvancedBluetoothDetailsHeaderController")
+
+                val updateIconMethod = headerControllerClass.getDeclaredMethod(
+                    "updateIcon",
+                    android.widget.ImageView::class.java,
+                    String::class.java)
+
+                hook(updateIconMethod, BluetoothIconHooker::class.java)
+                Log.i(TAG, "Successfully hooked updateIcon method in Bluetooth settings")
+
+                try {
+                    val displayPreferenceMethod = headerControllerClass.getDeclaredMethod(
+                        "displayPreference",
+                        param.classLoader.loadClass("androidx.preference.PreferenceScreen"))
+
+                    hook(displayPreferenceMethod, BluetoothSettingsAirPodsHooker::class.java)
+                    Log.i(TAG, "Successfully hooked displayPreference for AirPods button injection")
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to hook displayPreference: ${e.message}", e)
+                }
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to hook Bluetooth icon handler: ${e.message}", e)
+            }
+        }
+
+        if (param.packageName == "com.android.systemui") {
+            Log.i(TAG, "SystemUI detected, hooking volume panel")
+            try {
+                val volumePanelViewClass = param.classLoader.loadClass("com.android.systemui.volume.VolumeDialogImpl")
+
+                try {
+                    val initDialogMethod = volumePanelViewClass.getDeclaredMethod("initDialog", Int::class.java)
+                    hook(initDialogMethod, VolumeDialogInitHooker::class.java)
+                    Log.i(TAG, "Hooked initDialog method successfully")
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to hook initDialog method: ${e.message}")
+                }
+
+                try {
+                    val showHMethod = volumePanelViewClass.getDeclaredMethod("showH", Int::class.java, Boolean::class.java, Int::class.java)
+                    hook(showHMethod, VolumeDialogShowHooker::class.java)
+                    Log.i(TAG, "Hooked showH method successfully")
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to hook showH method: ${e.message}")
+                }
+
+                Log.i(TAG, "Volume panel hook setup attempted on multiple methods")
+            } catch (e: Exception) {
+                Log.e(TAG, "Failed to hook volume panel: ${e.message}", e)
+            }
+        }
+    }
+
+    @XposedHooker
+    class VolumeDialogInitHooker : XposedInterface.Hooker {
+        companion object {
+            @JvmStatic
+            @AfterInvocation
+            fun afterInitDialog(callback: AfterHookCallback) {
+                try {
+                    val volumeDialog = callback.thisObject
+                    Log.i(TAG, "Volume dialog initialized, adding AirPods controls")
+                    addAirPodsControlsToDialog(volumeDialog!!)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in initDialog hook: ${e.message}", e)
+                }
+            }
+        }
+    }
+
+    @XposedHooker
+    class VolumeDialogShowHooker : XposedInterface.Hooker {
+        companion object {
+            @JvmStatic
+            @AfterInvocation
+            fun afterShowH(callback: AfterHookCallback) {
+                try {
+                    val volumeDialog = callback.thisObject
+                    Log.i(TAG, "Volume dialog shown, ensuring AirPods controls are added")
+                    addAirPodsControlsToDialog(volumeDialog!!)
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in showH hook: ${e.message}", e)
+                }
+            }
+        }
+    }
+
+    @XposedHooker
+    class BluetoothSettingsAirPodsHooker : XposedInterface.Hooker {
+        companion object {
+            private const val AIRPODS_UUID = "74ec2172-0bad-4d01-8f77-997b2be0722a"
+            private const val LIBREPODS_PREFERENCE_KEY = "librepods_open_preference"
+            private const val ACTION_SET_ANC_MODE = "me.kavishdevar.librepods.SET_ANC_MODE"
+            private const val EXTRA_ANC_MODE = "anc_mode"
+
+            private const val ANC_MODE_OFF = 1
+            private const val ANC_MODE_NOISE_CANCELLATION = 2
+            private const val ANC_MODE_TRANSPARENCY = 3
+            private const val ANC_MODE_ADAPTIVE = 4
+
+            private var currentAncMode = ANC_MODE_NOISE_CANCELLATION
+
+            @JvmStatic
+            @AfterInvocation
+            fun afterDisplayPreference(callback: AfterHookCallback) {
+                try {
+                    val controller = callback.thisObject!!
+                    val preferenceScreen = callback.args[0]!!
+
+                    val context = preferenceScreen.javaClass.getMethod("getContext").invoke(preferenceScreen) as Context
+
+                    val deviceField = controller.javaClass.getDeclaredField("mCachedDevice")
+                    deviceField.isAccessible = true
+                    val cachedDevice = deviceField.get(controller) ?: return
+
+                    val getDeviceMethod = cachedDevice.javaClass.getMethod("getDevice")
+                    val bluetoothDevice = getDeviceMethod.invoke(cachedDevice) ?: return
+
+                    val uuidsMethod = bluetoothDevice.javaClass.getMethod("getUuids")
+                    val uuids = uuidsMethod.invoke(bluetoothDevice) as? Array<ParcelUuid>
+
+                    if (uuids != null) {
+                        val isAirPods = uuids.any { it.uuid.toString() == AIRPODS_UUID }
+
+                        if (isAirPods) {
+                            Log.i(TAG, "AirPods device detected in settings, injecting controls")
+
+                            val findPreferenceMethod = preferenceScreen.javaClass.getMethod("findPreference", CharSequence::class.java)
+                            val existingPref = findPreferenceMethod.invoke(preferenceScreen, LIBREPODS_PREFERENCE_KEY)
+
+                            if (existingPref != null) {
+                                Log.i(TAG, "LIBREPODS button already exists, skipping")
+                                return
+                            }
+
+                            val preferenceClass = preferenceScreen.javaClass.classLoader.loadClass("androidx.preference.Preference")
+                            val preference = preferenceClass.getConstructor(Context::class.java).newInstance(context)
+
+                            val setKeyMethod = preferenceClass.getMethod("setKey", String::class.java)
+                            setKeyMethod.invoke(preference, LIBREPODS_PREFERENCE_KEY)
+
+                            val setTitleMethod = preferenceClass.getMethod("setTitle", CharSequence::class.java)
+                            setTitleMethod.invoke(preference, "Open LibrePods")
+
+                            val setSummaryMethod = preferenceClass.getMethod("setSummary", CharSequence::class.java)
+                            setSummaryMethod.invoke(preference, "Control AirPods features")
+
+                            val setIconMethod = preferenceClass.getMethod("setIcon", Int::class.java)
+                            setIconMethod.invoke(preference, android.R.drawable.ic_menu_manage)
+
+                            val setOrderMethod = preferenceClass.getMethod("setOrder", Int::class.java)
+                            setOrderMethod.invoke(preference, 1000)
+
+                            val intent = Intent().apply {
+                                setClassName("me.kavishdevar.librepods", "me.kavishdevar.librepods.MainActivity")
+                                flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                            }
+                            val setIntentMethod = preferenceClass.getMethod("setIntent", Intent::class.java)
+                            setIntentMethod.invoke(preference, intent)
+
+                            val addPreferenceMethod = preferenceScreen.javaClass.getMethod("addPreference", preferenceClass)
+                            addPreferenceMethod.invoke(preferenceScreen, preference)
+
+                            Log.i(TAG, "Successfully added Open LIBREPODS button to AirPods settings")
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in BluetoothSettingsAirPodsHooker: ${e.message}", e)
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    @XposedHooker
+    class BluetoothIconHooker : XposedInterface.Hooker {
+        companion object {
+            @JvmStatic
+            @AfterInvocation
+            fun afterUpdateIcon(callback: AfterHookCallback) {
+                Log.i(TAG, "BluetoothIconHooker called with args: ${callback.args.joinToString(", ")}")
+                try {
+                    val imageView = callback.args[0] as ImageView
+                    val iconUri = callback.args[1] as String
+
+                    val uri = android.net.Uri.parse(iconUri)
+                    if (uri.toString().startsWith("android.resource://me.kavishdevar.librepods")) {
+                        Log.i(TAG, "Handling AirPods icon URI: $uri")
+
+                        try {
+                            val context = imageView.context
+
+                            android.os.Handler(android.os.Looper.getMainLooper()).post {
+                                try {
+                                    val packageName = uri.authority
+                                    val packageContext = context.createPackageContext(
+                                        packageName,
+                                        Context.CONTEXT_IGNORE_SECURITY
+                                    )
+
+                                    val resPath = uri.pathSegments
+                                    if (resPath.size >= 2 && resPath[0] == "drawable") {
+                                        val resourceName = resPath[1]
+                                        val resourceId = packageContext.resources.getIdentifier(
+                                            resourceName, "drawable", packageName
+                                        )
+
+                                        if (resourceId != 0) {
+                                            val drawable = packageContext.resources.getDrawable(
+                                                resourceId, packageContext.theme
+                                            )
+
+                                            imageView.setImageDrawable(drawable)
+                                            imageView.alpha = 1.0f
+
+                                            callback.result = null
+
+                                            Log.i(TAG, "Successfully loaded icon from resource: $resourceName")
+                                        } else {
+                                            Log.e(TAG, "Resource not found: $resourceName")
+                                        }
+                                    }
+                                } catch (e: Exception) {
+                                    Log.e(TAG, "Error loading resource from URI $uri: ${e.message}")
+                                }
+                            }
+                        } catch (e: Exception) {
+                            Log.e(TAG, "Error accessing context: ${e.message}")
+                        }
+                    }
+                } catch (e: Exception) {
+                    Log.e(TAG, "Error in BluetoothIconHooker: ${e.message}")
+                    e.printStackTrace()
+                }
+            }
+        }
+    }
+
+    override fun getApplicationInfo(): ApplicationInfo {
+        return super.applicationInfo
+    }
+
+    companion object {
+        private const val ANC_MODE_OFF = 1
+        private const val ANC_MODE_NOISE_CANCELLATION = 2
+        private const val ANC_MODE_TRANSPARENCY = 3
+        private const val ANC_MODE_ADAPTIVE = 4
+
+        private var currentANCMode = ANC_MODE_NOISE_CANCELLATION
+
+        private const val ACTION_SET_ANC_MODE = "me.kavishdevar.librepods.SET_ANC_MODE"
+        private const val EXTRA_ANC_MODE = "anc_mode"
+        private const val ANIMATION_DURATION = 250L
+
+        private fun addAirPodsControlsToDialog(volumeDialog: Any) {
+            try {
+                val contextField = volumeDialog.javaClass.getDeclaredField("mContext")
+                contextField.isAccessible = true
+                val context = contextField.get(volumeDialog) as Context
+
+                val dialogViewField = volumeDialog.javaClass.getDeclaredField("mDialogView")
+                dialogViewField.isAccessible = true
+                val dialogView = dialogViewField.get(volumeDialog) as ViewGroup
+
+                val dialogRowsViewField = volumeDialog.javaClass.getDeclaredField("mDialogRowsView")
+                dialogRowsViewField.isAccessible = true
+                val dialogRowsView = dialogRowsViewField.get(volumeDialog) as ViewGroup
+
+                Log.d(TAG, "Found dialogRowsView: ${dialogRowsView.javaClass.name}")
+
+                val existingContainer = dialogView.findViewWithTag<View>("airpods_container")
+                if (existingContainer != null) {
+                    Log.d(TAG, "AirPods container already exists, ensuring visibility state")
+                    val drawer = existingContainer.findViewWithTag<View>("airpods_drawer_container")
+                    drawer?.visibility = View.GONE
+                    drawer?.alpha = 0f
+                    drawer?.translationY = 0f
+                    val button = existingContainer.findViewWithTag<ImageButton>("airpods_button")
+                    button?.visibility = View.VISIBLE
+                    button?.alpha = 1f
+                    if (button != null) {
+                         updateMainButtonIcon(context, button, currentANCMode)
+                    }
+                    return
+                }
+
+                val newAirPodsButton = ImageButton(context).apply {
+                    tag = "airpods_button"
+
+                    try {
+                        val airPodsPackage = context.createPackageContext(
+                            "me.kavishdevar.librepods",
+                            Context.CONTEXT_IGNORE_SECURITY
+                        )
+                        val airPodsIconRes = airPodsPackage.resources.getIdentifier(
+                            "airpods", "drawable", "me.kavishdevar.librepods")
+
+                        if (airPodsIconRes != 0) {
+                            val airPodsDrawable = airPodsPackage.resources.getDrawable(
+                                airPodsIconRes, airPodsPackage.theme)
+                            setImageDrawable(airPodsDrawable)
+                        } else {
+                            setImageResource(android.R.drawable.ic_media_play)
+                            Log.d(TAG, "Using fallback icon because airpods icon resource not found")
+                        }
+                    } catch (e: Exception) {
+                        setImageResource(android.R.drawable.ic_media_play)
+                        Log.e(TAG, "Failed to load AirPods icon: ${e.message}")
+                    }
+
+                    val shape = GradientDrawable()
+                    shape.shape = GradientDrawable.RECTANGLE
+                    shape.setColor(Color.BLACK)
+                    background = shape
+
+                    imageTintList = ColorStateList.valueOf(Color.WHITE)
+                    scaleType = ImageView.ScaleType.CENTER_INSIDE
+
+                    setPadding(24, 24, 24, 24)
+
+                    val params = LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        90
+                    )
+                    params.gravity = Gravity.CENTER
+                    params.setMargins(0, 0, 0, 0)
+                    layoutParams = params
+
+                    setOnClickListener {
+                        Log.d(TAG, "AirPods button clicked, toggling drawer")
+                        val container = findAirPodsContainer(this)
+                        val drawerContainer = container?.findViewWithTag<View>("airpods_drawer_container")
+                        if (drawerContainer != null && container != null) {
+                            if (drawerContainer.visibility == View.VISIBLE) {
+                                hideAirPodsDrawer(container, this, drawerContainer)
+                            } else {
+                                showAirPodsDrawer(container, this, drawerContainer)
+                            }
+                        } else {
+                             Log.e(TAG, "Could not find container or drawer for toggle")
+                        }
+                    }
+
+                    contentDescription = "AirPods Settings"
+                }
+
+                val airPodsContainer = FrameLayout(context).apply {
+                    layoutParams = LinearLayout.LayoutParams(
+                        LinearLayout.LayoutParams.MATCH_PARENT,
+                        LinearLayout.LayoutParams.WRAP_CONTENT
+                    )
+                    tag = "airpods_container"
+                }
+
+                newAirPodsButton.setOnLongClickListener {
+                    Log.d(TAG, "AirPods button long-pressed, opening QuickSettingsDialogActivity")
+                    val intent = Intent().apply {
+                        setClassName("me.kavishdevar.librepods", "me.kavishdevar.librepods.QuickSettingsDialogActivity")
+                        flags = Intent.FLAG_ACTIVITY_NEW_TASK
+                    }
+                    context.startActivity(intent)
+                    try {
+                        val dismissMethod = volumeDialog.javaClass.getMethod("dismissH")
+                        dismissMethod.invoke(volumeDialog)
+                    } catch (e: Exception) {
+                        Log.w(TAG, "Could not dismiss volume dialog: ${e.message}")
+                    }
+                    true
+                }
+
+                val airPodsDrawer = LinearLayout(context).apply {
+                    orientation = LinearLayout.VERTICAL
+                    layoutParams = FrameLayout.LayoutParams(
+                        FrameLayout.LayoutParams.MATCH_PARENT,
+                        FrameLayout.LayoutParams.WRAP_CONTENT
+                    ).apply {
+                        gravity = Gravity.TOP
+                    }
+                    tag = "airpods_drawer_container"
+                    visibility = View.GONE
+                    alpha = 0f
+
+                    val drawerShape = GradientDrawable()
+                    drawerShape.shape = GradientDrawable.RECTANGLE
+                    drawerShape.setColor(Color.BLACK)
+                    background = drawerShape
+
+                    setPadding(16, 8, 16, 8)
+                }
+
+                val buttonContainer = LinearLayout(context).apply {
+                    orientation = LinearLayout.VERTICAL
+                    layoutParams = FrameLayout.LayoutParams(
+                        FrameLayout.LayoutParams.MATCH_PARENT,
+                        FrameLayout.LayoutParams.WRAP_CONTENT
+                    ).apply {
+                        gravity = Gravity.TOP
+                    }
+                    tag = "airpods_button_container"
+                }
+
+                val modes = listOf(ANC_MODE_OFF, ANC_MODE_TRANSPARENCY, ANC_MODE_ADAPTIVE, ANC_MODE_NOISE_CANCELLATION)
+                for (mode in modes) {
+                    val modeOption = createAncModeOption(context, mode, mode == currentANCMode, newAirPodsButton)
+                    airPodsDrawer.addView(modeOption)
+                }
+
+                buttonContainer.addView(newAirPodsButton)
+
+                airPodsContainer.addView(airPodsDrawer)
+                airPodsContainer.addView(buttonContainer)
+
+                val settingsViewField = try {
+                    val field = volumeDialog.javaClass.getDeclaredField("mSettingsView")
+                    field.isAccessible = true
+                    field.get(volumeDialog) as? View
+                } catch (e: Exception) {
+                    Log.e(TAG, "Failed to get settings view field: ${e.message}")
+                    null
+                }
+
+                if (settingsViewField != null && settingsViewField.parent is ViewGroup) {
+                    val settingsParent = settingsViewField.parent as ViewGroup
+                    val settingsIndex = findViewIndexInParent(settingsParent, settingsViewField)
+
+                    if (settingsIndex >= 0) {
+                        settingsParent.addView(airPodsContainer, settingsIndex)
+                        Log.i(TAG, "Added AirPods controls before settings button")
+                    } else {
+                        settingsParent.addView(airPodsContainer)
+                        Log.i(TAG, "Added AirPods controls to the end of settings parent")
+                    }
+                } else {
+                    dialogView.addView(airPodsContainer)
+                    Log.i(TAG, "Fallback: Added AirPods controls to dialog view")
+                }
+
+                updateMainButtonIcon(context, newAirPodsButton, currentANCMode)
+
+                Log.i(TAG, "Successfully added AirPods button and drawer to volume dialog")
+            } catch (e: Exception) {
+                Log.e(TAG, "Error adding AirPods button to volume panel: ${e.message}")
+                e.printStackTrace()
+            }
+        }
+
+        private fun findViewIndexInParent(parent: ViewGroup, view: View): Int {
+            for (i in 0 until parent.childCount) {
+                if (parent.getChildAt(i) == view) {
+                    return i
+                }
+            }
+            return -1
+        }
+
+        private fun updateMainButtonIcon(context: Context, button: ImageButton, mode: Int) {
+            try {
+                val pkgContext = context.createPackageContext(
+                    "me.kavishdevar.librepods",
+                    Context.CONTEXT_IGNORE_SECURITY
+                )
+
+                val resName = when (mode) {
+                    ANC_MODE_OFF -> "noise_cancellation"
+                    ANC_MODE_TRANSPARENCY -> "transparency"
+                    ANC_MODE_ADAPTIVE -> "adaptive"
+                    ANC_MODE_NOISE_CANCELLATION -> "noise_cancellation"
+                    else -> "noise_cancellation"
+                }
+
+                val resId = pkgContext.resources.getIdentifier(
+                    resName, "drawable", "me.kavishdevar.librepods"
+                )
+
+                if (resId != 0) {
+                    val drawable = pkgContext.resources.getDrawable(resId, pkgContext.theme)
+                    button.setImageDrawable(drawable)
+                    button.setColorFilter(Color.WHITE)
+                } else {
+                    button.setImageResource(getIconResourceForMode(mode))
+                    button.setColorFilter(Color.WHITE)
+                }
+            } catch (e: Exception) {
+                button.setImageResource(getIconResourceForMode(mode))
+                button.setColorFilter(Color.WHITE)
+            }
+        }
+
+        private fun createAncModeOption(context: Context, mode: Int, isSelected: Boolean, mainButton: ImageButton): LinearLayout {
+            return LinearLayout(context).apply {
+                orientation = LinearLayout.HORIZONTAL
+                layoutParams = LinearLayout.LayoutParams(
+                    LinearLayout.LayoutParams.MATCH_PARENT,
+                    LinearLayout.LayoutParams.WRAP_CONTENT
+                ).apply {
+                    setMargins(0, 6, 0, 6)
+                }
+                gravity = Gravity.CENTER
+                setPadding(24, 16, 24, 16)
+                tag = "anc_mode_${mode}"
+
+                val icon = ImageView(context).apply {
+                    layoutParams = LinearLayout.LayoutParams(60, 60).apply {
+                        gravity = Gravity.CENTER
+                    }
+                    tag = "mode_icon_$mode"
+
+                    try {
+                        val packageContext = context.createPackageContext(
+                            "me.kavishdevar.librepods",
+                            Context.CONTEXT_IGNORE_SECURITY
+                        )
+
+                        val resourceName = when (mode) {
+                            ANC_MODE_OFF -> "noise_cancellation"
+                            ANC_MODE_TRANSPARENCY -> "transparency"
+                            ANC_MODE_ADAPTIVE -> "adaptive"
+                            ANC_MODE_NOISE_CANCELLATION -> "noise_cancellation"
+                            else -> "noise_cancellation"
+                        }
+
+                        val resourceId = packageContext.resources.getIdentifier(
+                            resourceName, "drawable", "me.kavishdevar.librepods"
+                        )
+
+                        if (resourceId != 0) {
+                            val drawable = packageContext.resources.getDrawable(
+                                resourceId, packageContext.theme
+                            )
+                            setImageDrawable(drawable)
+                        } else {
+                            setImageResource(getIconResourceForMode(mode))
+                        }
+                    } catch (e: Exception) {
+                        setImageResource(getIconResourceForMode(mode))
+                        Log.e(TAG, "Failed to load custom drawable for mode $mode: ${e.message}")
+                    }
+
+                    if (isSelected) {
+                        setColorFilter(Color.BLACK)
+                    } else {
+                        setColorFilter(Color.WHITE)
+                    }
+                }
+
+                addView(icon)
+
+                if (isSelected) {
+                    background = createSelectedBackground(context)
+                } else {
+                    background = null
+                }
+
+                setOnClickListener {
+                    Log.d(TAG, "ANC mode selected: $mode (was: $currentANCMode)")
+                    val container = findAirPodsContainer(this)
+                    val drawerContainer = container?.findViewWithTag<View>("airpods_drawer_container")
+
+                    if (currentANCMode == mode) {
+                        if (drawerContainer != null && container != null) {
+                            hideAirPodsDrawer(container, mainButton, drawerContainer)
+                        }
+                        return@setOnClickListener
+                    }
+
+                    currentANCMode = mode
+
+                    val parentDrawer = parent as? ViewGroup
+                    if (parentDrawer != null) {
+                        for (i in 0 until parentDrawer.childCount) {
+                            val child = parentDrawer.getChildAt(i) as? LinearLayout
+                            if (child != null && child.tag.toString().startsWith("anc_mode_")) {
+                                val childModeStr = child.tag.toString().substringAfter("anc_mode_")
+                                val childMode = childModeStr.toIntOrNull() ?: -1
+                                val childIcon = child.findViewWithTag<ImageView>("mode_icon_${childMode}")
+
+                                if (childMode == mode) {
+                                    child.background = createSelectedBackground(context)
+                                    childIcon?.setColorFilter(Color.BLACK)
+                                } else {
+                                    child.background = null
+                                    childIcon?.setColorFilter(Color.WHITE)
+                                }
+                            }
+                        }
+                    }
+
+                    val intent = Intent(ACTION_SET_ANC_MODE).apply {
+                        setPackage("me.kavishdevar.librepods")
+                        putExtra(EXTRA_ANC_MODE, mode)
+                    }
+                    context.sendBroadcast(intent)
+                    Log.d(TAG, "Sent broadcast to change ANC mode to: ${getLabelForMode(currentANCMode)}")
+
+
+                    updateMainButtonIcon(context, mainButton, mode)
+
+                    if (drawerContainer != null && container != null) {
+                         android.os.Handler(android.os.Looper.getMainLooper()).postDelayed({
+                             hideAirPodsDrawer(container, mainButton, drawerContainer)
+                         }, 50)
+                    }
+                }
+            }
+        }
+
+        private fun createSelectedBackground(context: Context): GradientDrawable {
+            return GradientDrawable().apply {
+                shape = GradientDrawable.RECTANGLE
+                setColor(Color.WHITE)
+                cornerRadius = 50f
+            }
+        }
+
+        private fun findAirPodsContainer(view: View): ViewGroup? {
+            var current: View? = view
+            while (current != null) {
+                if (current is ViewGroup && current.tag == "airpods_container") {
+                    return current
+                }
+                val parent = current.parent
+                if (parent is ViewGroup && parent.tag == "airpods_container") {
+                    return parent
+                }
+                current = parent as? View
+            }
+            Log.w(TAG, "Could not find airpods_container ancestor")
+            return null
+        }
+
+        private fun showAirPodsDrawer(container: ViewGroup, mainButton: ImageButton, drawerContainer: View) {
+            Log.d(TAG, "Showing AirPods drawer")
+            val selectedModeView = drawerContainer.findViewWithTag<View>("anc_mode_$currentANCMode")
+            val selectedModeIcon = selectedModeView?.findViewWithTag<ImageView>("mode_icon_$currentANCMode")
+            val buttonContainer = container.findViewWithTag<View>("airpods_button_container")
+
+            if (selectedModeView == null || selectedModeIcon == null) {
+                Log.e(TAG, "Cannot find selected mode view or icon for show animation")
+
+                drawerContainer.alpha = 0f
+                drawerContainer.visibility = View.VISIBLE
+
+                drawerContainer.animate()
+                    .alpha(1f)
+                    .setDuration(ANIMATION_DURATION)
+                    .start()
+
+                buttonContainer?.animate()
+                    ?.alpha(0f)
+                    ?.setDuration(ANIMATION_DURATION / 2)
+                    ?.setStartDelay(ANIMATION_DURATION / 2)
+                    ?.withEndAction {
+                        buttonContainer.visibility = View.GONE
+                    }
+                    ?.start()
+
+                return
+            }
+
+            drawerContainer.measure(
+                View.MeasureSpec.makeMeasureSpec(container.width, View.MeasureSpec.EXACTLY),
+                View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED)
+            )
+
+            val drawerHeight = drawerContainer.measuredHeight
+
+            drawerContainer.alpha = 0f
+            drawerContainer.visibility = View.VISIBLE
+            drawerContainer.translationY = -drawerHeight.toFloat()
+
+            drawerContainer.animate()
+                .translationY(0f)
+                .alpha(1f)
+                .setDuration(ANIMATION_DURATION)
+                .setInterpolator(DecelerateInterpolator())
+                .start()
+
+            buttonContainer?.animate()
+                ?.alpha(0f)
+                ?.setDuration(ANIMATION_DURATION / 2)
+                ?.setStartDelay(ANIMATION_DURATION / 3)
+                ?.withEndAction {
+                    buttonContainer.visibility = View.GONE
+                }
+                ?.start()
+        }
+
+        private fun hideAirPodsDrawer(container: ViewGroup, mainButton: ImageButton, drawerContainer: View) {
+            Log.d(TAG, "Hiding AirPods drawer")
+            val buttonContainer = container.findViewWithTag<View>("airpods_button_container")
+
+            if (buttonContainer != null && buttonContainer.visibility != View.VISIBLE) {
+                buttonContainer.alpha = 0f
+                buttonContainer.visibility = View.VISIBLE
+            }
+
+            buttonContainer?.animate()
+                ?.alpha(1f)
+                ?.setDuration(ANIMATION_DURATION / 2)
+                ?.start()
+
+            drawerContainer.animate()
+                .translationY(-drawerContainer.height.toFloat())
+                .alpha(0f)
+                .setDuration(ANIMATION_DURATION)
+                .setInterpolator(AccelerateInterpolator())
+                .setStartDelay(ANIMATION_DURATION / 4)
+                .withEndAction {
+                    drawerContainer.visibility = View.GONE
+                    drawerContainer.translationY = 0f
+                }
+                .start()
+        }
+
+        private fun getIconResourceForMode(mode: Int): Int {
+            return when (mode) {
+                ANC_MODE_OFF -> android.R.drawable.ic_lock_silent_mode
+                ANC_MODE_TRANSPARENCY -> android.R.drawable.ic_lock_silent_mode_off
+                ANC_MODE_ADAPTIVE -> android.R.drawable.ic_menu_compass
+                ANC_MODE_NOISE_CANCELLATION -> android.R.drawable.ic_lock_idle_charging
+                else -> android.R.drawable.ic_lock_silent_mode_off
+            }
+        }
+
+        private fun getLabelForMode(mode: Int): String {
+            return when (mode) {
+                ANC_MODE_OFF -> "Off"
+                ANC_MODE_TRANSPARENCY -> "Transparency"
+                ANC_MODE_ADAPTIVE -> "Adaptive"
+                ANC_MODE_NOISE_CANCELLATION -> "Noise Cancellation"
+                else -> "Unknown"
+            }
+        }
+    }
+}

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

@@ -0,0 +1,215 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package me.kavishdevar.librepods.utils
+
+import android.content.Context
+import android.content.Intent
+import android.net.Uri
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.BufferedReader
+import java.io.File
+import java.io.InputStreamReader
+
+class LogCollector(private val context: Context) {
+    private var isCollecting = false
+    private var logProcess: Process? = null
+    
+    suspend fun openXposedSettings(context: Context) {
+        withContext(Dispatchers.IO) {
+            val command = if (android.os.Build.VERSION.SDK_INT >= 29) {
+                "am broadcast -a android.telephony.action.SECRET_CODE -d android_secret_code://5776733 android"
+            } else {
+                "am broadcast -a android.provider.Telephony.SECRET_CODE -d android_secret_code://5776733 android"
+            }
+            
+            executeRootCommand(command)
+        }
+    }
+    
+    suspend fun clearLogs() {
+        withContext(Dispatchers.IO) {
+            executeRootCommand("logcat -c")
+        }
+    }
+    
+    suspend fun killBluetoothService() {
+        withContext(Dispatchers.IO) {
+            executeRootCommand("killall com.android.bluetooth")
+        }
+    }
+    
+    private suspend fun getPackageUIDs(): Pair<String?, String?> {
+        return withContext(Dispatchers.IO) {
+            val btUid = executeRootCommand("dumpsys package com.android.bluetooth | grep -m 1 \"uid=\" | sed -E 's/.*uid=([0-9]+).*/\\1/'")
+                .trim()
+                .takeIf { it.isNotEmpty() }
+            
+            val appUid = executeRootCommand("dumpsys package me.kavishdevar.librepods | grep -m 1 \"uid=\" | sed -E 's/.*uid=([0-9]+).*/\\1/'")
+                .trim()
+                .takeIf { it.isNotEmpty() }
+            
+            Pair(btUid, appUid)
+        }
+    }
+    
+    suspend fun startLogCollection(listener: (String) -> Unit, connectionDetectedCallback: () -> Unit): String {
+        return withContext(Dispatchers.IO) {
+            isCollecting = true
+            val (btUid, appUid) = getPackageUIDs()
+            
+            val uidFilter = buildString {
+                if (!btUid.isNullOrEmpty() && !appUid.isNullOrEmpty()) {
+                    append("$btUid,$appUid")
+                } else if (!btUid.isNullOrEmpty()) {
+                    append(btUid)
+                } else if (!appUid.isNullOrEmpty()) {
+                    append(appUid)
+                }
+            }
+            
+            val command = if (uidFilter.isNotEmpty()) {
+                "su -c logcat --uid=$uidFilter -v threadtime"
+            } else {
+                "su -c logcat -v threadtime"
+            }
+            
+            val logs = StringBuilder()
+            try {
+                logProcess = Runtime.getRuntime().exec(command)
+                val reader = BufferedReader(InputStreamReader(logProcess!!.inputStream))
+                var line: String? = null
+                var connectionDetected = false
+                
+                while (isCollecting && reader.readLine().also { line = it } != null) {
+                    line?.let {
+                        if (it.contains("<LogCollector:")) {
+                            logs.append("\n=============\n")
+                        }
+                        
+                        logs.append(it).append("\n")
+                        listener(it)
+                        
+                        if (it.contains("<LogCollector:")) {
+                            logs.append("=============\n\n")
+                        }
+                        
+                        if (!connectionDetected) {
+                            if (it.contains("<LogCollector:Complete:Success>")) {
+                                connectionDetected = true
+                                connectionDetectedCallback()
+                            } else if (it.contains("<LogCollector:Complete:Failed>")) {
+                                connectionDetected = true
+                                connectionDetectedCallback()
+                            } else if (it.contains("<LogCollector:Start>")) {
+                            } 
+                            else if (it.contains("AirPodsService") && it.contains("Connected to device")) {
+                                connectionDetected = true
+                                connectionDetectedCallback()
+                            } else if (it.contains("AirPodsService") && it.contains("Connection failed")) {
+                                connectionDetected = true
+                                connectionDetectedCallback()
+                            } else if (it.contains("AirPodsService") && it.contains("Device disconnected")) {
+                            }
+                            else if (it.contains("BluetoothService") && it.contains("CONNECTION_STATE_CONNECTED")) {
+                                connectionDetected = true
+                                connectionDetectedCallback()
+                            } else if (it.contains("BluetoothService") && it.contains("CONNECTION_STATE_DISCONNECTED")) {
+                            }
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                logs.append("Error collecting logs: ${e.message}").append("\n")
+                e.printStackTrace()
+            }
+            
+            logs.toString()
+        }
+    }
+    
+    fun stopLogCollection() {
+        isCollecting = false
+        logProcess?.destroy()
+        logProcess = null
+    }
+    
+    suspend fun saveLogToInternalStorage(fileName: String, content: String): File? {
+        return withContext(Dispatchers.IO) {
+            try {
+                val logsDir = File(context.filesDir, "logs")
+                if (!logsDir.exists()) {
+                    logsDir.mkdir()
+                }
+                
+                val file = File(logsDir, fileName)
+                file.writeText(content)
+                return@withContext file
+            } catch (e: Exception) {
+                e.printStackTrace()
+                return@withContext null
+            }
+        }
+    }
+    
+    suspend fun addLogMarker(markerType: LogMarkerType, details: String = "") {
+        withContext(Dispatchers.IO) {
+            val timestamp = java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS", java.util.Locale.US)
+                .format(java.util.Date())
+            
+            val marker = when (markerType) {
+                LogMarkerType.START -> "<LogCollector:Start> [$timestamp] Beginning connection test"
+                LogMarkerType.SUCCESS -> "<LogCollector:Complete:Success> [$timestamp] Connection test completed successfully"
+                LogMarkerType.FAILURE -> "<LogCollector:Complete:Failed> [$timestamp] Connection test failed"
+                LogMarkerType.CUSTOM -> "<LogCollector:Custom:$details> [$timestamp]"
+            }
+            
+            val command = "log -t AirPodsService \"$marker\""
+            executeRootCommand(command)
+        }
+    }
+    
+    enum class LogMarkerType {
+        START,
+        SUCCESS,
+        FAILURE,
+        CUSTOM
+    }
+    
+    private suspend fun executeRootCommand(command: String): String {
+        return withContext(Dispatchers.IO) {
+            try {
+                val process = Runtime.getRuntime().exec("su -c $command")
+                val reader = BufferedReader(InputStreamReader(process.inputStream))
+                val output = StringBuilder()
+                var line: String?
+                
+                while (reader.readLine().also { line = it } != null) {
+                    output.append(line).append("\n")
+                }
+                
+                process.waitFor()
+                output.toString()
+            } catch (e: Exception) {
+                e.printStackTrace()
+                ""
+            }
+        }
+    }
+}

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

@@ -0,0 +1,203 @@
+/*
+ * LibrePods - AirPods liberated from Apple’s ecosystem
+ *
+ * Copyright (C) 2025 LibrePods contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.utils
+
+import android.content.SharedPreferences
+import android.media.AudioManager
+import android.media.AudioPlaybackConfiguration
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
+import android.view.KeyEvent
+import androidx.annotation.RequiresApi
+import me.kavishdevar.librepods.services.ServiceManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+object MediaController {
+    private var initialVolume: Int? = null
+    private lateinit var audioManager: AudioManager
+    var iPausedTheMedia = false
+    var userPlayedTheMedia = false
+    private lateinit var sharedPreferences: SharedPreferences
+    private val handler = Handler(Looper.getMainLooper())
+    private lateinit var preferenceChangeListener: SharedPreferences.OnSharedPreferenceChangeListener
+
+    var pausedForCrossDevice = false
+
+    private var relativeVolume: Boolean = false
+    private var conversationalAwarenessVolume: Int = 2
+    private var conversationalAwarenessPauseMusic: Boolean = false
+
+    fun initialize(audioManager: AudioManager, sharedPreferences: SharedPreferences) {
+        if (this::audioManager.isInitialized) {
+            return
+        }
+        this.audioManager = audioManager
+        this.sharedPreferences = sharedPreferences
+        Log.d("MediaController", "Initializing MediaController")
+        relativeVolume = sharedPreferences.getBoolean("relative_conversational_awareness_volume", false)
+        conversationalAwarenessVolume = sharedPreferences.getInt("conversational_awareness_volume", (audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) / 0.4).toInt())
+        conversationalAwarenessPauseMusic = sharedPreferences.getBoolean("conversational_awareness_pause_music", false)
+
+        preferenceChangeListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
+            when (key) {
+                "relative_conversational_awareness_volume" -> {
+                    relativeVolume = sharedPreferences.getBoolean("relative_conversational_awareness_volume", false)
+                }
+                "conversational_awareness_volume" -> {
+                    conversationalAwarenessVolume = sharedPreferences.getInt("conversational_awareness_volume", (audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) * 0.4).toInt())
+                }
+                "conversational_awareness_pause_music" -> {
+                    conversationalAwarenessPauseMusic = sharedPreferences.getBoolean("conversational_awareness_pause_music", false)
+                }
+            }
+        }
+
+        sharedPreferences.registerOnSharedPreferenceChangeListener(preferenceChangeListener)
+
+        audioManager.registerAudioPlaybackCallback(cb, null)
+    }
+
+    val cb = object : AudioManager.AudioPlaybackCallback() {
+        @RequiresApi(Build.VERSION_CODES.R)
+        override fun onPlaybackConfigChanged(configs: MutableList<AudioPlaybackConfiguration>?) {
+            super.onPlaybackConfigChanged(configs)
+            Log.d("MediaController", "Playback config changed, iPausedTheMedia: $iPausedTheMedia")
+            if (configs != null && !iPausedTheMedia) {
+                Log.d("MediaController", "Seems like the user changed the state of media themselves, now I won't play until the ear detection pauses it.")
+                handler.postDelayed({
+                    userPlayedTheMedia = audioManager.isMusicActive
+                }, 7) // i have no idea why android sends an event a hundred times after the user does something.
+            }
+            Log.d("MediaController", "pausedforcrossdevice: $pausedForCrossDevice")
+            if (!pausedForCrossDevice && audioManager.isMusicActive) {
+                ServiceManager.getService()?.takeOver("music")
+            }
+        }
+    }
+
+    @Synchronized
+    fun getMusicActive(): Boolean {
+        return audioManager.isMusicActive
+    }
+
+    @Synchronized
+    fun sendPause(force: Boolean = false) {
+        Log.d("MediaController", "Sending pause with iPausedTheMedia: $iPausedTheMedia, userPlayedTheMedia: $userPlayedTheMedia, isMusicActive: ${audioManager.isMusicActive}, force: $force")
+        if ((audioManager.isMusicActive) && (!userPlayedTheMedia || force)) {
+            iPausedTheMedia = if (force) audioManager.isMusicActive else true
+            userPlayedTheMedia = false
+            audioManager.dispatchMediaKeyEvent(
+                KeyEvent(
+                    KeyEvent.ACTION_DOWN,
+                    KeyEvent.KEYCODE_MEDIA_PAUSE
+                )
+            )
+            audioManager.dispatchMediaKeyEvent(
+                KeyEvent(
+                    KeyEvent.ACTION_UP,
+                    KeyEvent.KEYCODE_MEDIA_PAUSE
+                )
+            )
+        }
+    }
+
+    @Synchronized
+    fun sendPlay() {
+        Log.d("MediaController", "Sending play with iPausedTheMedia: $iPausedTheMedia")
+        if (iPausedTheMedia) {
+            Log.d("MediaController", "Sending play and setting userPlayedTheMedia to false")
+            userPlayedTheMedia = false
+            audioManager.dispatchMediaKeyEvent(
+                KeyEvent(
+                    KeyEvent.ACTION_DOWN,
+                    KeyEvent.KEYCODE_MEDIA_PLAY
+                )
+            )
+            audioManager.dispatchMediaKeyEvent(
+                KeyEvent(
+                    KeyEvent.ACTION_UP,
+                    KeyEvent.KEYCODE_MEDIA_PLAY
+                )
+            )
+        }
+        if (!audioManager.isMusicActive) {
+            Log.d("MediaController", "Setting iPausedTheMedia to false")
+            iPausedTheMedia = false
+        }
+        if (pausedForCrossDevice) {
+            Log.d("MediaController", "Setting pausedForCrossDevice to false")
+            pausedForCrossDevice = false
+        }
+    }
+
+    @Synchronized
+    fun startSpeaking() {
+        Log.d("MediaController", "Starting speaking max vol: ${audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC)}, current vol: ${audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)}, conversationalAwarenessVolume: $conversationalAwarenessVolume, relativeVolume: $relativeVolume")
+
+        if (initialVolume == null) {
+            initialVolume = audioManager.getStreamVolume(AudioManager.STREAM_MUSIC)
+            Log.d("MediaController", "Initial Volume: $initialVolume")
+            val targetVolume = if (relativeVolume) {
+                (initialVolume!! * conversationalAwarenessVolume / 100)
+            } else if (initialVolume!! > (audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) * conversationalAwarenessVolume / 100)) {
+                (audioManager.getStreamMaxVolume(AudioManager.STREAM_MUSIC) * conversationalAwarenessVolume / 100)
+            } else {
+                initialVolume!!
+            }
+            smoothVolumeTransition(initialVolume!!, targetVolume.toInt())
+            if (conversationalAwarenessPauseMusic) {
+                sendPause(force = true)
+            }
+        }
+        Log.d("MediaController", "Initial Volume: $initialVolume")
+    }
+
+    @Synchronized
+    fun stopSpeaking() {
+        Log.d("MediaController", "Stopping speaking, initialVolume: $initialVolume")
+        if (initialVolume != null) {
+            smoothVolumeTransition(audioManager.getStreamVolume(AudioManager.STREAM_MUSIC), initialVolume!!)
+            if (conversationalAwarenessPauseMusic) {
+                sendPlay()
+            }
+            initialVolume = null
+        }
+    }
+
+    private fun smoothVolumeTransition(fromVolume: Int, toVolume: Int) {
+        Log.d("MediaController", "Smooth volume transition from $fromVolume to $toVolume")
+        val step = if (fromVolume < toVolume) 1 else -1
+        val delay = 50L
+        var currentVolume = fromVolume
+
+        handler.post(object : Runnable {
+            override fun run() {
+                if (currentVolume != toVolume) {
+                    currentVolume += step
+                    audioManager.setStreamVolume(AudioManager.STREAM_MUSIC, currentVolume, 0)
+                    handler.postDelayed(this, delay)
+                }
+            }
+        })
+    }
+}

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

@@ -0,0 +1,368 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+@file:Suppress("unused")
+
+package me.kavishdevar.librepods.utils
+
+import android.os.Parcelable
+import android.util.Log
+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)),
+    START_HEAD_TRACKING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x10, 0x00, 0x10, 0x00, 0x08, 0xA1.toByte(), 0x02, 0x42, 0x0B, 0x08, 0x0E, 0x10, 0x02, 0x1A, 0x05, 0x01, 0x40, 0x9C.toByte(), 0x00, 0x00)),
+    STOP_HEAD_TRACKING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x17, 0x00, 0x00, 0x00, 0x10, 0x00, 0x11, 0x00, 0x08, 0x7E.toByte(), 0x10, 0x02, 0x42, 0x0B, 0x08, 0x4E.toByte(), 0x10, 0x02, 0x1A, 0x05, 0x01, 0x00, 0x00, 0x00, 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
+        }
+    }
+}
+
+enum class NoiseControlMode {
+    OFF,  NOISE_CANCELLATION, TRANSPARENCY, ADAPTIVE
+}
+
+class AirPodsNotifications {
+    companion object {
+        const val AIRPODS_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"
+    }
+
+    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())
+            }
+        }
+
+        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 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));
+    }
+}
+
+enum class LongPressPackets(val value: ByteArray) {
+    ENABLE_EVERYTHING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0F, 0x00, 0x00, 0x00)),
+
+    DISABLE_OFF_FROM_EVERYTHING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0e, 0x00, 0x00, 0x00)),
+    DISABLE_OFF_FROM_TRANSPARENCY_AND_ADAPTIVE(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0c, 0x00, 0x00, 0x00)),
+    DISABLE_OFF_FROM_TRANSPARENCY_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x06, 0x00, 0x00, 0x00)),
+    DISABLE_OFF_FROM_ADAPTIVE_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0a, 0x00, 0x00, 0x00)),
+
+    ENABLE_OFF_FROM_TRANSPARENCY_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x07, 0x00, 0x00, 0x00)),
+    ENABLE_OFF_FROM_ADAPTIVE_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0b, 0x00, 0x00, 0x00)),
+    ENABLE_OFF_FROM_TRANSPARENCY_AND_ADAPTIVE(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0d, 0x00, 0x00, 0x00)),
+
+    DISABLE_TRANSPARENCY_FROM_EVERYTHING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0b, 0x00, 0x00, 0x00)),
+    DISABLE_TRANSPARENCY_FROM_OFF_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x03, 0x00, 0x00, 0x00)),
+    DISABLE_TRANSPARENCY_FROM_ADAPTIVE_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0a, 0x00, 0x00, 0x00)),
+    DISABLE_TRANSPARENCY_FROM_OFF_AND_ADAPTIVE(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x09, 0x00, 0x00, 0x00)),
+
+    ENABLE_TRANSPARENCY_FROM_OFF_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x07, 0x00, 0x00, 0x00)),
+    ENABLE_TRANSPARENCY_FROM_ADAPTIVE_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0e, 0x00, 0x00, 0x00)),
+    ENABLE_TRANSPARENCY_FROM_OFF_AND_ADAPTIVE(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0d, 0x00, 0x00, 0x00)),
+
+    DISABLE_ANC_FROM_EVERYTHING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0D, 0x00, 0x00, 0x00)),
+    DISABLE_ANC_FROM_OFF_AND_TRANSPARENCY(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x05, 0x00, 0x00, 0x00)),
+    DISABLE_ANC_FROM_ADAPTIVE_AND_TRANSPARENCY(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0c, 0x00, 0x00, 0x00)),
+    DISABLE_ANC_FROM_OFF_AND_ADAPTIVE(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x09, 0x00, 0x00, 0x00)),
+
+    ENABLE_ANC_FROM_OFF_AND_TRANSPARENCY(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x07, 0x00, 0x00, 0x00)),
+    ENABLE_ANC_FROM_ADAPTIVE_AND_TRANSPARENCY(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0e, 0x00, 0x00, 0x00)),
+    ENABLE_ANC_FROM_OFF_AND_ADAPTIVE(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0b, 0x00, 0x00, 0x00)),
+
+    DISABLE_ADAPTIVE_FROM_EVERYTHING(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x07, 0x00, 0x00, 0x00)),
+    DISABLE_ADAPTIVE_FROM_OFF_AND_TRANSPARENCY(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x05, 0x00, 0x00, 0x00)),
+    DISABLE_ADAPTIVE_FROM_TRANSPARENCY_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x06, 0x00, 0x00, 0x00)),
+    DISABLE_ADAPTIVE_FROM_OFF_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x03, 0x00, 0x00, 0x00)),
+
+    ENABLE_ADAPTIVE_FROM_OFF_AND_TRANSPARENCY(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0d, 0x00, 0x00, 0x00)),
+    ENABLE_ADAPTIVE_FROM_TRANSPARENCY_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0e, 0x00, 0x00, 0x00)),
+    ENABLE_ADAPTIVE_FROM_OFF_AND_ANC(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0b, 0x00, 0x00, 0x00)),
+
+    ENABLE_EVERYTHING_OFF_DISABLED(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0E, 0x00, 0x00, 0x00)),
+    DISABLE_TRANSPARENCY_OFF_DISABLED(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0A, 0x00, 0x00, 0x00)),
+    DISABLE_ADAPTIVE_OFF_DISABLED(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x06, 0x00, 0x00, 0x00)),
+    DISABLE_ANC_OFF_DISABLED(byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A, 0x0C, 0x00, 0x00, 0x00)),
+}
+
+//enum class LongPressMode {
+//    OFF, TRANSPARENCY, ADAPTIVE, ANC
+//}
+//
+//data class LongPressPacket(val modes: Set<LongPressMode>) {
+//    val value: ByteArray
+//        get() {
+//            val baseArray = byteArrayOf(0x04, 0x00, 0x04, 0x00, 0x09, 0x00, 0x1A)
+//            val modeByte = calculateModeByte()
+//            return baseArray + byteArrayOf(modeByte, 0x00, 0x00, 0x00)
+//        }
+//
+//    private fun calculateModeByte(): Byte {
+//        var modeByte: Byte = 0x00
+//        modes.forEach { mode ->
+//            modeByte = when (mode) {
+//                LongPressMode.OFF -> (modeByte + 0x01).toByte()
+//                LongPressMode.TRANSPARENCY -> (modeByte + 0x02).toByte()
+//                LongPressMode.ADAPTIVE -> (modeByte + 0x04).toByte()
+//                LongPressMode.ANC -> (modeByte + 0x08).toByte()
+//            }
+//        }
+//        return modeByte
+//    }
+//}
+//
+//fun determinePacket(changedIndex: Int, newEnabled: Boolean, oldModes: Set<LongPressMode>, newModes: Set<LongPressMode>): ByteArray? {
+//    return if (newEnabled) {
+//        LongPressPacket(oldModes + newModes.elementAt(changedIndex)).value
+//    } else {
+//        LongPressPacket(oldModes - newModes.elementAt(changedIndex)).value
+//    }
+//}
+
+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].toByte()) 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/utils/PopupWindow.kt

@@ -0,0 +1,272 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+
+package me.kavishdevar.librepods.utils
+
+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
+
+@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
+        width = WindowManager.LayoutParams.MATCH_PARENT
+        type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY
+        format = PixelFormat.TRANSLUCENT
+        gravity = Gravity.BOTTOM
+        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
+
+        mParams.gravity = Gravity.BOTTOM
+        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()
+                }
+                
+                mWindowManager.addView(mView, mParams)
+
+                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()
+        }
+    }
+
+    private fun registerBatteryUpdateReceiver() {
+        batteryUpdateReceiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context?, intent: Intent?) {
+                if (intent?.action == AirPodsNotifications.BATTERY_DATA) {
+                    val batteryList = intent.getParcelableArrayListExtra<Battery>("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()
+        }
+    }
+
+    val isShowing: Boolean
+        get() = mView.parent != null && !isClosing
+}

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

@@ -0,0 +1,306 @@
+package me.kavishdevar.librepods.utils
+
+import android.bluetooth.BluetoothDevice
+import android.util.Log
+import org.lsposed.hiddenapibypass.HiddenApiBypass
+
+object SystemApisUtils {
+
+    /**
+     * Device type which is used in METADATA_DEVICE_TYPE
+     * Indicates this Bluetooth device is an untethered headset.
+     * @hide
+     */
+    val BluetoothDevice.DEVICE_TYPE_UNTETHERED_HEADSET: String
+        get() = "Untethered Headset"
+
+    /**
+     * Maximum length of a metadata entry, this is to avoid exploding Bluetooth
+     * disk usage
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MAX_LENGTH: Int
+        get() = 2048
+
+    /**
+     * Manufacturer name of this Bluetooth device
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MANUFACTURER_NAME: Int
+        get() = 0
+
+    /**
+     * Model name of this Bluetooth device
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MODEL_NAME: Int
+        get() = 1
+
+    /**
+     * Software version of this Bluetooth device
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_SOFTWARE_VERSION: Int
+        get() = 2
+
+    /**
+     * Hardware version of this Bluetooth device
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_HARDWARE_VERSION: Int
+        get() = 3
+
+    /**
+     * Package name of the companion app, if any
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_COMPANION_APP: Int
+        get() = 4
+
+    /**
+     * URI to the main icon shown on the settings UI
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MAIN_ICON: Int
+        get() = 5
+
+    /**
+     * Whether this device is an untethered headset with left, right and case
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_IS_UNTETHERED_HEADSET: Int
+        get() = 6
+
+    /**
+     * URI to icon of the left headset
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_LEFT_ICON: Int
+        get() = 7
+
+    /**
+     * URI to icon of the right headset
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_RIGHT_ICON: Int
+        get() = 8
+
+    /**
+     * URI to icon of the headset charging case
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_CASE_ICON: Int
+        get() = 9
+
+    /**
+     * Battery level of left headset
+     * Data type should be {@String} 0-100 as [Byte] array, otherwise
+     * as invalid.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_LEFT_BATTERY: Int
+        get() = 10
+
+    /**
+     * Battery level of rigth headset
+     * Data type should be {@String} 0-100 as [Byte] array, otherwise
+     * as invalid.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_RIGHT_BATTERY: Int
+        get() = 11
+
+    /**
+     * Battery level of the headset charging case
+     * Data type should be {@String} 0-100 as [Byte] array, otherwise
+     * as invalid.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_CASE_BATTERY: Int
+        get() = 12
+
+    /**
+     * Whether the left headset is charging
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_LEFT_CHARGING: Int
+        get() = 13
+
+    /**
+     * Whether the right headset is charging
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_RIGHT_CHARGING: Int
+        get() = 14
+
+    /**
+     * Whether the headset charging case is charging
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_CASE_CHARGING: Int
+        get() = 15
+
+    /**
+     * URI to the enhanced settings UI slice
+     * Data type should be {@String} as [Byte] array, null means
+     * the UI does not exist.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_ENHANCED_SETTINGS_UI_URI: Int
+        get() = 16
+
+    /**
+     * @hide
+     */
+    val BluetoothDevice.COMPANION_TYPE_PRIMARY: String
+        get() = "COMPANION_PRIMARY"
+
+    /**
+     * @hide
+     */
+    val BluetoothDevice.COMPANION_TYPE_SECONDARY: String
+        get() = "COMPANION_SECONDARY"
+
+    /**
+     * @hide
+     */
+    val BluetoothDevice.COMPANION_TYPE_NONE: String
+        get() = "COMPANION_NONE"
+
+    /**
+     * Type of the Bluetooth device, must be within the list of
+     * BluetoothDevice.DEVICE_TYPE_*
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_DEVICE_TYPE: Int
+        get() = 17
+
+    /**
+     * Battery level of the Bluetooth device, use when the Bluetooth device
+     * does not support HFP battery indicator.
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MAIN_BATTERY: Int
+        get() = 18
+
+    /**
+     * Whether the device is charging.
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MAIN_CHARGING: Int
+        get() = 19
+
+    /**
+     * The battery threshold of the Bluetooth device to show low battery icon.
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_MAIN_LOW_BATTERY_THRESHOLD: Int
+        get() = 20
+
+    /**
+     * The battery threshold of the left headset to show low battery icon.
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_LEFT_LOW_BATTERY_THRESHOLD: Int
+        get() = 21
+
+    /**
+     * The battery threshold of the right headset to show low battery icon.
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_RIGHT_LOW_BATTERY_THRESHOLD: Int
+        get() = 22
+
+    /**
+     * The battery threshold of the case to show low battery icon.
+     * Data type should be {@String} as [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_UNTETHERED_CASE_LOW_BATTERY_THRESHOLD: Int
+        get() = 23
+
+
+    /**
+     * The metadata of the audio spatial data.
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_SPATIAL_AUDIO: Int
+        get() = 24
+
+    /**
+     * The metadata of the Fast Pair for any custmized feature.
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_FAST_PAIR_CUSTOMIZED_FIELDS: Int
+        get() = 25
+
+    /**
+     * The metadata of the Fast Pair for LE Audio capable devices.
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_LE_AUDIO: Int
+        get() = 26
+
+    /**
+     * The UUIDs (16-bit) of registered to CCC characteristics from Media Control services.
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_GMCS_CCCD: Int
+        get() = 27
+
+    /**
+     * The UUIDs (16-bit) of registered to CCC characteristics from Telephony Bearer service.
+     * Data type should be [Byte] array.
+     * @hide
+     */
+    val BluetoothDevice.METADATA_GTBS_CCCD: Int
+        get() = 28
+
+    const val BATTERY_LEVEL_UNKNOWN: Int = -1
+
+    const val ACTION_BLUETOOTH_HANDSFREE_BATTERY_CHANGED = "android.intent.action.BLUETOOTH_HANDSFREE_BATTERY_CHANGED"
+    const val EXTRA_SHOW_BT_HANDSFREE_BATTERY = "android.intent.extra.show_bluetooth_handsfree_battery"
+    const val EXTRA_BT_HANDSFREE_BATTERY_LEVEL = "android.intent.extra.bluetooth_handsfree_battery_level"
+
+    /**
+     * Helper method to set metadata using HiddenApiBypass
+     */
+     fun setMetadata(device: BluetoothDevice, key: Int, value: ByteArray): Boolean {
+        return try {
+            val result = HiddenApiBypass.invoke(
+                BluetoothDevice::class.java,
+                device,
+                "setMetadata",
+                key,
+                value
+            ) as Boolean
+            result
+        } catch (e: Exception) {
+            Log.e("SystemApisUtils", "Failed to set metadata for key $key", e)
+            false
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+/*
+ * 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 Affero General Public License as published
+ * by the Free Software Foundation, either version 3 of the License.
+ *
+ * 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+@file:OptIn(ExperimentalEncodingApi::class)
+
+package me.kavishdevar.librepods.widgets
+
+import android.appwidget.AppWidgetManager
+import android.appwidget.AppWidgetProvider
+import android.content.Context
+import me.kavishdevar.librepods.services.ServiceManager
+import kotlin.io.encoding.ExperimentalEncodingApi
+
+class BatteryWidget : AppWidgetProvider() {
+    override fun onUpdate(
+        context: Context,
+        appWidgetManager: AppWidgetManager,
+        appWidgetIds: IntArray
+    ) {
+        ServiceManager.getService()?.updateBattery()
+    }
+}