Adjust versioning for GPlay wear os bundle upload

Wear is still WIP.

.github/FUNDING.yml

@@ -1,4 +1,5 @@
 # These are supported funding model platforms
-
+github:
+  - d4rken
 custom:
   - "https://www.buymeacoffee.com/tydarken"

.github/workflows/code-checks.yml

@@ -0,0 +1,34 @@
+name: Code tests & eval
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build-and-test:
+    name: Build and test
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up JDK 11
+        uses: actions/setup-java@v2
+        with:
+          java-version: '11'
+          distribution: 'adopt'
+          cache: gradle
+
+      - name: Grant execute permission for gradlew
+        run: chmod +x gradlew
+
+      - name: Build FOSS variant
+        run: ./gradlew assembleFossDebug
+      - name: Test FOSS variant
+        run: ./gradlew testFossDebugUnitTest
+
+      - name: Build Google Play variant
+        run: ./gradlew assembleGplayDebug
+      - name: Test Google Play variant
+        run: ./gradlew testGplayDebugUnitTest

.github/workflows/gradle-wrapper-validation.yml

@@ -0,0 +1,17 @@
+name: "Validate Gradle Wrapper"
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: gradle/wrapper-validation-action@v1

.github/workflows/release-tag.yml

@@ -0,0 +1,157 @@
+name: Tagged releases
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  release-github:
+    name: Create GitHub release
+    runs-on: ubuntu-latest
+    environment: foss-production
+    steps:
+      - name: Decode Keystore
+        env:
+          ENCODED_KEYSTORE: ${{ secrets.SIGNING_KEYSTORE_BASE64 }}
+        run: |
+          TMP_KEYSTORE_DIR_PATH="${RUNNER_TEMP}"/keystore
+          mkdir -p "${TMP_KEYSTORE_DIR_PATH}"
+          TMP_KEYSTORE_FILE_PATH="${TMP_KEYSTORE_DIR_PATH}"/keystore.jks
+          echo $ENCODED_KEYSTORE | base64 -di > "${TMP_KEYSTORE_FILE_PATH}"
+          echo "STORE_PATH=$(echo $TMP_KEYSTORE_FILE_PATH)" >> $GITHUB_ENV
+
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Get the version
+        id: tagger
+        uses: jimschubert/query-tag-action@v2
+        with:
+          skip-unshallow: 'true'
+          abbrev: false
+          commit-ish: HEAD
+
+      - name: Install JDK ${{ matrix.java_version }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: 11
+
+      - name: Assemble beta APK
+        if: contains(steps.tagger.outputs.tag, '-beta')
+        run: ./gradlew assembleFossBeta
+        env:
+          VERSION: ${{ github.ref }}
+          STORE_PASSWORD: ${{ secrets.STORE_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+          BUGSNAG_API_KEY: ${{ secrets.BUGSNAG_API_KEY }}
+
+      - name: Assemble production APK
+        if: "!contains(steps.tagger.outputs.tag, '-beta')"
+        run: ./gradlew assembleFossRelease
+        env:
+          VERSION: ${{ github.ref }}
+          STORE_PASSWORD: ${{ secrets.STORE_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+          BUGSNAG_API_KEY: ${{ secrets.BUGSNAG_API_KEY }}
+
+      - name: Create pre-release
+        if: contains(steps.tagger.outputs.tag, '-beta')
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: true
+          tag_name: ${{ steps.tagger.outputs.tag }}
+          name: ${{ steps.tagger.outputs.tag }}
+          generate_release_notes: true
+          files: |
+            app/build/outputs/apk/foss/beta/*.apk
+            app-wear/build/outputs/apk/foss/beta/*.apk
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Create release
+        if: "!contains(steps.tagger.outputs.tag, '-beta')"
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: false
+          tag_name: ${{ steps.tagger.outputs.tag }}
+          name: ${{ steps.tagger.outputs.tag }}
+          generate_release_notes: true
+          files: |
+            app/build/outputs/apk/foss/release/*.apk
+            app-wear/build/outputs/apk/foss/release/*.apk
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+  release-gplay:
+    name: Create Google Play release
+    runs-on: ubuntu-latest
+    environment: gplay-production
+    steps:
+      - name: Decode Keystore
+        env:
+          ENCODED_KEYSTORE: ${{ secrets.SIGNING_KEYSTORE_BASE64 }}
+        run: |
+          TMP_KEYSTORE_DIR_PATH="${RUNNER_TEMP}"/keystore
+          mkdir -p "${TMP_KEYSTORE_DIR_PATH}"
+          TMP_KEYSTORE_FILE_PATH="${TMP_KEYSTORE_DIR_PATH}"/keystore.jks
+          echo $ENCODED_KEYSTORE | base64 -di > "${TMP_KEYSTORE_FILE_PATH}"
+          echo "STORE_PATH=$(echo $TMP_KEYSTORE_FILE_PATH)" >> $GITHUB_ENV
+
+      - name: Decode Google Play service account key
+        env:
+          ENCODED_SERVICE_KEY: ${{ secrets.GPLAY_SERVICE_ACCOUNT_KEY_JSON_BASE64 }}
+        run: |
+          TMP_SERVICEKEY_DIR="${RUNNER_TEMP}"/gplaykey
+          mkdir -p "${TMP_SERVICEKEY_DIR}"
+          TMP_SERVICEKEY_FILE_PATH="${TMP_SERVICEKEY_DIR}"/service_account.json
+          echo $ENCODED_SERVICE_KEY | base64 -di > "${TMP_SERVICEKEY_FILE_PATH}"
+          echo "SUPPLY_JSON_KEY=$(echo $TMP_SERVICEKEY_FILE_PATH)" >> $GITHUB_ENV
+
+      - name: Checkout
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Get the version
+        id: tagger
+        uses: jimschubert/query-tag-action@v2
+        with:
+          skip-unshallow: 'true'
+          abbrev: false
+          commit-ish: HEAD
+
+      - name: Install JDK ${{ matrix.java_version }}
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: 11
+
+      - name: Set up ruby env
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7.6
+          bundler-cache: true
+
+      - name: Assemble beta and upload to Google Play
+        if: contains(steps.tagger.outputs.tag, '-beta')
+        run: bundle exec fastlane beta
+        env:
+          STORE_PASSWORD: ${{ secrets.STORE_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+          BUGSNAG_API_KEY: ${{ secrets.BUGSNAG_API_KEY }}
+
+      - name: Assemble production and upload to Google Play
+        if: "!contains(steps.tagger.outputs.tag, '-beta')"
+        run: bundle exec fastlane production
+        env:
+          STORE_PASSWORD: ${{ secrets.STORE_PASSWORD }}
+          KEY_ALIAS: ${{ secrets.KEY_ALIAS }}
+          KEY_PASSWORD: ${{ secrets.KEY_PASSWORD }}
+          BUGSNAG_API_KEY: ${{ secrets.BUGSNAG_API_KEY }}

.gitignore

@@ -1,3 +1,14 @@
-.idea
+*.iml
 .gradle
-build/
+/local.properties
+.DS_Store
+/build
+/captures
+.externalNativeBuild
+.cxx
+/.idea/**/*
+!/.idea/codeStyles/
+!/.idea/codeStyles/**/*
+*.jks
+.local/*
+/fastlane/report.xml

.idea/codeStyles/Project.xml

@@ -0,0 +1,167 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <option name="RIGHT_MARGIN" value="120" />
+    <JSON>
+      <option name="OBJECT_WRAPPING" value="1" />
+      <option name="ARRAY_WRAPPING" value="1" />
+    </JSON>
+    <JavaCodeStyleSettings>
+      <option name="DO_NOT_WRAP_AFTER_SINGLE_ANNOTATION" value="true" />
+      <option name="IMPORT_LAYOUT_TABLE">
+        <value>
+          <package name="android" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="com" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="junit" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="net" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="org" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="java" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="javax" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="" withSubpackages="true" static="false" />
+          <emptyLine />
+          <package name="" withSubpackages="true" static="true" />
+          <emptyLine />
+        </value>
+      </option>
+    </JavaCodeStyleSettings>
+    <JetCodeStyleSettings>
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </JetCodeStyleSettings>
+    <codeStyleSettings language="JAVA">
+      <option name="KEEP_SIMPLE_BLOCKS_IN_ONE_LINE" value="true" />
+      <option name="KEEP_SIMPLE_METHODS_IN_ONE_LINE" value="true" />
+      <option name="KEEP_SIMPLE_LAMBDAS_IN_ONE_LINE" value="true" />
+      <option name="KEEP_SIMPLE_CLASSES_IN_ONE_LINE" value="true" />
+      <option name="FIELD_ANNOTATION_WRAP" value="1" />
+    </codeStyleSettings>
+    <codeStyleSettings language="JSON">
+      <indentOptions>
+        <option name="USE_TAB_CHARACTER" value="true" />
+      </indentOptions>
+    </codeStyleSettings>
+    <codeStyleSettings language="XML">
+      <indentOptions>
+        <option name="CONTINUATION_INDENT_SIZE" value="4" />
+      </indentOptions>
+      <arrangement>
+        <rules>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:android</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>xmlns:.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:id</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*:name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>name</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>style</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>^$</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>ANDROID_ATTRIBUTE_ORDER</order>
+            </rule>
+          </section>
+          <section>
+            <rule>
+              <match>
+                <AND>
+                  <NAME>.*</NAME>
+                  <XML_ATTRIBUTE />
+                  <XML_NAMESPACE>.*</XML_NAMESPACE>
+                </AND>
+              </match>
+              <order>BY_NAME</order>
+            </rule>
+          </section>
+        </rules>
+      </arrangement>
+    </codeStyleSettings>
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+      <option name="METHOD_ANNOTATION_WRAP" value="1" />
+      <option name="CLASS_ANNOTATION_WRAP" value="1" />
+      <option name="FIELD_ANNOTATION_WRAP" value="1" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gem "fastlane"

Gemfile.lock

@@ -0,0 +1,218 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    CFPropertyList (3.0.5)
+      rexml
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    artifactory (3.0.15)
+    atomos (0.1.3)
+    aws-eventstream (1.2.0)
+    aws-partitions (1.610.0)
+    aws-sdk-core (3.131.3)
+      aws-eventstream (~> 1, >= 1.0.2)
+      aws-partitions (~> 1, >= 1.525.0)
+      aws-sigv4 (~> 1.1)
+      jmespath (~> 1, >= 1.6.1)
+    aws-sdk-kms (1.58.0)
+      aws-sdk-core (~> 3, >= 3.127.0)
+      aws-sigv4 (~> 1.1)
+    aws-sdk-s3 (1.114.0)
+      aws-sdk-core (~> 3, >= 3.127.0)
+      aws-sdk-kms (~> 1)
+      aws-sigv4 (~> 1.4)
+    aws-sigv4 (1.5.1)
+      aws-eventstream (~> 1, >= 1.0.2)
+    babosa (1.0.4)
+    claide (1.1.0)
+    colored (1.2)
+    colored2 (3.1.2)
+    commander (4.6.0)
+      highline (~> 2.0.0)
+    declarative (0.0.20)
+    digest-crc (0.6.4)
+      rake (>= 12.0.0, < 14.0.0)
+    domain_name (0.5.20190701)
+      unf (>= 0.0.5, < 1.0.0)
+    dotenv (2.7.6)
+    emoji_regex (3.2.3)
+    excon (0.92.4)
+    faraday (1.10.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0)
+      faraday-multipart (~> 1.0)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.0)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
+      faraday-retry (~> 1.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-cookie_jar (0.0.7)
+      faraday (>= 0.8.0)
+      http-cookie (~> 1.0.0)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    faraday-retry (1.0.3)
+    faraday_middleware (1.2.0)
+      faraday (~> 1.0)
+    fastimage (2.2.6)
+    fastlane (2.208.0)
+      CFPropertyList (>= 2.3, < 4.0.0)
+      addressable (>= 2.8, < 3.0.0)
+      artifactory (~> 3.0)
+      aws-sdk-s3 (~> 1.0)
+      babosa (>= 1.0.3, < 2.0.0)
+      bundler (>= 1.12.0, < 3.0.0)
+      colored
+      commander (~> 4.6)
+      dotenv (>= 2.1.1, < 3.0.0)
+      emoji_regex (>= 0.1, < 4.0)
+      excon (>= 0.71.0, < 1.0.0)
+      faraday (~> 1.0)
+      faraday-cookie_jar (~> 0.0.6)
+      faraday_middleware (~> 1.0)
+      fastimage (>= 2.1.0, < 3.0.0)
+      gh_inspector (>= 1.1.2, < 2.0.0)
+      google-apis-androidpublisher_v3 (~> 0.3)
+      google-apis-playcustomapp_v1 (~> 0.1)
+      google-cloud-storage (~> 1.31)
+      highline (~> 2.0)
+      json (< 3.0.0)
+      jwt (>= 2.1.0, < 3)
+      mini_magick (>= 4.9.4, < 5.0.0)
+      multipart-post (~> 2.0.0)
+      naturally (~> 2.2)
+      optparse (~> 0.1.1)
+      plist (>= 3.1.0, < 4.0.0)
+      rubyzip (>= 2.0.0, < 3.0.0)
+      security (= 0.1.3)
+      simctl (~> 1.6.3)
+      terminal-notifier (>= 2.0.0, < 3.0.0)
+      terminal-table (>= 1.4.5, < 2.0.0)
+      tty-screen (>= 0.6.3, < 1.0.0)
+      tty-spinner (>= 0.8.0, < 1.0.0)
+      word_wrap (~> 1.0.0)
+      xcodeproj (>= 1.13.0, < 2.0.0)
+      xcpretty (~> 0.3.0)
+      xcpretty-travis-formatter (>= 0.0.3)
+    gh_inspector (1.1.3)
+    google-apis-androidpublisher_v3 (0.25.0)
+      google-apis-core (>= 0.7, < 2.a)
+    google-apis-core (0.7.0)
+      addressable (~> 2.5, >= 2.5.1)
+      googleauth (>= 0.16.2, < 2.a)
+      httpclient (>= 2.8.1, < 3.a)
+      mini_mime (~> 1.0)
+      representable (~> 3.0)
+      retriable (>= 2.0, < 4.a)
+      rexml
+      webrick
+    google-apis-iamcredentials_v1 (0.13.0)
+      google-apis-core (>= 0.7, < 2.a)
+    google-apis-playcustomapp_v1 (0.10.0)
+      google-apis-core (>= 0.7, < 2.a)
+    google-apis-storage_v1 (0.18.0)
+      google-apis-core (>= 0.7, < 2.a)
+    google-cloud-core (1.6.0)
+      google-cloud-env (~> 1.0)
+      google-cloud-errors (~> 1.0)
+    google-cloud-env (1.6.0)
+      faraday (>= 0.17.3, < 3.0)
+    google-cloud-errors (1.2.0)
+    google-cloud-storage (1.37.0)
+      addressable (~> 2.8)
+      digest-crc (~> 0.4)
+      google-apis-iamcredentials_v1 (~> 0.1)
+      google-apis-storage_v1 (~> 0.1)
+      google-cloud-core (~> 1.6)
+      googleauth (>= 0.16.2, < 2.a)
+      mini_mime (~> 1.0)
+    googleauth (1.2.0)
+      faraday (>= 0.17.3, < 3.a)
+      jwt (>= 1.4, < 3.0)
+      memoist (~> 0.16)
+      multi_json (~> 1.11)
+      os (>= 0.9, < 2.0)
+      signet (>= 0.16, < 2.a)
+    highline (2.0.3)
+    http-cookie (1.0.5)
+      domain_name (~> 0.5)
+    httpclient (2.8.3)
+    jmespath (1.6.1)
+    json (2.6.2)
+    jwt (2.4.1)
+    memoist (0.16.2)
+    mini_magick (4.11.0)
+    mini_mime (1.1.2)
+    multi_json (1.15.0)
+    multipart-post (2.0.0)
+    nanaimo (0.3.0)
+    naturally (2.2.1)
+    optparse (0.1.1)
+    os (1.1.4)
+    plist (3.6.0)
+    public_suffix (4.0.7)
+    rake (13.0.6)
+    representable (3.2.0)
+      declarative (< 0.1.0)
+      trailblazer-option (>= 0.1.1, < 0.2.0)
+      uber (< 0.2.0)
+    retriable (3.1.2)
+    rexml (3.2.5)
+    rouge (2.0.7)
+    ruby2_keywords (0.0.5)
+    rubyzip (2.3.2)
+    security (0.1.3)
+    signet (0.17.0)
+      addressable (~> 2.8)
+      faraday (>= 0.17.5, < 3.a)
+      jwt (>= 1.5, < 3.0)
+      multi_json (~> 1.10)
+    simctl (1.6.8)
+      CFPropertyList
+      naturally
+    terminal-notifier (2.0.0)
+    terminal-table (1.8.0)
+      unicode-display_width (~> 1.1, >= 1.1.1)
+    trailblazer-option (0.1.2)
+    tty-cursor (0.7.1)
+    tty-screen (0.8.1)
+    tty-spinner (0.9.3)
+      tty-cursor (~> 0.7)
+    uber (0.1.0)
+    unf (0.1.4)
+      unf_ext
+    unf_ext (0.0.8.2)
+    unicode-display_width (1.8.0)
+    webrick (1.7.0)
+    word_wrap (1.0.0)
+    xcodeproj (1.22.0)
+      CFPropertyList (>= 2.3.3, < 4.0)
+      atomos (~> 0.1.3)
+      claide (>= 1.0.2, < 2.0)
+      colored2 (~> 3.1)
+      nanaimo (~> 0.3.0)
+      rexml (~> 3.2.4)
+    xcpretty (0.3.0)
+      rouge (~> 2.0.7)
+    xcpretty-travis-formatter (1.0.1)
+      xcpretty (~> 0.2, >= 0.0.7)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  fastlane
+
+BUNDLED WITH
+   2.2.8

PRIVACY_POLICY.md

@@ -1,24 +1,42 @@
-# Privacy policy for the app `CAPod`
+# Privacy policy
+This is the privacy policy for the Android app "CAPod - Companion for AirPods".
 
-* I do not collect personal information
+## Preamble
-* I do not sell, monetize or otherwise misappropriate any collected data.
+CAPod respects your privacy.
 
-Anonymous device information may be collected in the event of a crash (see [Automatic crash reports](#automatic-crash-reports)).
+I do not collect, share or sell personal information.
+
+Send a [quick mail](mailto:support@darken.eu) if you have questions.
 
 My underlying privacy principle is the [Golden Rule](https://en.wikipedia.org/wiki/Golden_Rule).
 
-Send a [quick mail](mailto:support@darken.eu) if you have further questions.
+## Location data
+
+CAPod does not collect, share or sell location data.
+
+Location permissions are required to receive Bluetooth Low Energy (BLE) data and ebale its core functionality.
+The permission "access fine location" (`ACCESS_FINE_LOCATION`) and "access coarse location" (`ACCESS_COARSE_LOCATION`) are required to receive Bluetooth Low Energy data on Android 11 and lower.
+On Android 12+ the newer and more fine grained `BLUETOOTH_SCAN` permission is used instead.
+
+Bluetooth Low Energy is a technology that devices like AirPods use to communicate their status to nearby devices.
+CAPod requests location permissions because these permissions are required to work with Bluetooth Low Energy data.
+This is a privacy measure on Android's side because you could determine someones location by scanning for Bluetooth devices:
+If you know the physical location of a Bluetooth device (e.g. AirTags) you could use Bluetooth data to calculate your position.
+
+### Location access in the background
+
+CAPod uses the "location access in the background" permission (`ACCESS_BACKGROUND_LOCATION`) on Android 11 and older to receive Bluetooth Low Energy data while the app is in the background. This permission enables the "Show popup" and "Autoconnect" features and allows CAPod to react to nearby devices whil the app is closed.
 
 ## Automatic crash reports
 
-The app uses "Bugsnag" for automatic crash reports:
+Anonymous device information may be collected in the event of an app crash or error.
 
+To do this the app uses the service "Bugsnag":
 https://www.bugsnag.com/
 
-Bugsnags privacy policy can be found here:
+Bugsnag's privacy policy can be found here:
-
 https://docs.bugsnag.com/legal/privacy-policy/
 
-Crash reports may contain device and app related information.
+Crash reports may contain device and app related information, e.g. your phone model, Android version and app version.
 
-You can disable automatic crash reports in the app's settings.
+You can disable automatic reports in the app's settings.

README.md

@@ -1,16 +1,29 @@
+<img src="https://github.com/d4rken-org/capod/raw/main/.assets/banner.png" width="400">
+
 # Companion App for AirPods (CAPod)
+[![GitHub release (latest SemVer including pre-releases)](https://img.shields.io/github/v/release/d4rken-org/capod?include_prereleases)](https://github.com/d4rken-org/capod/releases/latest)
+[![Code tests & eval](https://github.com/d4rken-org/capod/actions/workflows/code-checks.yml/badge.svg)](https://github.com/d4rken/capod/actions/workflows/code-checks.yml)
+[![Crowdin](https://badges.crowdin.net/capod/localized.svg)](https://crowdin.com/project/capod)
+[![Github All Releases](https://img.shields.io/github/downloads/d4rken-org/capod/total.svg)](https://github.com/d4rken-org/capod/releases/latest)
 
-![Build](https://github.com/d4rken/capod/actions/workflows/android.yml/badge.svg)
+A companion app that adds support for AirPod specific features to Android:
-[![Github All Releases](https://img.shields.io/github/downloads/d4rken/capod/total.svg)](https://github.com/d4rken/capod/releases/latest)
 
-A companion app that adds support for AirPod specific features to Android.
+* Battery level for pods & cases.
+* Charging status for pods & case.
+* Additional infos about connection, microphone & case.
+* Can receive and show all nearby devices.
+* Ear detection with automatic play/pause.
+* Automatically connect phone & AirPods.
+* Show popup when case is opened.
+* Support for Wear OS
 
-<img src="https://github.com/d4rken/capod/raw/master/.assets/banner.png" width="400">
+CAPod is ad-free. Some additional features require an in-app purchase.
 
 Currently supported models:
 
-* AirPods Gen1
+* AirPods 1. Generation
-* AirPods Gen2
+* AirPods 2. Generation
+* AirPods 3. Generation
 * AirPods Pro
 * AirPods Max
 * Power Beats Pro
@@ -20,28 +33,26 @@ Currently supported models:
 * Beats X
 * Beats Flex
 
-## Support the project
-
-* Buy the CAPod Pro In-App purchase on [Google Play](https://play.google.com/store/apps/details?id=eu.darken.capod)
-* Help translate CAPod [on Crowdin](https://crowdin.com/project/airpod-companion)
-* [Buy me a coffee](https://www.buymeacoffee.com/tydarken)
-
 ## Download
 
 * [Google Play](https://play.google.com/store/apps/details?id=eu.darken.capod)
-* [GitHub](https://github.com/d4rken/capod/releases/latest)
+* [GitHub](https://github.com/d4rken-org/capod/releases/latest)
+* [IzzyOnDroid](https://apt.izzysoft.de/fdroid/index/apk/eu.darken.capod)
+
+## Support the project
+
+* Buy the CAPod Pro In-App purchase on [Google Play](https://play.google.com/store/apps/details?id=eu.darken.capod)
+* [Sponsor development](https://github.com/sponsors/d4rken) on GitHub
+* Help translate CAPod [on Crowdin](https://crowdin.com/project/capod)
 
 ## Get help
 
-* [Github Issues](https://github.com/d4rken/capod/issues)
+* [Github Issues](https://github.com/d4rken-org/capod/issues)
 * [Discord](https://discord.gg/vHubYPp)
 
 ## Screenshots
 
-<img src="https://github.com/d4rken/capod/raw/master/.assets/screenshots/1.png" width="200">
+<img src="https://github.com/d4rken-org/capod/raw/main/.assets/screenshots/1.png" width="200"><img src="https://github.com/d4rken-org/capod/raw/main/.assets/screenshots/2.png" width="200"><img src="https://github.com/d4rken-org/capod/raw/main/.assets/screenshots/3.png" width="200"><img src="https://github.com/d4rken-org/capod/raw/main/.assets/screenshots/4.png" width="200">
-<img src="https://github.com/d4rken/capod/raw/master/.assets/screenshots/2.png" width="200">
-<img src="https://github.com/d4rken/capod/raw/master/.assets/screenshots/3.png" width="200">
-<img src="https://github.com/d4rken/capod/raw/master/.assets/screenshots/4.png" width="200">
 
 ## Thanks to
 

app-common/.gitignore

@@ -0,0 +1 @@
+/build

app-common/build.gradle.kts

@@ -0,0 +1,100 @@
+plugins {
+    id("com.android.library")
+    id("kotlin-android")
+    id("kotlin-kapt")
+    id("kotlin-parcelize")
+}
+apply(plugin = "dagger.hilt.android.plugin")
+
+android {
+    compileSdk = ProjectConfig.compileSdk
+
+    defaultConfig {
+        minSdk = ProjectConfig.minSdk
+        targetSdk = ProjectConfig.targetSdk
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+        consumerProguardFiles("consumer-rules.pro")
+
+        buildConfigField("Long", "VERSION_CODE", "${ProjectConfig.Version.code}L")
+        buildConfigField("String", "VERSION_NAME", "\"${ProjectConfig.Version.name}\"")
+        buildConfigField("String", "APPLICATION_ID", "\"${ProjectConfig.packageName}\"")
+        buildConfigField("String", "GITSHA", "\"${lastCommitHash()}\"")
+        buildConfigField("String", "BUILDTIME", "\"${buildTime()}\"")
+    }
+
+    buildFeatures {
+        viewBinding = true
+    }
+
+    compileOptions {
+        isCoreLibraryDesugaringEnabled = true
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    kotlinOptions {
+        jvmTarget = "1.8"
+        freeCompilerArgs = freeCompilerArgs + listOf(
+            "-opt-in=kotlin.ExperimentalStdlibApi",
+            "-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi",
+            "-opt-in=kotlin.time.ExperimentalTime",
+            "-opt-in=kotlin.ExperimentalUnsignedTypes",
+        )
+    }
+
+    flavorDimensions.add("version")
+    productFlavors {
+        create("foss") {
+            dimension = "version"
+        }
+        create("gplay") {
+            dimension = "version"
+        }
+    }
+
+    buildTypes {
+        val customProguardRules = fileTree(File("../proguard")) {
+            include("*.pro")
+        }
+        debug {
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+            proguardFiles(*customProguardRules.toList().toTypedArray())
+            proguardFiles("proguard-rules-debug.pro")
+        }
+        create("beta") {
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+            proguardFiles(*customProguardRules.toList().toTypedArray())
+        }
+        release {
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+            proguardFiles(*customProguardRules.toList().toTypedArray())
+        }
+    }
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+        tasks.withType<Test> {
+            useJUnitPlatform()
+        }
+    }
+}
+
+dependencies {
+    coreLibraryDesugaring("com.android.tools:desugar_jdk_libs:1.1.5")
+
+    addBaseAndroid()
+    addBaseAndroidUi()
+    addBaseKotlin()
+    addDagger()
+    addMoshi()
+    addBaseWorkManager()
+    addNavigation()
+
+    addTesting()
+
+    implementation("com.bugsnag:bugsnag-android:5.9.2")
+
+}

app-common/proguard-rules.pro

@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile

app-common/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="eu.darken.capod.common">
+
+</manifest>

app-common/src/main/java/eu/darken/capod/common/BuildConfigWrap.kt

@@ -0,0 +1,45 @@
+package eu.darken.capod.common
+
+
+// Can't be const because that prevents them from being mocked in tests
+@Suppress("MayBeConstant")
+object BuildConfigWrap {
+    val DEBUG: Boolean = BuildConfig.DEBUG
+
+    val BUILD_TYPE: BuildType = when (val typ = BuildConfig.BUILD_TYPE) {
+        "debug" -> BuildType.DEV
+        "beta" -> BuildType.BETA
+        "release" -> BuildType.RELEASE
+        else -> throw IllegalArgumentException("Unknown buildtype: $typ")
+    }
+
+    enum class BuildType {
+        DEV,
+        BETA,
+        RELEASE,
+        ;
+    }
+
+    val FLAVOR: Flavor = when (val flav = BuildConfig.FLAVOR) {
+        "gplay" -> Flavor.GPLAY
+        "foss" -> Flavor.FOSS
+        else -> throw IllegalStateException("Unknown flavor: $flav")
+    }
+
+    enum class Flavor {
+        GPLAY,
+        FOSS,
+        ;
+    }
+
+    val APPLICATION_ID: String = BuildConfig.APPLICATION_ID
+
+    val VERSION_CODE: Long = BuildConfig.VERSION_CODE.toLong()
+    val VERSION_NAME: String = BuildConfig.VERSION_NAME
+    val GIT_SHA: String = BuildConfig.GITSHA
+    val BUILDTIME: String = BuildConfig.BUILDTIME
+
+    val VERSION_DESCRIPTION_LONG: String = "v$VERSION_NAME ($VERSION_CODE) [$GIT_SHA] ${FLAVOR}_$BUILD_TYPE"
+    val VERSION_DESCRIPTION_SHORT: String = "v$VERSION_NAME [$GIT_SHA] $FLAVOR"
+    val VERSION_DESCRIPTION_TINY: String = "v$VERSION_NAME"
+}

app-common/src/main/java/eu/darken/capod/common/BuildWrap.kt

@@ -13,6 +13,6 @@ object BuildWrap {
     }
 }
 
-fun hasApiLevel(level: Int): Boolean = BuildWrap.VERSION.SDK_INT >= level
+fun hasApiLevel(level: Int): Boolean = BuildWrap.VersionWrap.SDK_INT >= level
 
-fun withinApiLevel(start: Int, end: Int): Boolean = BuildWrap.VERSION.SDK_INT in start..end
+fun withinApiLevel(start: Int, end: Int): Boolean = BuildWrap.VersionWrap.SDK_INT in start..end

app-common/src/main/java/eu/darken/capod/common/ByteArrayExtensions.kt

@@ -0,0 +1,20 @@
+package eu.darken.capod.common
+
+import java.util.*
+
+fun Byte.toHex(): String = String.format("%02X", this)
+fun UByte.toHex(): String = this.toByte().toHex()
+
+val Byte.upperNibble get() = (this.toInt() shr 4 and 0b1111).toShort()
+val Byte.lowerNibble get() = (this.toInt() and 0b1111).toShort()
+val UByte.upperNibble get() = (this.toInt() shr 4 and 0b1111).toUShort()
+val UByte.lowerNibble get() = (this.toInt() and 0b1111).toUShort()
+
+fun Byte.isBitSet(pos: Int): Boolean = BitSet.valueOf(arrayOf(this).toByteArray()).get(pos)
+fun UByte.isBitSet(pos: Int): Boolean = this.toByte().isBitSet(pos)
+
+fun Short.isBitSet(pos: Int): Boolean = this.toByte().isBitSet(pos)
+fun UShort.isBitSet(pos: Int): Boolean = this.toShort().isBitSet(pos)
+
+fun UShort.toBinaryString(): String = Integer.toBinaryString(this.toInt()).padStart(4, '0')
+fun UByte.toBinaryString(): String = Integer.toBinaryString(this.toInt()).padStart(8, '0')

app-common/src/main/java/eu/darken/capod/common/PrivacyPolicy.kt

@@ -0,0 +1,5 @@
+package eu.darken.capod.common
+
+object PrivacyPolicy {
+    const val URL = "https://github.com/d4rken-org/capod/blob/main/PRIVACY_POLICY.md"
+}

app-common/src/main/java/eu/darken/capod/common/bluetooth/BleScanResult.kt

@@ -3,14 +3,19 @@ package eu.darken.capod.common.bluetooth
 import android.bluetooth.le.ScanResult
 import android.os.Parcelable
 import androidx.core.util.forEach
+import com.squareup.moshi.Json
+import com.squareup.moshi.JsonClass
 import kotlinx.parcelize.Parcelize
+import java.time.Instant
 
 @Parcelize
+@JsonClass(generateAdapter = true)
 data class BleScanResult(
-    val address: String,
+    @Json(name = "receivedAt") val receivedAt: Instant,
-    val rssi: Int,
+    @Json(name = "address") val address: String,
-    val generatedAtNanos: Long,
+    @Json(name = "rssi") val rssi: Int,
-    val manufacturerSpecificData: Map<Int, ByteArray>
+    @Json(name = "generatedAtNanos") val generatedAtNanos: Long,
+    @Json(name = "manufacturerSpecificData") val manufacturerSpecificData: Map<Int, ByteArray>
 ) : Parcelable {
 
     fun getManufacturerSpecificData(id: Int): ByteArray? = manufacturerSpecificData[id]
@@ -25,6 +30,7 @@ data class BleScanResult(
 
     companion object {
         fun fromScanResult(scanResult: ScanResult) = BleScanResult(
+            receivedAt = Instant.now(),
             address = scanResult.device.address,
             rssi = scanResult.rssi,
             generatedAtNanos = scanResult.timestampNanos,

app-common/src/main/java/eu/darken/capod/common/bluetooth/BleScanner.kt

@@ -0,0 +1,151 @@
+package eu.darken.capod.common.bluetooth
+
+import android.annotation.SuppressLint
+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 dagger.hilt.android.qualifiers.ApplicationContext
+import eu.darken.capod.common.debug.logging.Logging.Priority.*
+import eu.darken.capod.common.debug.logging.log
+import eu.darken.capod.common.debug.logging.logTag
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class BleScanner @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val bluetoothManager: BluetoothManager2,
+    private val fakeBleData: FakeBleData,
+) {
+
+    @SuppressLint("MissingPermission") fun scan(
+        filters: Set<ScanFilter>,
+        scannerMode: ScannerMode,
+        compatMode: Boolean,
+    ): Flow<List<BleScanResult>> = callbackFlow {
+        log(TAG, VERBOSE) { "scan(filters=$filters, scannerMode=$scannerMode, compatMode=$compatMode)" }
+        if (compatMode) log(TAG, WARN) { "Using compatibilityMode!" }
+
+        val adapter = bluetoothManager.adapter
+
+        val supportsOffloadFiltering = adapter.isOffloadedFilteringSupported.also {
+            log(TAG, if (it) DEBUG else WARN) { "isOffloadedFilteringSupported=$it" }
+        } && !compatMode
+
+        val supportsOffloadBatching = adapter.isOffloadedScanBatchingSupported.also {
+            log(TAG, if (it) DEBUG else WARN) { "isOffloadedScanBatchingSupported=$it" }
+        } && !compatMode
+
+        val scanner = bluetoothManager.scanner
+
+        val callback = object : ScanCallback() {
+            var lastScanAt = System.currentTimeMillis()
+            override fun onScanResult(callbackType: Int, result: ScanResult) {
+                log(TAG, VERBOSE) {
+                    val delay = System.currentTimeMillis() - lastScanAt
+                    lastScanAt = System.currentTimeMillis()
+                    "onScanResult(delay=${delay}ms, callbackType=$callbackType, result=$result)"
+                }
+                val toSend = if (
+                    supportsOffloadFiltering
+                    || filters.isEmpty()
+                    || filters.any { it.matchesSafe(result) }
+                ) {
+                    listOf(BleScanResult.fromScanResult(result))
+                } else {
+                    log(TAG, VERBOSE) { "Manual filtering: No match for $result" }
+                    emptyList()
+                }
+                trySend(toSend)
+            }
+
+            override fun onBatchScanResults(results: MutableList<ScanResult>) {
+                log(TAG, VERBOSE) {
+                    val delay = System.currentTimeMillis() - lastScanAt
+                    lastScanAt = System.currentTimeMillis()
+                    "onBatchScanResults(delay=${delay}ms, results=$results)"
+                }
+
+                val toSend = results
+                    .filter { result ->
+                        val passed = when {
+                            supportsOffloadFiltering -> true
+                            filters.isEmpty() -> true
+                            else -> filters.any { it.matches(result) }
+                        }
+                        if (!passed) log(TAG, VERBOSE) { "Manually filtered $result" }
+                        passed
+                    }
+                    .map { BleScanResult.fromScanResult(it) }
+                trySend(toSend)
+            }
+
+            override fun onScanFailed(errorCode: Int) {
+                log(TAG, WARN) { "onScanFailed(errorCode=$errorCode)" }
+            }
+        }
+
+
+        val settings = ScanSettings.Builder().apply {
+            setScanMode(
+                when (scannerMode) {
+                    ScannerMode.LOW_POWER -> ScanSettings.SCAN_MODE_LOW_POWER
+                    ScannerMode.BALANCED -> ScanSettings.SCAN_MODE_BALANCED
+                    ScannerMode.LOW_LATENCY -> ScanSettings.SCAN_MODE_LOW_LATENCY
+                }
+            )
+            if (supportsOffloadBatching) {
+                setReportDelay(
+                    when (scannerMode) {
+                        ScannerMode.LOW_POWER -> 2000L
+                        ScannerMode.BALANCED -> 1000L
+                        ScannerMode.LOW_LATENCY -> 500L
+                    }
+                )
+            }
+        }.build()
+
+        log(TAG, VERBOSE) { "Settings created for offloaded filtering: $settings" }
+
+        val flushJob = launch {
+            log(TAG) { "Flush job launched" }
+            while (isActive) {
+                // Can undercut the minimum setReportDelay(), e.g. 5000ms on a Pixel5@12
+                log(TAG, VERBOSE) { "Flushing scan results." }
+                adapter.bluetoothLeScanner.flushPendingScanResults(callback)
+                when (scannerMode) {
+                    ScannerMode.LOW_POWER -> break
+                    ScannerMode.BALANCED -> delay(1000)
+                    ScannerMode.LOW_LATENCY -> delay(500)
+                }
+            }
+        }
+
+        scanner.startScan(
+            if (supportsOffloadFiltering) filters.toList() else listOf(ScanFilter.Builder().build()),
+            settings,
+            callback
+        )
+        log(TAG) { "BleScanner started (filters=$filters, settings=$settings)" }
+
+        awaitClose {
+            flushJob.cancel()
+            scanner.stopScan(callback)
+            log(TAG) { "BleScanner stopped" }
+        }
+    }
+        .map { fakeBleData.maybeAddfakeData(it) }
+
+    companion object {
+        private val TAG = logTag("Bluetooth", "BleScanner")
+    }
+}

app-common/src/main/java/eu/darken/capod/common/bluetooth/BluetoothExtensions.kt

@@ -0,0 +1,26 @@
+package eu.darken.capod.common.bluetooth
+
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.le.ScanFilter
+import android.bluetooth.le.ScanResult
+import android.os.ParcelUuid
+import eu.darken.capod.common.debug.logging.asLog
+import eu.darken.capod.common.debug.logging.log
+
+fun BluetoothDevice.hasFeature(uuid: ParcelUuid): Boolean {
+    return uuids?.contains(uuid) ?: false
+}
+
+/**
+ * java.lang.NullPointerException: Attempt to invoke virtual method 'java.lang.Object android.util.SparseArray.get(int)' on a null object reference
+ *  at android.bluetooth.le.ScanRecord.getManufacturerSpecificData(ScanRecord.java:118)
+ *  at android.bluetooth.le.ScanFilter.matches(ScanFilter.java:369)
+ * ZenFone Max Pro M1 (ZB602KL) (WW) / Max Pro M1 (ZB601KL) (IN) (ZB602KL), Android 9, PKQ1.WW_Phone-16.2017.2009.087-20200826
+ * Intel Gemini Lake Chromebook (octopus), Android 9, R99-14469.59.0 release-keys
+ */
+fun ScanFilter.matchesSafe(scanResult: ScanResult): Boolean = try {
+    matches(scanResult)
+} catch (e: NullPointerException) {
+    log { "AOSP error: ${e.asLog()}" }
+    false
+}

app-common/src/main/java/eu/darken/capod/common/bluetooth/BluetoothManager2.kt

@@ -0,0 +1,184 @@
+package eu.darken.capod.common.bluetooth
+
+import android.bluetooth.*
+import android.bluetooth.le.BluetoothLeScanner
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.ParcelUuid
+import dagger.hilt.android.qualifiers.ApplicationContext
+import eu.darken.capod.common.coroutine.DispatcherProvider
+import eu.darken.capod.common.debug.Bugs
+import eu.darken.capod.common.debug.logging.Logging.Priority.*
+import eu.darken.capod.common.debug.logging.log
+import eu.darken.capod.common.debug.logging.logTag
+import eu.darken.capod.pods.core.apple.protocol.ContinuityProtocol
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.flow.*
+import kotlinx.coroutines.launch
+import java.io.IOException
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class BluetoothManager2 @Inject constructor(
+    private val manager: BluetoothManager,
+    @ApplicationContext private val context: Context,
+    private val dispatcherProvider: DispatcherProvider,
+) {
+
+    val adapter: BluetoothAdapter
+        get() = manager.adapter
+
+    val scanner: BluetoothLeScanner
+        get() = adapter.bluetoothLeScanner
+            ?: throw IllegalStateException("Bluetooth is disabled or permissiong missing")
+
+    val isBluetoothEnabled: Flow<Boolean> = callbackFlow {
+        send(manager.adapter?.isEnabled ?: false)
+
+        val receiver = object : BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                if (BluetoothAdapter.ACTION_STATE_CHANGED != intent.action) {
+                    log(TAG) { "Unknown BluetoothAdapter action: $intent" }
+                    return
+                }
+
+                val value = when (intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, -1)) {
+                    BluetoothAdapter.STATE_OFF -> false
+                    BluetoothAdapter.STATE_ON -> true
+                    else -> false
+                }
+
+                trySend(value)
+            }
+        }
+        context.registerReceiver(receiver, IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED))
+        awaitClose { context.unregisterReceiver(receiver) }
+    }
+
+    fun getBluetoothProfile(profile: Int = BluetoothProfile.HEADSET): Flow<BluetoothProfile2> = callbackFlow {
+        log(TAG, VERBOSE) { "getBluetoothProfile(profile=$profile)" }
+
+        var profileProxy: BluetoothProfile2? = null
+        manager.adapter.getProfileProxy(context, object : BluetoothProfile.ServiceListener {
+            override fun onServiceConnected(profile: Int, proxy: BluetoothProfile) {
+                log(TAG, VERBOSE) { "onServiceConnected(profile=$profile, proxy=$proxy)" }
+
+                profileProxy = BluetoothProfile2(
+                    profileType = profile,
+                    profileProxy = proxy,
+                ).also { trySend(it) }
+            }
+
+            override fun onServiceDisconnected(profile: Int) {
+                log(TAG, WARN) { "onServiceDisconnected(profile=$profile" }
+                close(IOException("BluetoothProfile service disconnected (profile=$profile)"))
+            }
+
+        }, profile)
+
+        awaitClose {
+            log(TAG) { "Closing BluetoothProfile: $profileProxy" }
+            profileProxy?.let {
+                manager.adapter.closeProfileProxy(it.profileType, it.proxy)
+            }
+        }
+    }
+
+
+    private fun monitorDevicesForProfile(
+        profile: Int = BluetoothProfile.HEADSET
+    ): Flow<Set<BluetoothDevice>> = getBluetoothProfile(profile).flatMapLatest { bluetoothProfile ->
+        callbackFlow {
+            log(TAG, VERBOSE) { "connectedDevices(profile=$profile) starting" }
+            trySend(bluetoothProfile.connectedDevices)
+
+            val filter = IntentFilter().apply {
+                addAction(BluetoothDevice.ACTION_ACL_CONNECTED)
+                addAction(BluetoothDevice.ACTION_ACL_DISCONNECTED)
+            }
+
+            val handlerThread = HandlerThread("BluetoothEventReceiver").apply {
+                start()
+            }
+            val handler = Handler(handlerThread.looper)
+
+            val receiver: BroadcastReceiver = object : BroadcastReceiver() {
+                override fun onReceive(context: Context, intent: Intent) {
+                    log(TAG, VERBOSE) { "Bluetooth event (intent=$intent, extras=${intent.extras})" }
+                    val action = intent.action
+                    if (action == null) {
+                        log(TAG, ERROR) { "Bluetooth event without action, how did we get this?" }
+                        return
+                    }
+                    val device = intent.getParcelableExtra<BluetoothDevice?>(BluetoothDevice.EXTRA_DEVICE)
+                    if (device == null) {
+                        log(TAG, ERROR) { "Connection event is missing EXTRA_DEVICE: ${intent.extras}" }
+                        return
+                    }
+
+                    this@callbackFlow.launch {
+                        val currentDevices = bluetoothProfile.connectedDevices
+
+                        when (action) {
+                            BluetoothDevice.ACTION_ACL_CONNECTED -> {
+                                log(TAG) { "Adding $device to current devices $currentDevices" }
+                                trySend(currentDevices.plus(device))
+                            }
+                            BluetoothDevice.ACTION_ACL_DISCONNECTED -> {
+                                log(TAG) { "Removing $device from current devices $currentDevices" }
+                                trySend(currentDevices.minus(device))
+                            }
+                        }
+                    }
+                }
+            }
+            context.registerReceiver(receiver, filter, null, handler)
+
+            awaitClose {
+                log(TAG, VERBOSE) { "connectedDevices(profile=$profile) closed." }
+                context.unregisterReceiver(receiver)
+            }
+        }
+    }
+
+    fun connectedDevices(
+        featureFilter: Set<ParcelUuid> = ContinuityProtocol.BLE_FEATURE_UUIDS
+    ): Flow<List<BluetoothDevice>> = isBluetoothEnabled
+        .flatMapLatest { monitorDevicesForProfile(BluetoothProfile.HEADSET) }
+        .map { devices ->
+            devices.filter { device ->
+                featureFilter.any { feature ->
+                    device.hasFeature(feature)
+                }
+            }
+        }
+
+    fun bondedDevices(): Set<BluetoothDevice> = adapter.bondedDevices
+
+    suspend fun nudgeConnection(device: BluetoothDevice): Boolean = getBluetoothProfile().map { bluetoothProfile ->
+        try {
+            log(TAG) { "Nudging Android connection to $device" }
+
+            val connectMethod = BluetoothHeadset::class.java.getDeclaredMethod(
+                "connect", BluetoothDevice::class.java
+            ).apply { isAccessible = true }
+
+            connectMethod.invoke(bluetoothProfile.proxy, device)
+
+            log(TAG) { "Nudged connection to $device" }
+            true
+        } catch (e: Exception) {
+            Bugs.report(tag = TAG, "BluetoothHeadset.connect(device) is unavailable", exception = e)
+            false
+        }
+    }.first()
+
+    companion object {
+        private val TAG = logTag("Bluetooth", "Manager2")
+    }
+}

app-common/src/main/java/eu/darken/capod/common/bluetooth/BluetoothProfile2.kt

@@ -0,0 +1,16 @@
+package eu.darken.capod.common.bluetooth
+
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothProfile
+
+data class BluetoothProfile2(
+    internal val profileType: Int,
+    private val profileProxy: BluetoothProfile,
+) {
+
+    val proxy: BluetoothProfile
+        get() = profileProxy
+
+    val connectedDevices: Set<BluetoothDevice>
+        get() = proxy.connectedDevices.toSet()
+}

app-common/src/main/java/eu/darken/capod/common/bluetooth/FakeBleData.kt

@@ -0,0 +1,124 @@
+package eu.darken.capod.common.bluetooth
+
+import dagger.Reusable
+import eu.darken.capod.common.SystemClockWrap
+import eu.darken.capod.common.debug.autoreport.DebugSettings
+import java.time.Instant
+import javax.inject.Inject
+import kotlin.random.Random
+
+@Reusable
+class FakeBleData @Inject constructor(
+    private val debugSettings: DebugSettings,
+) {
+
+    fun maybeAddfakeData(originals: List<BleScanResult>): List<BleScanResult> {
+        if (!debugSettings.showFakeData.value) return originals
+        return originals + getFakeData()
+    }
+
+    fun getFakeData(): Collection<BleScanResult> {
+        val fakeDevices = mutableListOf<BleScanResult>()
+        // AirPods Gen1
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "78:73:AF:B4:85:22",
+            rssi = Random.nextInt(100) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 100,
+            manufacturerSpecificData = mapOf(76 to "07 19 01 02 20 75 AA B6 31 00 05 9C 5A A4 5D C0 2C A0 B4 6F B9 ED 8E CE 03 97 CA".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+
+        // AirPods Gen2
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "78:73:FF:B4:85:5E",
+            rssi = Random.nextInt(100) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 100,
+            manufacturerSpecificData = mapOf(76 to "07 19 01 0F 20 75 AA B6 31 00 05 9C 5A A4 5D C0 2C A0 B4 6F B9 ED 8E CE 03 97 CA".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+
+        // AirPods Gen3
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "4E:9E:D1:49:D2:6D",
+            rssi = Random.nextInt(15, 75) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 200,
+            manufacturerSpecificData = mapOf(76 to "07 19 01 13 20 55 AF 56 31 00 06 6F E4 DF 10 AF 10 60 81 03 3B 76 D9 C7 11 22 88".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+        // AirPods Max
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "7E:E5:C7:65:D2:B5",
+            rssi = Random.nextInt(15, 75) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 300,
+            manufacturerSpecificData = mapOf(76 to "07 19 01 0A 20 02 05 80 04 0F 44 A7 60 9B F8 3C FD B1 D8 1C 61 EA 82 60 A3 2C 4E".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+        // BeatsFlex
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "5E:9E:D1:49:D2:6D",
+            rssi = Random.nextInt(15, 75) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 400,
+            manufacturerSpecificData = mapOf(76 to "07 19 01 10 20 0A F4 8F 00 01 00 C4 71 9F 9C EF A2 E3 BA 66 FE 1D 45 9F C9 2F A0".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+
+        // Tws i99999
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "5E:9E:D1:29:D2:6D",
+            rssi = Random.nextInt(15, 75) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 400,
+            manufacturerSpecificData = mapOf(76 to "07 13 01 02 20 71 AA 37 32 00 10 00 64 64 FF 00 00 00 00 00 00".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+
+        // Unknown Device
+        BleScanResult(
+            receivedAt = Instant.now(),
+            address = "6E:9E:D1:49:D2:6D",
+            rssi = Random.nextInt(15, 75) * -1,
+            generatedAtNanos = SystemClockWrap.elapsedRealtimeNanos + 500,
+            manufacturerSpecificData = mapOf(76 to "07 19 01 FF 20 0A F4 8F 00 01 00 C4 71 9F 9C EF A2 E3 BA 66 FE 1D 45 9F C9 2F A0".hexToByteArray())
+        ).run {
+            if (Random.nextBoolean()) {
+                fakeDevices.add(this)
+            }
+        }
+
+        return fakeDevices
+    }
+
+
+    private fun String.hexToByteArray(): ByteArray {
+        val trimmed = this
+            .replace(" ", "")
+            .replace(">", "")
+            .replace("<", "")
+        require(trimmed.length % 2 == 0) { "Not a HEX string" }
+        return trimmed.chunked(2).map { it.toInt(16).toByte() }.toByteArray()
+    }
+
+}

app-common/src/main/java/eu/darken/capod/common/bluetooth/ScannerMode.kt

@@ -1,9 +1,9 @@
-package eu.darken.capod.main.core
+package eu.darken.capod.common.bluetooth
 
 import androidx.annotation.StringRes
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
-import eu.darken.capod.R
+import eu.darken.capod.common.R
 
 @JsonClass(generateAdapter = false)
 enum class ScannerMode(

app-common/src/main/java/eu/darken/capod/common/debug/autoreport/AutoReporting.kt

@@ -28,12 +28,12 @@ class AutoReporting @Inject constructor(
 ) {
 
     fun setup() {
-        val isEnabled = debugSettings.isAutoReportEnabled.value
+        val isEnabled = debugSettings.isAutoReportingEnabled.value
         log(TAG) { "setup(): isEnabled=$isEnabled" }
 
         try {
             val bugsnagConfig = Configuration.load(context).apply {
-                if (debugSettings.isAutoReportEnabled.value) {
+                if (debugSettings.isAutoReportingEnabled.value) {
                     Logging.install(bugsnagLogger.get())
                     setUser(installId.id, null, null)
                     autoTrackSessions = true

app-common/src/main/java/eu/darken/capod/common/debug/autoreport/DebugSettings.kt

@@ -4,8 +4,9 @@ import android.content.Context
 import android.content.SharedPreferences
 import androidx.preference.PreferenceDataStore
 import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.androidstarter.common.preferences.Settings
+import eu.darken.capod.common.BuildConfigWrap
 import eu.darken.capod.common.preferences.PreferenceStoreMapper
+import eu.darken.capod.common.preferences.Settings
 import eu.darken.capod.common.preferences.createFlowPreference
 import javax.inject.Inject
 import javax.inject.Singleton
@@ -17,15 +18,21 @@ class DebugSettings @Inject constructor(
 
     override val preferences: SharedPreferences = context.getSharedPreferences("settings_debug", Context.MODE_PRIVATE)
 
-    val isAutoReportEnabled = preferences.createFlowPreference("debug.bugreport.automatic.enabled", true)
+    val isAutoReportingEnabled = preferences.createFlowPreference(
-
+        key = "debug.bugreport.automatic.enabled",
+        // Reporting is opt-out for gplay, and opt-in for github builds
+        defaultValue = BuildConfigWrap.FLAVOR == BuildConfigWrap.Flavor.GPLAY
+    )
     val isDebugModeEnabled = preferences.createFlowPreference("debug.mode.enabled", false)
 
     val showFakeData = preferences.createFlowPreference("debug.fakedata.enabled", false)
 
+    val showUnfiltered = preferences.createFlowPreference("debug.blescanner.unfiltered.enabled", false)
+
     override val preferenceDataStore: PreferenceDataStore = PreferenceStoreMapper(
         isDebugModeEnabled,
         showFakeData,
+        showUnfiltered,
     )
 
 }

app-common/src/main/java/eu/darken/capod/common/debug/autoreport/bugsnag/BugsnagErrorHandler.kt

@@ -6,7 +6,6 @@ import android.content.pm.PackageManager
 import com.bugsnag.android.Event
 import com.bugsnag.android.OnErrorCallback
 import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.capod.BuildConfig
 import eu.darken.capod.common.BuildConfigWrap
 import eu.darken.capod.common.debug.autoreport.DebugSettings
 import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
@@ -26,13 +25,13 @@ class BugsnagErrorHandler @Inject constructor(
         bugsnagLogger.injectLog(event)
 
         TAB_APP.also { tab ->
-            event.addMetadata(tab, "gitSha", BuildConfig.GITSHA)
+            event.addMetadata(tab, "gitSha", BuildConfigWrap.GIT_SHA)
-            event.addMetadata(tab, "buildTime", BuildConfig.BUILDTIME)
+            event.addMetadata(tab, "buildTime", BuildConfigWrap.BUILDTIME)
 
             context.tryFormattedSignature()?.let { event.addMetadata(tab, "signatures", it) }
         }
 
-        return debugSettings.isAutoReportEnabled.value && !BuildConfigWrap.DEBUG
+        return debugSettings.isAutoReportingEnabled.value && !eu.darken.capod.common.BuildConfigWrap.DEBUG
     }
 
     companion object {

app-common/src/main/java/eu/darken/capod/common/error/LocalizedError.kt

@@ -1,7 +1,7 @@
 package eu.darken.capod.common.error
 
 import android.content.Context
-import eu.darken.capod.R
+import eu.darken.capod.common.R
 
 interface HasLocalizedError {
     fun getLocalizedError(context: Context): LocalizedError

app-common/src/main/java/eu/darken/capod/common/flow/DynamicStateFlow.kt

@@ -25,7 +25,8 @@ class DynamicStateFlow<T>(
     loggingTag: String? = null,
     parentScope: CoroutineScope,
     coroutineContext: CoroutineContext = parentScope.coroutineContext,
-    private val startValueProvider: suspend CoroutineScope.() -> T
+    private val onRelease: CoroutineScope.(T) -> Unit = {},
+    private val startValueProvider: suspend CoroutineScope.() -> T,
 ) {
     private val lTag = loggingTag?.let { "$it:DSFlow" }
 
@@ -47,6 +48,12 @@ class DynamicStateFlow<T>(
             }
         }
 
+        invokeOnClose {
+            lTag?.let { log(it, VERBOSE) { "invokeOnClose executing..." } }
+            onRelease(currentValue)
+            lTag?.let { log(it, VERBOSE) { "internal channelFlow finished." } }
+        }
+
         updateActions.collect { update ->
             currentValue = valueGuard.withLock {
                 try {
@@ -68,12 +75,11 @@ class DynamicStateFlow<T>(
                 }
             }
         }
-
-        lTag?.let { log(it, VERBOSE) { "internal channelFlow finished." } }
     }
 
     private val internalFlow = producer
         .onStart { lTag?.let { log(it, VERBOSE) { "Internal onStart" } } }
+//        .onEach { value -> lTag?.let { log(it, VERBOSE) { "New value: $value" } } }
         .onCompletion { err ->
             when {
                 err is CancellationException -> {

app-common/src/main/java/eu/darken/capod/common/flow/FlowExtensions.kt

@@ -34,13 +34,13 @@ fun <T : Any> Flow<T>.shareLatest(
     )
     .filterNotNull()
 
-fun <T : Any> Flow<T>.replayingShare(scope: CoroutineScope) = this.shareIn(
+fun <T : Any?> Flow<T>.replayingShare(scope: CoroutineScope) = this.shareIn(
     scope = scope,
     replay = 1,
     started = SharingStarted.WhileSubscribed(replayExpiration = Duration.ZERO)
 )
 
-internal fun <T> Flow<T>.withPrevious(): Flow<Pair<T?, T>> = this
+fun <T> Flow<T>.withPrevious(): Flow<Pair<T?, T>> = this
     .scan(Pair<T?, T?>(null, null)) { previous, current -> Pair(previous.second, current) }
     .drop(1)
     .map {

app-common/src/main/java/eu/darken/capod/common/permissions/Permission.kt

@@ -6,8 +6,8 @@ import android.os.Build
 import android.os.PowerManager
 import androidx.annotation.StringRes
 import androidx.core.content.ContextCompat
-import eu.darken.capod.R
 import eu.darken.capod.common.BuildConfigWrap
+import eu.darken.capod.common.R
 import eu.darken.capod.common.withinApiLevel
 
 enum class Permission(
@@ -62,6 +62,15 @@ enum class Permission(
             val pwm = it.getSystemService(Context.POWER_SERVICE) as PowerManager
             pwm.isIgnoringBatteryOptimizations(BuildConfigWrap.APPLICATION_ID)
         },
+    ),
+    SYSTEM_ALERT_WINDOW(
+        minApiLevel = Build.VERSION_CODES.BASE,
+        labelRes = R.string.permission_system_alert_window_label,
+        descriptionRes = R.string.permission_system_alert_window_description,
+        permissionId = "android.permission.SYSTEM_ALERT_WINDOW",
+        isGranted = {
+            android.provider.Settings.canDrawOverlays(it)
+        },
     )
 }
 

app-common/src/main/java/eu/darken/capod/common/preferences/FlowPreference.kt

@@ -2,7 +2,7 @@ package eu.darken.capod.common.preferences
 
 import android.content.SharedPreferences
 import androidx.core.content.edit
-import eu.darken.capod.common.debug.logging.Logging.Priority.*
+import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
 import eu.darken.capod.common.debug.logging.log
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.MutableStateFlow

app-common/src/main/java/eu/darken/capod/common/preferences/Settings.kt

@@ -1,4 +1,4 @@
-package eu.darken.androidstarter.common.preferences
+package eu.darken.capod.common.preferences
 
 import android.content.SharedPreferences
 import androidx.preference.PreferenceDataStore

app-common/src/main/java/eu/darken/capod/common/serialization/JavaInstantAdapter.kt

@@ -9,5 +9,5 @@ class JavaInstantAdapter {
     fun toJson(obj: Instant): Long = obj.toEpochMilli()
 
     @FromJson
-    fun fromJson(epochMillis: Long): Instant = Instant.ofEpochSecond(epochMillis)
+    fun fromJson(epochMillis: Long): Instant = Instant.ofEpochMilli(epochMillis)
 }

app-common/src/main/java/eu/darken/capod/common/viewbinding/ViewBindingExtensions.kt

@@ -8,7 +8,8 @@ import androidx.fragment.app.Fragment
 import androidx.lifecycle.DefaultLifecycleObserver
 import androidx.lifecycle.LifecycleOwner
 import androidx.viewbinding.ViewBinding
-import eu.darken.capod.common.debug.logging.Logging.Priority.*
+import eu.darken.capod.common.debug.logging.Logging.Priority.VERBOSE
+import eu.darken.capod.common.debug.logging.Logging.Priority.WARN
 import eu.darken.capod.common.debug.logging.log
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty

app-common/src/main/java/eu/darken/capod/main/core/GeneralSettings.kt

@@ -5,9 +5,10 @@ import android.content.SharedPreferences
 import androidx.preference.PreferenceDataStore
 import com.squareup.moshi.Moshi
 import dagger.hilt.android.qualifiers.ApplicationContext
-import eu.darken.androidstarter.common.preferences.Settings
+import eu.darken.capod.common.bluetooth.ScannerMode
 import eu.darken.capod.common.debug.autoreport.DebugSettings
 import eu.darken.capod.common.preferences.PreferenceStoreMapper
+import eu.darken.capod.common.preferences.Settings
 import eu.darken.capod.common.preferences.createFlowPreference
 import eu.darken.capod.pods.core.PodDevice
 import javax.inject.Inject
@@ -30,10 +31,15 @@ class GeneralSettings @Inject constructor(
 
     val scannerMode = preferences.createFlowPreference(
         "core.scanner.mode",
-        ScannerMode.BALANCED,
+        ScannerMode.LOW_LATENCY,
         moshi
     )
 
+    val compatibilityMode = preferences.createFlowPreference(
+        "core.compatibility.enabled",
+        false
+    )
+
     val showAll = preferences.createFlowPreference(
         "core.showall.enabled",
         false
@@ -58,9 +64,10 @@ class GeneralSettings @Inject constructor(
     override val preferenceDataStore: PreferenceDataStore = PreferenceStoreMapper(
         monitorMode,
         scannerMode,
+        compatibilityMode,
         showAll,
         minimumSignalQuality,
         mainDeviceAddress,
-        debugSettings.isAutoReportEnabled,
+        debugSettings.isAutoReportingEnabled,
     )
 }

app-common/src/main/java/eu/darken/capod/main/core/MonitorMode.kt

@@ -3,7 +3,7 @@ package eu.darken.capod.main.core
 import androidx.annotation.StringRes
 import com.squareup.moshi.Json
 import com.squareup.moshi.JsonClass
-import eu.darken.capod.R
+import eu.darken.capod.common.R
 
 @JsonClass(generateAdapter = false)
 enum class MonitorMode(