Refactor DI modules and qualifiers

- Move `ColorSchemeScopes` to `ColorSchemeQualifiers`
- Rename `CustomCertManagerModule` to `Cert4AndroidModule`
- Move `CoroutineScopes` to `CoroutineQualifiers`
- Add `ApplicationScope` qualifier to `CoroutineQualifiers`
- Remove redundant DI module declarations
- Add new `CoreSettingsProvidersModule`
- Add new `StartupPluginsModule`
- Add new `UncaughtExceptionHandlerModule`
- Add new `AuthorizationServiceModule`
- Add new `AppLicenseInfoProviderModule`
- Add new `IntroPageFactoryModule`
- Add new `LoginTypesProviderModule`
- Add new `AccountsDrawerHandlerModule`

.github/CODEOWNERS

@@ -0,0 +1,8 @@
+# See https://docs.github.com/de/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
+# For combination with "Require review from code owners" for main-ose branch.
+
+# Dependabot
+gradle/**   @bitfireAT/app-dev
+
+# everything else
+*   @rfc2822

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +1,4 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
 contact_links:
   - name: DAVx⁵ Community Support
     url: https://github.com/bitfireAT/davx5-ose/discussions

.github/ISSUE_TEMPLATE/qualified-bug.yml

@@ -1,5 +1,6 @@
 name: Qualified Bug Report
-description: "[Developers only] For qualified bug reports. (Use Discussions if unsure.)"
+description: "For qualified bug reports. (Use Discussions if unsure.)"
+type: bug
 labels: ["bug"]
 body:
   - type: checkboxes

.github/ISSUE_TEMPLATE/qualified-feature.yml

@@ -1,6 +1,7 @@
 name: Qualified Feature Request
-description: "[Developers only] For qualified feature requests. (Use Discussions if unsure.)"
-labels: ["feature"]
+description: "For qualified feature requests. (Use Discussions if unsure.)"
+type: feature
+labels: ["enhancement"]
 body:
   - type: checkboxes
     attributes:

.github/dependabot.yml

@@ -0,0 +1,32 @@
+version: 2
+updates:
+  # Enable version updates for GitHub Actions
+  - package-ecosystem: "github-actions"
+    # Workflow files stored in the default location of `.github/workflows`
+    # You don't need to specify `/.github/workflows` for `directory`. You can use `directory: "/"`.
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    commit-message:
+      prefix: "[CI] "
+    labels:
+      - "github_actions"
+      - "dependencies"
+    groups:
+      ci-actions:
+        patterns: ["*"]
+        
+  - package-ecosystem: "gradle"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    labels:             # don't create "java" label (default for gradle ecosystem)
+      - "dependencies"
+    groups:
+      app-dependencies:
+        patterns: ["*"]
+    ignore:
+      # dependencies without semantic versioning
+      - dependency-name: "com.github.bitfireat:cert4android"
+      - dependency-name: "com.github.bitfireat:dav4jvm"
+      - dependency-name: "com.github.bitfireat:synctools"

.github/pull_request_template.md

@@ -1,4 +1,6 @@
 
+Please delete this paragraph and other repeating text (like the examples) after reading and before submitting the PR.
+
 The PR should be in _Draft_ state during development. As soon as it's finished, it should be marked as _Ready for review_ and a reviewer should be chosen.
 
 See also: [Writing A Great Pull Request Description](https://www.pullrequest.com/blog/writing-a-great-pull-request-description/)

.github/release.yml

@@ -12,6 +12,9 @@ changelog:
     - title: Refactoring
       labels:
         - refactoring
+    - title: Dependencies
+      labels:
+        - dependencies
     - title: Other changes
       labels:
         - "*"

.github/workflows/codeql.yml

@@ -8,6 +8,7 @@ on:
     branches: [ main-ose ]
   schedule:
     - cron: '22 10 * * 1'
+
 concurrency:
   group: codeql-${{ github.ref }}
   cancel-in-progress: true
@@ -21,45 +22,29 @@ jobs:
       contents: read
       security-events: write
 
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'java' ]
-
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
-    - uses: actions/setup-java@v4
+      uses: actions/checkout@v6
+    - uses: actions/setup-java@v5
       with:
         distribution: temurin
-        java-version: 17
-    - uses: gradle/actions/setup-gradle@v3
+        java-version: 21
+    - uses: gradle/actions/setup-gradle@v5
       with:
         cache-encryption-key: ${{ secrets.gradle_encryption_key }}
         cache-read-only: true         # gradle user home cache is generated by test jobs
 
-    - name: Use incremental build cache
-      uses: actions/cache/restore@v4
-      with:
-        key: incremental-build-tests
-        restore-keys: incremental-build-tests   # restore cache from main branch
-        path: app/build
-
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v4
       with:
-        languages: ${{ matrix.language }}
+        languages: java-kotlin
+        build-mode: manual            # autobuild uses older JDK
 
-    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
-    # If this step fails, then you should remove it and run the build manually (see below)
-    #- name: Autobuild
-    #  uses: github/codeql-action/autobuild@v2
-
-    - name: Build
-      run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn --no-daemon app:assembleOseDebug
+    - name: Build                     # we must not use build cache here
+      run: ./gradlew --no-daemon --configuration-cache app:assembleDebug
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v4
       with:
         category: "/language:${{matrix.language}}"

.github/workflows/dependency-submission.yml

@@ -0,0 +1,24 @@
+name: Dependency Submission
+
+on:
+  push:
+    branches: [ 'main-ose' ]
+
+permissions:
+  contents: write
+
+jobs:
+  dependency-submission:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v6
+    - uses: actions/setup-java@v5
+      with:
+        distribution: temurin
+        java-version: 21
+
+    - name: Generate and submit dependency graph
+      uses: gradle/actions/dependency-submission@v5
+      with:
+        cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+        dependency-graph-exclude-configurations: '.*[Tt]est.* .*[cC]heck.*'

.github/workflows/dependent-issues.yml

@@ -1,55 +0,0 @@
-name: Dependent Issues
-
-on:
-  issues:
-    types:
-      - opened
-      - edited
-      - closed
-      - reopened
-  pull_request_target:
-    types:
-      - opened
-      - edited
-      - closed
-      - reopened
-      # Makes sure we always add status check for PRs. Useful only if
-      # this action is required to pass before merging. Otherwise, it
-      # can be removed.
-      - synchronize
-
-  # Schedule a daily check. Useful if you reference cross-repository
-  # issues or pull requests. Otherwise, it can be removed.
-  schedule:
-    - cron: '19 9 * * *'
-
-permissions: write-all
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: z0al/dependent-issues@v1
-        env:
-          # (Required) The token to use to make API calls to GitHub.
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          # (Optional) The token to use to make API calls to GitHub for remote repos.
-          GITHUB_READ_TOKEN: ${{ secrets.DEPENDENT_ISSUES_READ_TOKEN }}
-
-        with:
-          # (Optional) The label to use to mark dependent issues
-          # label: dependent
-
-          # (Optional) Enable checking for dependencies in issues.
-          # Enable by setting the value to "on". Default "off"
-          check_issues: on
-
-          # (Optional) A comma-separated list of keywords. Default
-          # "depends on, blocked by"
-          keywords: depends on, blocked by
-
-          # (Optional) A custom comment body. It supports `{{ dependencies }}` token.
-          comment: >
-            This PR/issue depends on:
-
-            {{ dependencies }}

.github/workflows/release.yml

@@ -19,19 +19,19 @@ jobs:
       discussions: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@v6
+      - uses: actions/setup-java@v5
         with:
           distribution: temurin
-          java-version: 17
-      - uses: gradle/actions/setup-gradle@v3
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v5
 
       - name: Prepare keystore
         run: echo ${{ secrets.android_keystore_base64 }} | base64 -d >$GITHUB_WORKSPACE/keystore.jks
 
       - name: Build signed package
-        # Make sure that caches are disabled to generate reproducible release builds
-        run: ./gradlew --no-build-cache --no-configuration-cache --no-daemon app:assembleRelease
+        # Use build cache to speed up building of build variants, but clean caches from previous tests before
+        run: ./gradlew --build-cache --configuration-cache --no-daemon app:clean app:assembleRelease
         env:
           ANDROID_KEYSTORE: ${{ github.workspace }}/keystore.jks
           ANDROID_KEYSTORE_PASSWORD: ${{ secrets.android_keystore_password }}
@@ -39,10 +39,9 @@ jobs:
           ANDROID_KEY_PASSWORD: ${{ secrets.android_key_password }}
 
       - name: Create Github release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           prerelease: ${{ env.prerelease }}
           files: app/build/outputs/apk/ose/release/*.apk
           fail_on_unmatched_files: true
           generate_release_notes: true
-          discussion_category_name: Announcements

.github/workflows/test-dev.yml

@@ -2,83 +2,135 @@ name: Development tests
 on:
   push:
     branches:
-      - '*'
+      - 'main-ose'
+  pull_request:
 
 concurrency:
   group: test-dev-${{ github.ref }}
   cancel-in-progress: true
 
+# We provide a remote gradle build cache. Take the settings from the secrets and enable
+# configuration and build cache for all gradle jobs.
+#
+# Note: The secrets are not available for forks and Dependabot PRs.
 env:
-  is_main_branch: ${{ github.ref == 'refs/heads/main-ose' }}
+  GRADLE_BUILDCACHE_URL: ${{ secrets.gradle_buildcache_url }}
+  GRADLE_BUILDCACHE_USERNAME: ${{ secrets.gradle_buildcache_username }}
+  GRADLE_BUILDCACHE_PASSWORD: ${{ secrets.gradle_buildcache_password }}
+  GRADLE_OPTS: -Dorg.gradle.caching=true -Dorg.gradle.configuration-cache=true
 
 jobs:
-  test:
-    name: Tests without emulator
+  compile:
+    name: Compile
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@v6
+      - uses: actions/setup-java@v5
         with:
           distribution: temurin
-          java-version: 17
-      - uses: gradle/actions/setup-gradle@v3
+          java-version: 21
+
+      # See https://community.gradle.org/github-actions/docs/setup-gradle/ for more information
+      - uses: gradle/actions/setup-gradle@v5
         with:
           cache-encryption-key: ${{ secrets.gradle_encryption_key }}
-          cache-read-only: true       # gradle user home cache is generated by test_on_emulator
+          cache-read-only: false                            # allow branches to update their configuration cache
+          gradle-home-cache-excludes: caches/build-cache-1  # don't cache local build cache because we use a remote cache
 
-      - name: Use incremental build cache
-        uses: actions/cache/restore@v4
+      - name: Cache Android environment
+        uses: actions/cache@v5
         with:
-          key: incremental-build-tests
-          restore-keys: incremental-build-tests   # restore cache from main branch
-          path: app/build
+          path: ~/.config/.android                          # needs to be cached so that configuration cache can work
+          key: android-${{ hashFiles('app/build.gradle.kts') }}
 
-      - name: Run lint and unit tests
-        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn --no-daemon app:check
+      - name: Compile
+        run: ./gradlew app:compileOseDebugSource
 
-  # generates the build caches because it uses more gradle dependencies
-  test_on_emulator:
-    name: Tests with emulator
+      # Cache configurations for the other jobs (including assemble for CodeQL)
+      - name: Populate configuration cache
+        run: |
+          ./gradlew --dry-run core:assembleDebug app:assembleDebug
+          ./gradlew --dry-run core:lintDebug app:lintOseDebug
+          ./gradlew --dry-run core:testDebugUnitTest
+          ./gradlew --dry-run core:virtualDebugAndroidTest
+
+  unit_tests:
+    needs: compile
+    name: Lint and unit tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-java@v4
+      - uses: actions/checkout@v6
+      - uses: actions/setup-java@v5
         with:
           distribution: temurin
-          java-version: 17
-      - uses: gradle/actions/setup-gradle@v3
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v5
         with:
           cache-encryption-key: ${{ secrets.gradle_encryption_key }}
-          gradle-home-cache-cleanup: true     # avoid ever-growing gradle user home cache
- 
-      - name: Use incremental build cache
-        if: ${{ !env.is_main_branch }}
-        uses: actions/cache/restore@v4
-        with:
-          key: incremental-build-tests
-          restore-keys: incremental-build-tests       # restore cache from main branch
-          path: |
-            .gradle/configuration-cache
-            app/build
+          cache-read-only: true
 
+      - name: Restore Android environment
+        uses: actions/cache/restore@v5
+        with:
+          path: ~/.config/.android
+          key: android-${{ hashFiles('app/build.gradle.kts') }}
+
+      - name: Lint checks
+        run: ./gradlew core:lintDebug app:lintOseDebug
+
+      - name: Unit tests
+        run: ./gradlew core:testDebugUnitTest
+
+  instrumented_tests:
+    needs: compile
+    name: Instrumented tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v5
+        with:
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          cache-read-only: true
+
+      - name: Restore Android environment
+        uses: actions/cache/restore@v5
+        with:
+          path: ~/.config/.android
+          key: android-${{ hashFiles('app/build.gradle.kts') }}
+
+      # gradle and Android SDK often take more space than what is available on the default runner.
+      # We try to free a few GB here to make gradle-managed devices more reliable.
+      - name: Free some disk space
+        uses: jlumbroso/free-disk-space@main
+        with:
+          android: false          # we need the Android SDK
+          large-packages: false   # apt takes too long
+          swap-storage: false     # gradle needs much memory
+
+      - name: Restore AVD
+        id: restore-avd
+        uses: actions/cache/restore@v5
+        with:
+          path: ~/.config/.android/avd                        # where AVD is stored
+          key: avd-${{ hashFiles('app/build.gradle.kts') }}   # gradle-managed devices are defined there
+
+      # Enable virtualization for Android emulator
       - name: Enable KVM group perms
         run: |
           echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
           sudo udevadm control --reload-rules
           sudo udevadm trigger --name-match=kvm
 
+      - name: Instrumented tests
+        run: ./gradlew core:virtualDebugAndroidTest
+
       - name: Cache AVD
-        uses: actions/cache@v4
+        uses: actions/cache/save@v5
+        if: steps.restore-avd.outputs.cache-hit != 'true'
         with:
-          path: ~/.config/.android/avd
+          path: ~/.config/.android/avd                        # where AVD is stored
           key: avd-${{ hashFiles('app/build.gradle.kts') }}   # gradle-managed devices are defined there
-
-      - name: Run device tests
-        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn --no-daemon app:virtualCheck
-
-      - name: Create incremental build cache
-        if: ${{ env.is_main_branch }}
-        uses: actions/cache/save@v4
-        with:
-          key: incremental-build-tests-${{ github.run_id }}
-          path: app/build

.gitignore

@@ -16,10 +16,6 @@
 bin/
 gen/
 
-# Gradle files
-.gradle/
-build/
-
 # Local configuration file (sdk path, etc)
 local.properties
 

.idea/codeStyles/Project.xml

@@ -0,0 +1,9 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <option name="LINE_SEPARATOR" value="&#10;" />
+    <option name="RIGHT_MARGIN" value="180" />
+    <codeStyleSettings language="kotlin">
+      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
+    </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>

.idea/copyright/LICENSE.xml

@@ -0,0 +1,6 @@
+<component name="CopyrightManager">
+  <copyright>
+    <option name="notice" value="Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details." />
+    <option name="myName" value="LICENSE" />
+  </copyright>
+</component>

.idea/copyright/profiles_settings.xml

@@ -0,0 +1,3 @@
+<component name="CopyrightManager">
+  <settings default="LICENSE" />
+</component>

.tx/config

@@ -1,30 +0,0 @@
-[main]
-host     = https://www.transifex.com
-lang_map = ar_SA: ar, en_GB: en-rGB, fa_IR: fa-rIR, fi_FI: fi, nb_NO: nb, sk_SK: sk, sl_SI: sl, tr_TR: tr, zh_CN: zh, zh_TW: zh-rTW
-
-[o:bitfireAT:p:davx5:r:app]
-file_filter   = app/src/main/res/values-<lang>/strings.xml
-source_file   = app/src/main/res/values/strings.xml
-source_lang   = en
-type          = ANDROID
-minimum_perc  = 20
-resource_name = App strings (all flavors)
-
-
-# Attention: fastlane directories are like "en-us", not "en-rUS"!
-
-[o:bitfireAT:p:davx5:r:metadata-short-description]
-file_filter   = fastlane/metadata/android/<lang>/short_description.txt
-source_file   = fastlane/metadata/android/en-US/short_description.txt
-source_lang   = en
-type          = TXT
-minimum_perc  = 100
-resource_name = Metadata: short description
-
-[o:bitfireAT:p:davx5:r:metadata-full-description]
-file_filter   = fastlane/metadata/android/<lang>/full_description.txt
-source_file   = fastlane/metadata/android/en-US/full_description.txt
-source_lang   = en
-type          = TXT
-minimum_perc  = 100
-resource_name = Metadata: full description

AUTHORS

@@ -1,11 +1,7 @@
-# This is the list of significant contributors to DAVx5.
-#
-# This does not necessarily list everyone who has contributed work.
-# To see the full list of contributors, see the revision history in
-# source control.
+You can view the list of people who have contributed to the code base in the version control history:
+https://github.com/bitfireAT/davx5-ose/graphs/contributors
 
-Ricki Hirner (bitfire.at)
-Bernhard Stockmann (bitfire.at)
+Translators are not mentioned in the history explicitly.
+The list of translators can be found in the About screen.
 
-Sunik Kupfer (bitfire.at)
-Patrick Lang (techbee.at)
+Every contribution is welcome. There are many other forms of contributing besides writing code!

CONTRIBUTING.md

@@ -14,24 +14,11 @@ If you send us a pull request, our CLA bot will ask you to sign the
 Contributor's License Agreement so that we can use your contribution.
 
 
-# Copyright
+# Copyright notice
 
 Make sure that every file that contains significant work (at least every code file)
-starts with the copyright header:
-
-```
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-```
-
-You can set this in Android Studio:
-
-1. Settings / Editor / Copyright / Copyright Profiles
-2. Paste the text above (without the stars).
-3. Set Formatting so that the preview exactly looks like above; one blank line after the block.
-4. Set this copyright profile as the default profile for the project.
-5. Apply copyright: right-click in file tree / Update copyright.
+starts with the copyright header. Android Studio should do so automatically because the
+configuration is stored in the repository (`.idea/copyright`).
 
 
 # Style guide
@@ -110,8 +97,3 @@ Test classes should be in the appropriate directory (see existing tests) and in
 tested class. Tests are usually be named like `methodToBeTested_Condition()`, see
 [Test apps on Android](https://developer.android.com/training/testing/).
 
-
-# Authors
-
-If you make significant contributions, feel free to add yourself to the [AUTHORS file](AUTHORS).
-

README.md

@@ -1,9 +1,9 @@
 
-[![Website](https://img.shields.io/website?style=flat-square&up_color=%237cb342&url=https%3A%2F%2Fwww.davx5.com)](https://www.davx5.com/)
-[![F-Droid](https://img.shields.io/f-droid/v/at.bitfire.davdroid?style=flat-square)](https://f-droid.org/packages/at.bitfire.davdroid/)
-[![License](https://img.shields.io/github/license/bitfireAT/davx5-ose?style=flat-square)](https://github.com/bitfireAT/davx5-ose/blob/main/LICENSE)
 [![Follow @davx5app@fosstodon.org](https://img.shields.io/mastodon/follow/109598783742737223?domain=https%3A%2F%2Ffosstodon.org&style=flat-square)](https://fosstodon.org/@davx5app)
-[![Development tests](https://github.com/bitfireAT/davx5-ose/actions/workflows/test-dev.yml/badge.svg)](https://github.com/bitfireAT/davx5-ose/actions/workflows/test-dev.yml)
+[![Website](https://img.shields.io/website?style=flat-square&up_color=%237cb342&url=https%3A%2F%2Fwww.davx5.com)](https://www.davx5.com/)
+[![License](https://img.shields.io/github/license/bitfireAT/davx5-ose?style=flat-square)](https://github.com/bitfireAT/davx5-ose/blob/main/LICENSE)
+[![F-Droid](https://img.shields.io/f-droid/v/at.bitfire.davdroid?style=flat-square)](https://f-droid.org/packages/at.bitfire.davdroid/)
+![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/bitfireAT/davx5-ose/total?label=GitHub%20downloads)
 
 ![DAVx⁵ logo](app/src/main/res/mipmap-xxxhdpi/ic_launcher.png)
 
@@ -11,8 +11,10 @@
 DAVx⁵
 ========
 
-Please see the [DAVx⁵ Web site](https://www.davx5.com) for
-comprehensive information about DAVx⁵, including a list of services it has been tested with.
+> [!IMPORTANT]
+> Please see the [DAVx⁵ Web site](https://www.davx5.com) for
+> comprehensive information about DAVx⁵, including a list of services it has been tested with,
+> a manual and FAQ.
 
 DAVx⁵ is licensed under the [GPLv3 License](LICENSE).
 
@@ -26,8 +28,7 @@ Parts of DAVx⁵ have been outsourced into these libraries:
 
 * [cert4android](https://github.com/bitfireAT/cert4android) – custom certificate management
 * [dav4jvm](https://github.com/bitfireAT/dav4jvm) – WebDAV/CalDav/CardDAV framework
-* [ical4android](https://github.com/bitfireAT/ical4android) – iCalendar processing and Calendar Provider access
-* [vcard4android](https://github.com/bitfireAT/vcard4android) – vCard processing and Contacts Provider access
+* [synctools](https://github.com/bitfireAT/synctools) – iCalendar/vCard/Tasks processing and content provider access
 
 **If you want to support DAVx⁵, please consider [donating to DAVx⁵](https://www.davx5.com/donate)
 or [purchasing it](https://www.davx5.com/download).**

app-ose/build.gradle.kts

@@ -0,0 +1,126 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 24        // Android 7.0
+        targetSdk = 36     // Android 16
+
+        applicationId = "at.bitfire.davdroid"
+
+        versionCode = 405090005
+        versionName = "4.5.9"
+
+        base.archivesName = "davx5-$versionCode-$versionName"
+    }
+
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(21)
+        }
+    }
+
+    compileOptions {
+        isCoreLibraryDesugaringEnabled = true
+    }
+
+    buildFeatures {
+        compose = true
+    }
+
+    // Java namespace for our classes (not to be confused with Android package ID)
+    namespace = "com.davx5.ose"
+
+    flavorDimensions += "distribution"
+    productFlavors {
+        create("ose") {
+            dimension = "distribution"
+            versionNameSuffix = "-ose"
+        }
+    }
+
+    androidResources {
+        generateLocaleConfig = true
+    }
+
+    buildTypes {
+        getByName("release") {
+            isMinifyEnabled = true
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules-release.pro")
+
+            isShrinkResources = true
+
+            signingConfig = signingConfigs.findByName("bitfire")
+        }
+    }
+
+    signingConfigs {
+        create("bitfire") {
+            storeFile = file(System.getenv("ANDROID_KEYSTORE") ?: "/dev/null")
+            storePassword = System.getenv("ANDROID_KEYSTORE_PASSWORD")
+            keyAlias = System.getenv("ANDROID_KEY_ALIAS")
+            keyPassword = System.getenv("ANDROID_KEY_PASSWORD")
+        }
+    }
+
+    @Suppress("UnstableApiUsage")
+    testOptions {
+        managedDevices {
+            localDevices {
+                create("virtual") {
+                    device = "Pixel 3"
+                    // TBD: API level 35 and higher causes network tests to fail sometimes, see https://github.com/bitfireAT/davx5-ose/issues/1525
+                    // Suspected reason: https://developer.android.com/about/versions/15/behavior-changes-all#background-network-access
+                    apiLevel = 34
+                    systemImageSource = "aosp-atd"
+                }
+            }
+        }
+    }
+}
+
+dependencies {
+    // include core subproject (manages its own dependencies itself, however from same version catalog)
+    implementation(project(":core"))
+
+    // Kotlin / Android
+    implementation(libs.kotlin.stdlib)
+    implementation(libs.kotlinx.coroutines)
+    coreLibraryDesugaring(libs.android.desugaring)
+
+    // Hilt
+    implementation(libs.hilt.android.base)
+    ksp(libs.androidx.hilt.compiler)
+    ksp(libs.hilt.android.compiler)
+
+    // support libs
+    implementation(libs.androidx.core)
+    implementation(libs.androidx.hilt.work)
+    implementation(libs.androidx.lifecycle.viewmodel.base)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.work.base)
+
+    // Jetpack Compose
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.material3)
+    debugImplementation(libs.androidx.compose.ui.tooling)
+    implementation(libs.androidx.compose.ui.toolingPreview)
+
+    // own libraries
+    implementation(libs.bitfire.cert4android)
+
+    // third-party libs
+    implementation(libs.guava)
+    implementation(libs.okhttp.base)
+    implementation(libs.openid.appauth)
+}

app-ose/src/main/AndroidManifest.xml

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        xmlns:tools="http://schemas.android.com/tools"
+        android:installLocation="internalOnly">
+
+    <application android:name=".App">
+
+        <!-- Required for Hilt/WorkManager integration. See
+        - https://developer.android.com/develop/background-work/background-tasks/persistent/configuration/custom-configuration#remove-default
+        - https://developer.android.com/training/dependency-injection/hilt-jetpack#workmanager
+        However, we must not disable AndroidX startup completely, as it's needed by other libraries like okhttp. -->
+        <provider
+                android:name="androidx.startup.InitializationProvider"
+                android:authorities="${applicationId}.androidx-startup"
+                android:exported="false"
+                tools:node="merge">
+            <meta-data
+                    android:name="androidx.work.WorkManagerInitializer"
+                    android:value="androidx.startup"
+                    tools:node="remove" />
+        </provider>
+
+    </application>
+
+</manifest>

app-ose/src/main/kotlin/com/davx5/ose/App.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose
+
+import androidx.work.Configuration
+import at.bitfire.davdroid.CoreApp
+import dagger.hilt.android.HiltAndroidApp
+
+/**
+ * Actual implementation of Application, used for Hilt. Delegates to [CoreApp].
+ */
+@HiltAndroidApp
+class App: CoreApp(), Configuration.Provider {
+
+    /**
+     * Required for Hilt/WorkManager integration, see:
+     * https://developer.android.com/training/dependency-injection/hilt-jetpack#workmanager
+     *
+     * This requires to remove the androidx.work.WorkManagerInitializer from App Startup
+     * in the AndroidManifest, see:
+     * https://developer.android.com/develop/background-work/background-tasks/persistent/configuration/custom-configuration#remove-default
+     */
+    override val workManagerConfiguration: Configuration
+        get() = Configuration.Builder()
+            .setWorkerFactory(workerFactory)
+            .build()
+
+}

app-ose/src/ose/AndroidManifest.xml

@@ -2,7 +2,8 @@
   ~ Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
   -->
 
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
 
     <application>
 
@@ -14,7 +15,10 @@
                 <action android:name="android.intent.action.VIEW"/>
                 <category android:name="android.intent.category.DEFAULT"/>
                 <category android:name="android.intent.category.BROWSABLE"/>
-                <data android:scheme="at.bitfire.davdroid" android:path="/oauth2/redirect"/>
+                <data
+                    tools:ignore="AppLinkUrlError"
+                        android:scheme="${applicationId}"
+                    android:path="/oauth2/redirect"/>
             </intent-filter>
         </activity>
 

app-ose/src/ose/kotlin/com/davx5/ose/DebugInfoCrashHandler.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose
+
+import android.content.Context
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import java.util.logging.Level
+import java.util.logging.Logger
+import javax.inject.Inject
+
+class DebugInfoCrashHandler @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val logger: Logger
+): Thread.UncaughtExceptionHandler {
+
+    @Module
+    @InstallIn(SingletonComponent::class)
+    interface DebugInfoCrashHandlerModule {
+        @Binds
+        fun debugInfoCrashHandler(
+            debugInfoCrashHandler: DebugInfoCrashHandler
+        ): Thread.UncaughtExceptionHandler
+    }
+
+    // See https://developer.android.com/about/versions/oreo/android-8.0-changes#loue
+    val originalCrashHandler = Thread.getDefaultUncaughtExceptionHandler()
+
+
+    override fun uncaughtException(t: Thread, e: Throwable) {
+        logger.log(Level.SEVERE, "Unhandled exception in thread ${t.id}!", e)
+
+        // start debug info activity with exception (will be started in a new process)
+        val intent = DebugInfoActivity.IntentBuilder(context)
+            .withCause(e)
+            .newTask()
+            .build()
+        context.startActivity(intent)
+
+        // pass through to default handler to kill the process
+        originalCrashHandler?.uncaughtException(t, e)
+    }
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/AccountsDrawerHandlerModule.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import at.bitfire.davdroid.ui.AccountsDrawerHandler
+import at.bitfire.davdroid.ui.OseAccountsDrawerHandler
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityComponent
+
+@Module
+@InstallIn(ActivityComponent::class)
+interface AccountsDrawerHandlerModule {
+    @Binds
+    fun accountsDrawerHandler(impl: OseAccountsDrawerHandler): AccountsDrawerHandler
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/AppLicenseInfoProviderModule.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import at.bitfire.davdroid.ui.about.AboutActivity
+import com.davx5.ose.ui.about.OpenSourceLicenseInfoProvider
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ViewModelComponent
+
+@Module
+@InstallIn(ViewModelComponent::class)
+interface AppLicenseInfoProviderModule {
+    @Binds
+    fun appLicenseInfoProvider(impl: OpenSourceLicenseInfoProvider): AboutActivity.AppLicenseInfoProvider
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/Cert4AndroidModule.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import android.content.Context
+import at.bitfire.cert4android.CustomCertManager
+import at.bitfire.cert4android.CustomCertStore
+import at.bitfire.cert4android.SettingsProvider
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.davdroid.ui.ForegroundTracker
+import dagger.Module
+import dagger.Provides
+import dagger.Reusable
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import okhttp3.internal.tls.OkHostnameVerifier
+import java.util.Optional
+
+/**
+ * cert4android integration module
+ */
+@Module
+@InstallIn(SingletonComponent::class)
+class Cert4AndroidModule {
+
+    @Provides
+    fun customCertStore(@ApplicationContext context: Context): Optional<CustomCertStore> =
+        Optional.of(CustomCertStore.getInstance(context))
+
+    @Provides
+    @Reusable
+    fun customCertManager(
+        customCertStore: Optional<CustomCertStore>,
+        settings: SettingsManager
+    ): Optional<CustomCertManager> =
+        Optional.of(
+            CustomCertManager(
+            certStore = customCertStore.get(),
+            settings = object : SettingsProvider {
+
+                override val appInForeground: Boolean
+                    get() = ForegroundTracker.inForeground.value
+
+                override val trustSystemCerts: Boolean
+                    get() = !settings.getBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES)
+
+            }
+        ))
+
+    @Provides
+    @Reusable
+    fun customHostnameVerifier(
+        customCertManager: Optional<CustomCertManager>
+    ): Optional<CustomCertManager.HostnameVerifier> =
+        Optional.of(customCertManager.get().HostnameVerifier(OkHostnameVerifier))
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/ColorSchemesModule.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import androidx.compose.material3.ColorScheme
+import at.bitfire.davdroid.di.qualifier.DarkColorScheme
+import at.bitfire.davdroid.di.qualifier.LightColorScheme
+import at.bitfire.davdroid.ui.OseTheme
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+class ColorSchemesModule {
+
+    @Provides
+    @LightColorScheme
+    fun lightColorScheme(): ColorScheme = OseTheme.lightScheme
+
+    @Provides
+    @DarkColorScheme
+    fun darkColorScheme(): ColorScheme = OseTheme.darkScheme
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/IntroPageFactoryModule.kt

@@ -0,0 +1,19 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import at.bitfire.davdroid.ui.intro.IntroPageFactory
+import com.davx5.ose.ui.intro.OseIntroPageFactory
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+interface Global {
+    @Binds
+    fun introPageFactory(impl: OseIntroPageFactory): IntroPageFactory
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/LoginTypesProviderModule.kt

@@ -0,0 +1,21 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import at.bitfire.davdroid.ui.setup.LoginTypesProvider
+import at.bitfire.davdroid.ui.setup.StandardLoginTypesProvider
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+interface LoginTypesProviderModule {
+
+    @Binds
+    fun loginTypesProvider(impl: StandardLoginTypesProvider): LoginTypesProvider
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/ui/about/OpenSourceLicenseInfoProvider.kt

@@ -2,10 +2,11 @@
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
  */
 
-package at.bitfire.davdroid.ui
+package com.davx5.ose.ui.about
 
-import android.app.Application
+import android.content.Context
 import android.text.Spanned
+import androidx.compose.material3.Text
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.getValue
 import androidx.compose.runtime.mutableStateOf
@@ -13,15 +14,17 @@ import androidx.compose.runtime.setValue
 import androidx.compose.ui.text.AnnotatedString
 import androidx.compose.ui.tooling.preview.Preview
 import androidx.core.text.HtmlCompat
-import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.ViewModel
 import androidx.lifecycle.viewModelScope
 import androidx.lifecycle.viewmodel.compose.viewModel
+import at.bitfire.davdroid.di.qualifier.IoDispatcher
 import at.bitfire.davdroid.ui.UiUtils.toAnnotatedString
-import at.bitfire.davdroid.ui.widget.ClickableTextWithLink
+import at.bitfire.davdroid.ui.about.AboutActivity
+import com.google.common.io.CharStreams
 import dagger.hilt.android.lifecycle.HiltViewModel
-import kotlinx.coroutines.Dispatchers
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineDispatcher
 import kotlinx.coroutines.launch
-import org.apache.commons.io.IOUtils
 import javax.inject.Inject
 
 class OpenSourceLicenseInfoProvider @Inject constructor(): AboutActivity.AppLicenseInfoProvider {
@@ -40,14 +43,17 @@ class OpenSourceLicenseInfoProvider @Inject constructor(): AboutActivity.AppLice
 
 
     @HiltViewModel
-    class Model @Inject constructor(app: Application): AndroidViewModel(app) {
+    class Model @Inject constructor(
+        @ApplicationContext private val context: Context,
+        @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+    ): ViewModel() {
 
         var gpl by mutableStateOf<Spanned?>(null)
 
         init {
-            viewModelScope.launch(Dispatchers.IO) {
-                app.resources.assets.open("gplv3.html").use { inputStream ->
-                    val raw = IOUtils.toString(inputStream, Charsets.UTF_8)
+            viewModelScope.launch(ioDispatcher) {
+                context.resources.assets.open("gplv3.html").use { inputStream ->
+                    val raw = CharStreams.toString(inputStream.bufferedReader())
                     gpl = HtmlCompat.fromHtml(raw, HtmlCompat.FROM_HTML_MODE_LEGACY)
                 }
             }
@@ -60,7 +66,7 @@ class OpenSourceLicenseInfoProvider @Inject constructor(): AboutActivity.AppLice
 
 @Composable
 fun OpenSourceLicenseInfo(license: AnnotatedString) {
-    ClickableTextWithLink(license)
+    Text(text = license)
 }
 
 @Composable

app-ose/src/ose/kotlin/com/davx5/ose/ui/intro/OseIntroPageFactory.kt

@@ -2,8 +2,9 @@
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
  */
 
-package at.bitfire.davdroid
+package com.davx5.ose.ui.intro
 
+import at.bitfire.davdroid.ui.intro.BackupsPage
 import at.bitfire.davdroid.ui.intro.BatteryOptimizationsPage
 import at.bitfire.davdroid.ui.intro.IntroPageFactory
 import at.bitfire.davdroid.ui.intro.OpenSourcePage
@@ -13,6 +14,7 @@ import at.bitfire.davdroid.ui.intro.WelcomePage
 import javax.inject.Inject
 
 class OseIntroPageFactory @Inject constructor(
+    backupsPage: BackupsPage,
     batteryOptimizationsPage: BatteryOptimizationsPage,
     openSourcePage: OpenSourcePage,
     permissionsIntroPage: PermissionsIntroPage,
@@ -24,6 +26,7 @@ class OseIntroPageFactory @Inject constructor(
         tasksIntroPage,
         permissionsIntroPage,
         batteryOptimizationsPage,
+        backupsPage,
         openSourcePage
     )
 

app/proguard-rules-release.pro

@@ -1,59 +0,0 @@
-
-# R8 usage for DAVx⁵:
-#    shrinking        yes (only in release builds)
-#    optimization     yes (on by R8 defaults)
-#      full-mode      no (see gradle.properties)
-#    obfuscation      no (open-source)
-
--dontobfuscate
--printusage build/reports/r8-usage.txt
-
-# ez-vcard: keep all vCard properties/parameters (used via reflection)
--keep class ezvcard.io.scribe.** { *; }
--keep class ezvcard.property.** { *; }
--keep class ezvcard.parameter.** { *; }
-
-# ical4j: keep all iCalendar properties/parameters (used via reflection)
--keep class net.fortuna.ical4j.** { *; }
-
-# XmlPullParser
--keep class org.xmlpull.** { *; }
-
-# DAVx⁵ + libs
--keep class at.bitfire.** { *; }       # all DAVx⁵ code is required
-
-# AGP 8.2 and 8.3 seem to remove this class, but ezvcard.io uses it. See https://github.com/bitfireAT/davx5/issues/499
--keep class javax.xml.namespace.QName { *; }
-
-# we use enum classes (https://www.guardsquare.com/en/products/proguard/manual/examples#enumerations)
--keepclassmembers,allowoptimization enum * {
-    public static **[] values();
-    public static ** valueOf(java.lang.String);
-}
-
-# Additional rules which are now required since missing classes can't be ignored in R8 anymore.
-# [https://developer.android.com/build/releases/past-releases/agp-7-0-0-release-notes#r8-missing-class-warning]
--dontwarn com.android.org.conscrypt.SSLParametersImpl
--dontwarn com.github.erosb.jsonsKema.**  # ical4j
--dontwarn com.google.errorprone.annotations.**
--dontwarn com.sun.jna.**                 # dnsjava
--dontwarn groovy.**
--dontwarn java.beans.Transient
--dontwarn javax.cache.**                 # ical4j
--dontwarn javax.naming.NamingException   # dnsjava
--dontwarn javax.naming.directory.**      # dnsjava
--dontwarn junit.textui.TestRunner
--dontwarn lombok.**                      # dnsjava
--dontwarn org.apache.harmony.xnet.provider.jsse.SSLParametersImpl
--dontwarn org.bouncycastle.jsse.**
--dontwarn org.codehaus.groovy.**
--dontwarn org.joda.**
--dontwarn org.jparsec.**                 # ical4j
--dontwarn org.json.*
--dontwarn org.jsoup.**
--dontwarn org.openjsse.javax.net.ssl.SSLParameters
--dontwarn org.openjsse.javax.net.ssl.SSLSocket
--dontwarn org.openjsse.net.ssl.OpenJSSE
--dontwarn org.xmlpull.**
--dontwarn sun.net.spi.nameservice.NameService
--dontwarn sun.net.spi.nameservice.NameServiceDescriptor

app/src/.gitignore

@@ -1 +0,0 @@
-espressoTest

app/src/androidTest/kotlin/at/bitfire/davdroid/CustomTestRunner.kt

@@ -1,17 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid
-
-import android.content.Context
-import androidx.test.runner.AndroidJUnitRunner
-import dagger.hilt.android.HiltAndroidApp
-import dagger.hilt.android.testing.HiltTestApplication
-
-class CustomTestRunner : AndroidJUnitRunner() {
-
-    override fun newApplication(cl: ClassLoader, name: String, context: Context) =
-        super.newApplication(cl, HiltTestApplication::class.java.name, context)
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/Dav4jvm.kt

@@ -1,20 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid
-
-import android.util.Xml
-import at.bitfire.dav4jvm.XmlUtils
-import org.junit.Assert.assertTrue
-import org.junit.Test
-
-class Dav4jvm {
-
-    @Test
-    fun test_Dav4jvm_XmlUtils_NewPullParser_RelaxedParsing() {
-        val parser = XmlUtils.newPullParser()
-        assertTrue(parser.getFeature(Xml.FEATURE_RELAXED))
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/InitCalendarProviderRule.kt

@@ -1,96 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid
-
-import android.Manifest
-import android.accounts.Account
-import android.content.ContentUris
-import android.content.ContentValues
-import android.os.Build
-import android.provider.CalendarContract
-import androidx.annotation.RequiresApi
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalCalendar
-import at.bitfire.davdroid.resource.LocalEvent
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.Event
-import net.fortuna.ical4j.model.property.DtStart
-import net.fortuna.ical4j.model.property.RRule
-import org.junit.rules.RuleChain
-import org.junit.rules.TestRule
-import org.junit.runner.Description
-import org.junit.runners.model.Statement
-
-/**
- * JUnit ClassRule which initializes the AOSP CalendarProvider.
- * Needed for some "flaky" tests which would otherwise only succeed on second run.
- *
- * Currently tested on development machine (Ryzen) with Android 12 images (with/without Google Play).
- * Calendar provider behaves quite randomly, so it may or may not work. If you (the reader
- * if this comment) can find out on how to initialize the calendar provider so that the
- * tests are reliably run after `adb shell pm clear com.android.providers.calendar`,
- * please let us know!
- *
- * If you run tests manually, just make sure to ignore the first run after the calendar
- * provider has been accessed the first time.
- */
-class InitCalendarProviderRule private constructor(): TestRule {
-
-    companion object {
-        fun getInstance() = RuleChain
-            .outerRule(GrantPermissionRule.grant(Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR))
-            .around(InitCalendarProviderRule())
-    }
-
-    override fun apply(base: Statement, description: Description): Statement {
-        Logger.log.info("Initializing calendar provider before running ${description.displayName}")
-        return InitCalendarProviderStatement(base)
-    }
-
-
-    class InitCalendarProviderStatement(val base: Statement): Statement() {
-
-        override fun evaluate() {
-            if (Build.VERSION.SDK_INT < 31)
-                Logger.log.warning("Calendar provider initialization may or may not work. See InitCalendarProviderRule")
-            initCalendarProvider()
-
-            base.evaluate()
-        }
-
-        private fun initCalendarProvider() {
-            val account = Account("LocalCalendarTest", CalendarContract.ACCOUNT_TYPE_LOCAL)
-            val context = InstrumentationRegistry.getInstrumentation().targetContext
-            val provider = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)!!
-            val uri = AndroidCalendar.create(account, provider, ContentValues())
-            val calendar = AndroidCalendar.findByID(account, provider, LocalCalendar.Factory, ContentUris.parseId(uri))
-            try {
-                // single event init
-                val normalEvent = Event().apply {
-                    dtStart = DtStart("20220120T010203Z")
-                    summary = "Event with 1 instance"
-                }
-                val normalLocalEvent = LocalEvent(calendar, normalEvent, null, null, null, 0)
-                normalLocalEvent.add()
-                LocalEvent.numInstances(provider, account, normalLocalEvent.id!!)
-
-                // recurring event init
-                val recurringEvent = Event().apply {
-                    dtStart = DtStart("20220120T010203Z")
-                    summary = "Event over 22 years"
-                    rRules.add(RRule("FREQ=YEARLY;UNTIL=20740119T010203Z"))     // year needs to be  >2074 (not supported by Android <11 Calendar Storage)
-                }
-                val localRecurringEvent = LocalEvent(calendar, recurringEvent, null, null, null, 0)
-                localRecurringEvent.add()
-                LocalEvent.numInstances(provider, account, localRecurringEvent.id!!)
-            } finally {
-                calendar.delete()
-            }
-        }
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/db/AppDatabaseTest.kt

@@ -1,50 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.db
-
-import android.content.Context
-import androidx.room.Room
-import androidx.room.testing.MigrationTestHelper
-import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Rule
-import org.junit.Test
-
-class AppDatabaseTest {
-
-    val TEST_DB = "test"
-
-    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    @Rule
-    @JvmField
-    val helper = MigrationTestHelper(
-        InstrumentationRegistry.getInstrumentation(),
-        AppDatabase::class.java,
-        listOf(), // no auto migrations until v8
-        FrameworkSQLiteOpenHelperFactory()
-    )
-
-
-    @Test
-    fun testAllMigrations() {
-        // DB schema is available since version 8, so create DB with v8
-        helper.createDatabase(TEST_DB, 8).close()
-
-        val db = Room.databaseBuilder(context, AppDatabase::class.java, TEST_DB)
-            // manual migrations
-            .addMigrations(*AppDatabase.migrations)
-            // auto-migrations that need to be specified explicitly
-            .addAutoMigrationSpec(AppDatabase.AutoMigration11_12(context))
-            .build()
-        try {
-            // open (with version 8) + migrate (to current version) database
-            db.openHelper.writableDatabase
-        } finally {
-            db.close()
-        }
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/db/CollectionTest.kt

@@ -1,155 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.db
-
-import android.security.NetworkSecurityPolicy
-import androidx.test.filters.SmallTest
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.dav4jvm.DavResource
-import at.bitfire.dav4jvm.property.webdav.ResourceType
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.settings.SettingsManager
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Assume
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import javax.inject.Inject
-
-@HiltAndroidTest
-class CollectionTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @Inject
-    lateinit var settingsManager: SettingsManager
-
-    @Before
-    fun inject() {
-        hiltRule.inject()
-    }
-
-
-    private lateinit var httpClient: HttpClient
-    private val server = MockWebServer()
-
-    @Before
-    fun setUp() {
-        httpClient = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build()
-        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
-    }
-
-    @After
-    fun shutDown() {
-        httpClient.close()
-    }
-
-
-    @Test
-    @SmallTest
-    fun testFromDavResponseAddressBook() {
-        // r/w address book
-        server.enqueue(MockResponse()
-                .setResponseCode(207)
-                .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav'>" +
-                        "<response>" +
-                        "   <href>/</href>" +
-                        "   <propstat><prop>" +
-                        "       <resourcetype><collection/><CARD:addressbook/></resourcetype>" +
-                        "       <displayname>My Contacts</displayname>" +
-                        "       <CARD:addressbook-description>My Contacts Description</CARD:addressbook-description>" +
-                        "   </prop></propstat>" +
-                        "</response>" +
-                        "</multistatus>"))
-
-        lateinit var info: Collection
-        DavResource(httpClient.okHttpClient, server.url("/"))
-                .propfind(0, ResourceType.NAME) { response, _ ->
-            info = Collection.fromDavResponse(response) ?: throw IllegalArgumentException()
-        }
-        assertEquals(Collection.TYPE_ADDRESSBOOK, info.type)
-        assertTrue(info.privWriteContent)
-        assertTrue(info.privUnbind)
-        assertNull(info.supportsVEVENT)
-        assertNull(info.supportsVTODO)
-        assertNull(info.supportsVJOURNAL)
-        assertEquals("My Contacts", info.displayName)
-        assertEquals("My Contacts Description", info.description)
-    }
-
-    @Test
-    @SmallTest
-    fun testFromDavResponseCalendar() {
-        // read-only calendar, no display name
-        server.enqueue(MockResponse()
-                .setResponseCode(207)
-                .setBody("<multistatus xmlns='DAV:' xmlns:CAL='urn:ietf:params:xml:ns:caldav' xmlns:ICAL='http://apple.com/ns/ical/'>" +
-                        "<response>" +
-                        "   <href>/</href>" +
-                        "   <propstat><prop>" +
-                        "       <resourcetype><collection/><CAL:calendar/></resourcetype>" +
-                        "       <current-user-privilege-set><privilege><read/></privilege></current-user-privilege-set>" +
-                        "       <CAL:calendar-description>My Calendar</CAL:calendar-description>" +
-                        "       <CAL:calendar-timezone>tzdata</CAL:calendar-timezone>" +
-                        "       <ICAL:calendar-color>#ff0000</ICAL:calendar-color>" +
-                        "   </prop></propstat>" +
-                        "</response>" +
-                        "</multistatus>"))
-
-        lateinit var info: Collection
-        DavResource(httpClient.okHttpClient, server.url("/"))
-                .propfind(0, ResourceType.NAME) { response, _ ->
-                    info = Collection.fromDavResponse(response) ?: throw IllegalArgumentException()
-                }
-        assertEquals(Collection.TYPE_CALENDAR, info.type)
-        assertFalse(info.privWriteContent)
-        assertFalse(info.privUnbind)
-        assertNull(info.displayName)
-        assertEquals("My Calendar", info.description)
-        assertEquals(0xFFFF0000.toInt(), info.color)
-        assertEquals("tzdata", info.timezone)
-        assertTrue(info.supportsVEVENT!!)
-        assertTrue(info.supportsVTODO!!)
-        assertTrue(info.supportsVJOURNAL!!)
-    }
-
-    @Test
-    @SmallTest
-    fun testFromDavResponseWebcal() {
-        // Webcal subscription
-        server.enqueue(MockResponse()
-                .setResponseCode(207)
-                .setBody("<multistatus xmlns='DAV:' xmlns:CS='http://calendarserver.org/ns/'>" +
-                        "<response>" +
-                        "   <href>/webcal1</href>" +
-                        "   <propstat><prop>" +
-                        "       <displayname>Sample Subscription</displayname>" +
-                        "       <resourcetype><collection/><CS:subscribed/></resourcetype>" +
-                        "       <CS:source><href>webcals://example.com/1.ics</href></CS:source>" +
-                        "   </prop></propstat>" +
-                        "</response>" +
-                        "</multistatus>"))
-
-        lateinit var info: Collection
-        DavResource(httpClient.okHttpClient, server.url("/"))
-                .propfind(0, ResourceType.NAME) { response, _ ->
-                    info = Collection.fromDavResponse(response) ?: throw IllegalArgumentException()
-                }
-        assertEquals(Collection.TYPE_WEBCAL, info.type)
-        assertEquals("Sample Subscription", info.displayName)
-        assertEquals("https://example.com/1.ics".toHttpUrl(), info.source)
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/db/HomesetDaoTest.kt

@@ -1,81 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.db
-
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import javax.inject.Inject
-
-@HiltAndroidTest
-class HomesetDaoTest {
-
-    @get:Rule
-    var hiltRule = HiltAndroidRule(this)
-
-    @Inject
-    lateinit var db: AppDatabase
-
-    @Before
-    fun setUp() {
-        hiltRule.inject()
-    }
-
-    @After
-    fun tearDown() {
-        db.close()
-    }
-
-    @Test
-    fun testInsertOrUpdate() {
-        // should insert new row or update (upsert) existing row - without changing its key!
-        val serviceId = createTestService()
-        val homeSetDao = db.homeSetDao()
-
-        val entry1 = HomeSet(id=0, serviceId=serviceId, personal=true, url="https://example.com/1".toHttpUrl())
-        val insertId1 = homeSetDao.insertOrUpdateByUrl(entry1)
-        assertEquals(1L, insertId1)
-        assertEquals(entry1.apply { id = 1L }, homeSetDao.getById(1L))
-
-        val updatedEntry1 = HomeSet(id=0, serviceId=serviceId, personal=true, url="https://example.com/1".toHttpUrl(), displayName="Updated Entry")
-        val updateId1 = homeSetDao.insertOrUpdateByUrl(updatedEntry1)
-        assertEquals(1L, updateId1)
-        assertEquals(updatedEntry1.apply { id = 1L }, homeSetDao.getById(1L))
-
-        val entry2 = HomeSet(id=0, serviceId=serviceId, personal=true, url= "https://example.com/2".toHttpUrl())
-        val insertId2 = homeSetDao.insertOrUpdateByUrl(entry2)
-        assertEquals(2L, insertId2)
-        assertEquals(entry2.apply { id = 2L }, homeSetDao.getById(2L))
-    }
-
-    @Test
-    fun testDelete() {
-        // should delete row with given primary key (id)
-        val serviceId = createTestService()
-        val homesetDao = db.homeSetDao()
-
-        val entry1 = HomeSet(id=1, serviceId=serviceId, personal=true, url= "https://example.com/1".toHttpUrl())
-
-        val insertId1 = homesetDao.insertOrUpdateByUrl(entry1)
-        assertEquals(1L, insertId1)
-        assertEquals(entry1, homesetDao.getById(1L))
-
-        homesetDao.delete(entry1)
-
-        assertEquals(null, homesetDao.getById(1L))
-    }
-
-    fun createTestService() : Long {
-        val serviceDao = db.serviceDao()
-        val service = Service(id=0, accountName="test", type=Service.TYPE_CALDAV, principal = null)
-        return serviceDao.insertOrReplace(service)
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/network/ConnectionUtilsTest.kt

@@ -1,154 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.network
-
-import android.net.ConnectivityManager
-import android.net.Network
-import android.net.NetworkCapabilities
-import android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET
-import android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN
-import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
-import android.net.NetworkCapabilities.TRANSPORT_WIFI
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.mockk.every
-import io.mockk.junit4.MockKRule
-import io.mockk.mockk
-import junit.framework.TestCase.assertFalse
-import junit.framework.TestCase.assertTrue
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-
-@HiltAndroidTest
-class ConnectionUtilsTest {
-
-    @get:Rule
-    val mockkRule = MockKRule(this)
-
-    private val connectivityManager = mockk<ConnectivityManager>()
-    private val network1 = mockk<Network>()
-    private val network2 = mockk<Network>()
-    private val capabilities = mockk<NetworkCapabilities>()
-
-    @Before
-    fun setUp() {
-        every { connectivityManager.allNetworks } returns arrayOf(network1, network2)
-        every { connectivityManager.getNetworkInfo(network1) } returns mockk()
-        every { connectivityManager.getNetworkInfo(network2) } returns mockk()
-        every { connectivityManager.getNetworkCapabilities(network1) } returns capabilities
-        every { connectivityManager.getNetworkCapabilities(network2) } returns capabilities
-    }
-
-    @Test
-    fun testWifiAvailable_capabilitiesNull() {
-        every { connectivityManager.getNetworkCapabilities(network1) } returns null
-        every { connectivityManager.getNetworkCapabilities(network2) } returns null
-        assertFalse(ConnectionUtils.wifiAvailable(connectivityManager))
-    }
-
-    @Test
-    fun testWifiAvailable() {
-        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns false
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
-        assertFalse(ConnectionUtils.wifiAvailable(connectivityManager))
-    }
-
-    @Test
-    fun testWifiAvailable_wifi() {
-        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
-        assertFalse(ConnectionUtils.wifiAvailable(connectivityManager))
-    }
-
-    @Test
-    fun testWifiAvailable_validated() {
-        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns false
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        assertFalse(ConnectionUtils.wifiAvailable(connectivityManager))
-    }
-
-    @Test
-    fun testWifiAvailable_wifiValidated() {
-        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        assertTrue(ConnectionUtils.wifiAvailable(connectivityManager))
-    }
-
-
-    @Test
-    fun testInternetAvailable_capabilitiesNull() {
-        every { connectivityManager.getNetworkCapabilities(network1) } returns null
-        every { connectivityManager.getNetworkCapabilities(network2) } returns null
-        assertFalse(ConnectionUtils.internetAvailable(connectivityManager, false))
-    }
-
-    @Test
-    fun testInternetAvailable_Internet() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
-        assertFalse(ConnectionUtils.internetAvailable(connectivityManager, false))
-    }
-
-    @Test
-    fun testInternetAvailable_Validated() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns false
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        assertFalse(ConnectionUtils.internetAvailable(connectivityManager, false))
-    }
-
-    @Test
-    fun testInternetAvailable_InternetValidated() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        assertTrue(ConnectionUtils.internetAvailable(connectivityManager, false))
-    }
-
-    @Test
-    fun testInternetAvailable_ignoreVpns() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_NOT_VPN) } returns false
-        assertFalse(ConnectionUtils.internetAvailable(connectivityManager, true))
-    }
-
-    @Test
-    fun testInternetAvailable_ignoreVpns_Notvpn() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_NOT_VPN) } returns true
-        assertTrue(ConnectionUtils.internetAvailable(connectivityManager, true))
-    }
-
-    @Test
-    fun testInternetAvailable_twoConnectionsFirstOneWithoutInternet() {
-        // The real case that failed in davx5-ose#395 is that the connection list contains (in this order)
-        // 1. a mobile network without INTERNET, but with VALIDATED
-        // 2. a WiFi network with INTERNET and VALIDATED
-
-        // The "return false" of hasINTERNET will trigger at the first connection, the
-        // "andThen true" will trigger for the second connection
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns false andThen true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-
-        // There is an internet connection if any(!) connection has both INTERNET and VALIDATED.
-        assertTrue(ConnectionUtils.internetAvailable(connectivityManager, false))
-    }
-
-    @Test
-    fun testInternetAvailable_twoConnectionsFirstOneWithoutValidated() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false andThen true
-        assertTrue(ConnectionUtils.internetAvailable(connectivityManager, false))
-    }
-
-    @Test
-    fun testInternetAvailable_twoConnectionsFirstOneWithoutNotvpn() {
-        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
-        every { capabilities.hasCapability(NET_CAPABILITY_NOT_VPN) } returns false andThen true
-        assertTrue(ConnectionUtils.internetAvailable(connectivityManager, true))
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/LocalAddressBookTest.kt

@@ -1,78 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import androidx.arch.core.executor.testing.InstantTaskExecutorRule
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.R
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.After
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-
-@HiltAndroidTest
-class LocalAddressBookTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    val mainAccountType = context.getString(R.string.account_type)
-    val mainAccount = Account("main", mainAccountType)
-
-    val addressBookAccountType = context.getString(R.string.account_type_address_book)
-    val addressBookAccount = Account("sub", addressBookAccountType)
-
-    val accountManager = AccountManager.get(context)
-
-    @Before
-    fun setUp() {
-        hiltRule.inject()
-
-        // TODO DOES NOT WORK: the account immediately starts to sync, which creates the sync adapter services.
-        // The services however can't be created because Hilt is "not ready" (although it has been initialized in the line above).
-        // assertTrue(AccountUtils.createAccount(context, mainAccount, AccountSettings.initialUserData(null)))
-    }
-
-    @After
-    fun cleanup() {
-        accountManager.removeAccount(addressBookAccount, null, null)
-        accountManager.removeAccount(mainAccount, null, null)
-    }
-
-
-    // TODO see above
-    /*@Test
-    fun testMainAccount_AddressBookAccount_WithMainAccount() {
-        // create address book account
-        assertTrue(accountManager.addAccountExplicitly(addressBookAccount, null, Bundle().apply {
-            putString(LocalAddressBook.USER_DATA_MAIN_ACCOUNT_NAME, mainAccount.name)
-            putString(LocalAddressBook.USER_DATA_MAIN_ACCOUNT_TYPE, mainAccount.type)
-        }))
-
-        // check mainAccount()
-        assertEquals(mainAccount, LocalAddressBook.mainAccount(context, addressBookAccount))
-    }
-
-    @Test(expected = IllegalArgumentException::class)
-    fun testMainAccount_AddressBookAccount_WithoutMainAccount() {
-        // create address book account
-        assertTrue(accountManager.addAccountExplicitly(addressBookAccount, null, Bundle()))
-
-        // check mainAccount(); should fail because there's no main account
-        LocalAddressBook.mainAccount(context, addressBookAccount)
-    }*/
-
-    @Test(expected = IllegalArgumentException::class)
-    fun testMainAccount_OtherAccount() {
-        LocalAddressBook.mainAccount(context, Account("Other Account", "com.example"))
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/LocalCalendarTest.kt

@@ -1,145 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentUris
-import android.content.ContentValues
-import android.provider.CalendarContract
-import android.provider.CalendarContract.ACCOUNT_TYPE_LOCAL
-import android.provider.CalendarContract.Events
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.InitCalendarProviderRule
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.Event
-import at.bitfire.ical4android.util.MiscUtils.closeCompat
-import at.bitfire.ical4android.util.MiscUtils.asSyncAdapter
-import net.fortuna.ical4j.model.property.DtStart
-import net.fortuna.ical4j.model.property.RRule
-import net.fortuna.ical4j.model.property.RecurrenceId
-import net.fortuna.ical4j.model.property.Status
-import org.junit.*
-import org.junit.Assert.assertEquals
-import org.junit.rules.TestRule
-
-class LocalCalendarTest {
-
-    companion object {
-        @JvmField
-        @ClassRule
-        val initCalendarProviderRule: TestRule = InitCalendarProviderRule.getInstance()
-
-        private lateinit var provider: ContentProviderClient
-
-        @BeforeClass
-        @JvmStatic
-        fun setUpProvider() {
-            val context = InstrumentationRegistry.getInstrumentation().targetContext
-            provider = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)!!
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun closeProvider() {
-            provider.closeCompat()
-        }
-
-    }
-
-    private val account = Account("LocalCalendarTest", ACCOUNT_TYPE_LOCAL)
-    private lateinit var calendar: LocalCalendar
-
-    @Before
-    fun prepare() {
-        val uri = AndroidCalendar.create(account, provider, ContentValues())
-        calendar = AndroidCalendar.findByID(account, provider, LocalCalendar.Factory, ContentUris.parseId(uri))
-    }
-
-    @After
-    fun shutdown() {
-        calendar.delete()
-    }
-
-
-    @Test
-    fun testDeleteDirtyEventsWithoutInstances_NoInstances_CancelledExceptions() {
-        // create recurring event with only deleted/cancelled instances
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 3 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=3"))
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220120T010203Z")
-                dtStart = DtStart("20220120T010203Z")
-                summary = "Cancelled exception on 1st day"
-                status = Status.VEVENT_CANCELLED
-            })
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220121T010203Z")
-                dtStart = DtStart("20220121T010203Z")
-                summary = "Cancelled exception on 2nd day"
-                status = Status.VEVENT_CANCELLED
-            })
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220122T010203Z")
-                dtStart = DtStart("20220122T010203Z")
-                summary = "Cancelled exception on 3rd day"
-                status = Status.VEVENT_CANCELLED
-            })
-        }
-        val localEvent = LocalEvent(calendar, event, "filename.ics", null, null, LocalResource.FLAG_REMOTELY_PRESENT)
-        localEvent.add()
-        val eventId = localEvent.id!!
-
-        // set event as dirty
-        provider.update(ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId), ContentValues(1).apply {
-            put(Events.DIRTY, 1)
-        }, null, null)
-
-        // this method should mark the event as deleted
-        calendar.deleteDirtyEventsWithoutInstances()
-
-        // verify that event is now marked as deleted
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId),
-            arrayOf(Events.DELETED), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToNext()
-            assertEquals(1, cursor.getInt(0))
-        }
-    }
-
-    @Test
-    // Flaky, Needs single or rec init of CalendarProvider (InitCalendarProviderRule)
-    fun testDeleteDirtyEventsWithoutInstances_Recurring_Instances() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 3 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=3"))
-        }
-        val localEvent = LocalEvent(calendar, event, "filename.ics", null, null, LocalResource.FLAG_REMOTELY_PRESENT)
-        localEvent.add()
-        val eventId = localEvent.id!!
-
-        // set event as dirty
-        provider.update(ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId), ContentValues(1).apply {
-            put(Events.DIRTY, 1)
-        }, null, null)
-
-        // this method should mark the event as deleted
-        calendar.deleteDirtyEventsWithoutInstances()
-
-        // verify that event is not marked as deleted
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId),
-            arrayOf(Events.DELETED), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToNext()
-            assertEquals(0, cursor.getInt(0))
-        }
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/LocalEventTest.kt

@@ -1,472 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentUris
-import android.content.ContentValues
-import android.os.Build
-import android.provider.CalendarContract
-import android.provider.CalendarContract.ACCOUNT_TYPE_LOCAL
-import android.provider.CalendarContract.Events
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.InitCalendarProviderRule
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.Event
-import at.bitfire.ical4android.util.MiscUtils.closeCompat
-import at.techbee.jtx.JtxContract.asSyncAdapter
-import net.fortuna.ical4j.model.Date
-import net.fortuna.ical4j.model.DateList
-import net.fortuna.ical4j.model.parameter.Value
-import net.fortuna.ical4j.model.property.*
-import org.junit.*
-import org.junit.Assert.*
-import org.junit.rules.TestRule
-import java.util.*
-
-class LocalEventTest {
-
-    companion object {
-
-        @JvmField
-        @ClassRule
-        val initCalendarProviderRule: TestRule = InitCalendarProviderRule.getInstance()
-
-        private val account = Account("LocalCalendarTest", ACCOUNT_TYPE_LOCAL)
-
-        private lateinit var provider: ContentProviderClient
-        private lateinit var calendar: LocalCalendar
-
-        @BeforeClass
-        @JvmStatic
-        fun connect() {
-            val context = InstrumentationRegistry.getInstrumentation().targetContext
-            provider = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)!!
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun disconnect() {
-            provider.closeCompat()
-        }
-    }
-
-    @Before
-    fun createCalendar() {
-        val uri = AndroidCalendar.create(account, provider, ContentValues())
-        calendar = AndroidCalendar.findByID(account, provider, LocalCalendar.Factory, ContentUris.parseId(uri))
-    }
-
-    @After
-    fun removeCalendar() {
-        calendar.delete()
-    }
-
-
-    @Test
-    fun testNumDirectInstances_SingleInstance() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 1 instance"
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertEquals(1, LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    fun testNumDirectInstances_Recurring() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 5 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=5"))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertEquals(5, LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    fun testNumDirectInstances_Recurring_Endless() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event without end"
-            rRules.add(RRule("FREQ=DAILY"))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertNull(LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    // flaky, needs InitCalendarProviderRule
-    fun testNumDirectInstances_Recurring_LateEnd() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 53 years"
-            rRules.add(RRule("FREQ=YEARLY;UNTIL=20740119T010203Z"))     // year 2074 is not supported by Android <11 Calendar Storage
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
-            assertEquals(52, LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-        else
-            assertNull(LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    // flaky, needs InitCalendarProviderRule
-    fun testNumDirectInstances_Recurring_ManyInstances() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 2 years"
-            rRules.add(RRule("FREQ=DAILY;UNTIL=20240120T010203Z"))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-        val number = LocalEvent.numDirectInstances(provider, account, localEvent.id!!)
-
-        // Some android versions (i.e. <=Q and S) return 365*2 instances (wrong, 365*2+1 => correct),
-        // but we are satisfied with either result for now
-        assertTrue(number == 365*2 || number == 365*2+1)
-    }
-
-    @Test
-    // flaky, needs InitCalendarProviderRule
-    fun testNumDirectInstances_RecurringWithExdate() {
-        val event = Event().apply {
-            dtStart = DtStart(Date("20220120T010203Z"))
-            summary = "Event with 5 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=5"))
-            exDates.add(ExDate(DateList("20220121T010203Z", Value.DATE_TIME)))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertEquals(4, LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    fun testNumDirectInstances_RecurringWithExceptions() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 5 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=5"))
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220122T010203Z")
-                dtStart = DtStart("20220122T130203Z")
-                summary = "Exception on 3rd day"
-            })
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220124T010203Z")
-                dtStart = DtStart("20220122T160203Z")
-                summary = "Exception on 5th day"
-            })
-        }
-        val localEvent = LocalEvent(calendar, event, "filename.ics", null, null, 0)
-        localEvent.add()
-
-        assertEquals(5-2, LocalEvent.numDirectInstances(provider, account, localEvent.id!!))
-    }
-
-
-    @Test
-    // flaky, needs InitCalendarProviderRule
-    fun testNumInstances_SingleInstance() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 1 instance"
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertEquals(1, LocalEvent.numInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    fun testNumInstances_Recurring() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 5 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=5"))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertEquals(5, LocalEvent.numInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    fun testNumInstances_Recurring_Endless() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with infinite instances"
-            rRules.add(RRule("FREQ=YEARLY"))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertNull(LocalEvent.numInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    // flaky, needs InitCalendarProviderRule
-    fun testNumInstances_Recurring_LateEnd() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event over 22 years"
-            rRules.add(RRule("FREQ=YEARLY;UNTIL=20740119T010203Z"))     // year 2074 not supported by Android <11 Calendar Storage
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R)
-            assertEquals(52, LocalEvent.numInstances(provider, account, localEvent.id!!))
-        else
-            assertNull(LocalEvent.numInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    // flaky, needs InitCalendarProviderRule
-    fun testNumInstances_Recurring_ManyInstances() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event over two years"
-            rRules.add(RRule("FREQ=DAILY;UNTIL=20240120T010203Z"))
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        assertEquals(
-            if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.Q)
-                365*2       // Android <10: does not include UNTIL (incorrect!)
-            else
-                365*2 + 1,  // Android ≥10: includes UNTIL (correct)
-            LocalEvent.numInstances(provider, account, localEvent.id!!))
-    }
-
-    @Test
-    fun testNumInstances_RecurringWithExceptions() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 6 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=6"))
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220122T010203Z")
-                dtStart = DtStart("20220122T130203Z")
-                summary = "Exception on 3rd day"
-            })
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220124T010203Z")
-                dtStart = DtStart("20220122T160203Z")
-                summary = "Exception on 5th day"
-            })
-        }
-        val localEvent = LocalEvent(calendar, event, "filename.ics", null, null, 0)
-        val uri = localEvent.add()
-
-        calendar.findById(localEvent.id!!)
-
-        assertEquals(6, LocalEvent.numInstances(provider, account, localEvent.id!!))
-    }
-
-
-    @Test
-    fun testMarkEventAsDeleted() {
-        // Create event
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "A fine event"
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()
-
-        // Delete event
-        LocalEvent.markAsDeleted(provider, account, localEvent.id!!)
-
-        // Get the status of whether the event is deleted
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI, localEvent.id!!).asSyncAdapter(account),
-            arrayOf(Events.DELETED),
-            null,
-            null, null
-        )!!.use { cursor ->
-            cursor.moveToFirst()
-            assertEquals(1, cursor.getInt(0))
-        }
-    }
-
-
-    @Test
-    fun testPrepareForUpload_NoUid() {
-        // create event
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event without uid"
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add()    // save it to calendar storage
-
-        // prepare for upload - this should generate a new random uuid, returned as filename
-        val fileNameWithSuffix = localEvent.prepareForUpload()
-        val fileName = fileNameWithSuffix.removeSuffix(".ics")
-
-        // throws an exception if fileName is not an UUID
-        UUID.fromString(fileName)
-
-        // UID in calendar storage should be the same as file name
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI, localEvent.id!!).asSyncAdapter(account),
-            arrayOf(Events.UID_2445), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToFirst()
-            assertEquals(fileName, cursor.getString(0))
-        }
-    }
-
-    @Test
-    fun testPrepareForUpload_NormalUid() {
-        // create event
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with normal uid"
-            uid = "some-event@hostname.tld"     // old UID format, UUID would be new format
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add() // save it to calendar storage
-
-        // prepare for upload - this should use the UID for the file name
-        val fileNameWithSuffix = localEvent.prepareForUpload()
-        val fileName = fileNameWithSuffix.removeSuffix(".ics")
-
-        assertEquals(event.uid, fileName)
-
-        // UID in calendar storage should still be set, too
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI, localEvent.id!!).asSyncAdapter(account),
-            arrayOf(Events.UID_2445), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToFirst()
-            assertEquals(fileName, cursor.getString(0))
-        }
-    }
-
-    @Test
-    fun testPrepareForUpload_UidHasDangerousChars() {
-        // create event
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with funny uid"
-            uid = "https://www.example.com/events/asdfewfe-cxyb-ewrws-sadfrwerxyvser-asdfxye-"
-        }
-        val localEvent = LocalEvent(calendar, event, null, null, null, 0)
-        localEvent.add() // save it to calendar storage
-
-        // prepare for upload - this should generate a new random uuid, returned as filename
-        val fileNameWithSuffix = localEvent.prepareForUpload()
-        val fileName = fileNameWithSuffix.removeSuffix(".ics")
-
-        // throws an exception if fileName is not an UUID
-        UUID.fromString(fileName)
-
-        // UID in calendar storage shouldn't have been changed
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI, localEvent.id!!).asSyncAdapter(account),
-            arrayOf(Events.UID_2445), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToFirst()
-            assertEquals(event.uid, cursor.getString(0))
-        }
-    }
-
-
-    @Test
-    fun testDeleteDirtyEventsWithoutInstances_NoInstances_Exdate() {
-        // TODO
-    }
-
-    @Test
-    fun testDeleteDirtyEventsWithoutInstances_NoInstances_CancelledExceptions() {
-        // create recurring event with only deleted/cancelled instances
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 3 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=3"))
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220120T010203Z")
-                dtStart = DtStart("20220120T010203Z")
-                summary = "Cancelled exception on 1st day"
-                status = Status.VEVENT_CANCELLED
-            })
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220121T010203Z")
-                dtStart = DtStart("20220121T010203Z")
-                summary = "Cancelled exception on 2nd day"
-                status = Status.VEVENT_CANCELLED
-            })
-            exceptions.add(Event().apply {
-                recurrenceId = RecurrenceId("20220122T010203Z")
-                dtStart = DtStart("20220122T010203Z")
-                summary = "Cancelled exception on 3rd day"
-                status = Status.VEVENT_CANCELLED
-            })
-        }
-        val localEvent = LocalEvent(calendar, event, "filename.ics", null, null, LocalResource.FLAG_REMOTELY_PRESENT)
-        localEvent.add()
-        val eventId = localEvent.id!!
-
-        // set event as dirty
-        provider.update(ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId), ContentValues(1).apply {
-            put(Events.DIRTY, 1)
-        }, null, null)
-
-        // this method should mark the event as deleted
-        calendar.deleteDirtyEventsWithoutInstances()
-
-        // verify that event is now marked as deleted
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId),
-            arrayOf(Events.DELETED), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToNext()
-            assertEquals(1, cursor.getInt(0))
-        }
-    }
-
-    @Test
-    fun testDeleteDirtyEventsWithoutInstances_Recurring_Instances() {
-        val event = Event().apply {
-            dtStart = DtStart("20220120T010203Z")
-            summary = "Event with 3 instances"
-            rRules.add(RRule("FREQ=DAILY;COUNT=3"))
-        }
-        val localEvent = LocalEvent(calendar, event, "filename.ics", null, null, LocalResource.FLAG_REMOTELY_PRESENT)
-        localEvent.add()
-        val eventId = localEvent.id!!
-
-        // set event as dirty
-        provider.update(ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId), ContentValues(1).apply {
-            put(Events.DIRTY, 1)
-        }, null, null)
-
-        // this method should mark the event as deleted
-        calendar.deleteDirtyEventsWithoutInstances()
-
-        // verify that event is not marked as deleted
-        provider.query(
-            ContentUris.withAppendedId(Events.CONTENT_URI.asSyncAdapter(account), eventId),
-            arrayOf(Events.DELETED), null, null, null
-        )!!.use { cursor ->
-            cursor.moveToNext()
-            assertEquals(0, cursor.getInt(0))
-        }
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/LocalGroupTest.kt

@@ -1,267 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.Manifest
-import android.content.ContentProviderClient
-import android.content.ContentUris
-import android.content.ContentValues
-import android.provider.ContactsContract
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.vcard4android.BatchOperation
-import at.bitfire.vcard4android.CachedGroupMembership
-import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.GroupMethod
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.*
-import org.junit.Assert.*
-import javax.inject.Inject
-
-@HiltAndroidTest
-class LocalGroupTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @Inject
-    lateinit var settingsManager: SettingsManager
-
-    @Before
-    fun inject() {
-        hiltRule.inject()
-    }
-
-    companion object {
-        @JvmField
-        @ClassRule
-        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
-
-        private lateinit var provider: ContentProviderClient
-
-        private lateinit var addressBookGroupsAsCategories: LocalTestAddressBook
-        private lateinit var addressBookGroupsAsVCards: LocalTestAddressBook
-
-        @BeforeClass
-        @JvmStatic
-        fun connect() {
-            val context = InstrumentationRegistry.getInstrumentation().targetContext
-            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
-            assertNotNull(provider)
-
-            addressBookGroupsAsCategories = LocalTestAddressBook(context, provider, GroupMethod.CATEGORIES)
-            addressBookGroupsAsVCards = LocalTestAddressBook(context, provider, GroupMethod.GROUP_VCARDS)
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun disconnect() {
-            @Suppress("DEPRECATION")
-            provider.release()
-        }
-    }
-
-    private fun newGroup(addressBook: LocalAddressBook = addressBookGroupsAsCategories): LocalGroup =
-        LocalGroup(addressBook,
-            Contact().apply {
-                displayName = "Test Group"
-            }, null, null, 0
-        ).apply {
-            add()
-        }
-
-
-
-    @Before
-    fun clearContacts() {
-        addressBookGroupsAsCategories.clear()
-        addressBookGroupsAsVCards.clear()
-    }
-
-
-    @Test
-    fun testApplyPendingMemberships_addPendingMembership() {
-        val ab = addressBookGroupsAsVCards
-
-        val contact1 = LocalContact(ab, Contact().apply {
-            uid = "test1"
-            displayName = "Test"
-        }, "test1.vcf", null, 0)
-        contact1.add()
-
-        val group = newGroup(ab)
-        // set pending membership of contact1
-        ab.provider!!.update(
-            ContentUris.withAppendedId(ab.groupsSyncUri(), group.id!!),
-            ContentValues().apply {
-                put(LocalGroup.COLUMN_PENDING_MEMBERS, LocalGroup.PendingMemberships(setOf("test1")).toString())
-            },
-            null, null
-        )
-
-        // pending membership -> contact1 should be added to group
-        LocalGroup.applyPendingMemberships(ab)
-
-        // check group membership
-        ab.provider!!.query(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(GroupMembership.GROUP_ROW_ID, GroupMembership.RAW_CONTACT_ID),
-            "${GroupMembership.MIMETYPE}=?", arrayOf(GroupMembership.CONTENT_ITEM_TYPE),
-            null
-        )!!.use { cursor ->
-            assertTrue(cursor.moveToNext())
-            assertEquals(group.id, cursor.getLong(0))
-            assertEquals(contact1.id, cursor.getLong(1))
-
-            assertFalse(cursor.moveToNext())
-        }
-        // check cached group membership
-        ab.provider!!.query(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(CachedGroupMembership.GROUP_ID, CachedGroupMembership.RAW_CONTACT_ID),
-            "${CachedGroupMembership.MIMETYPE}=?", arrayOf(CachedGroupMembership.CONTENT_ITEM_TYPE),
-            null
-        )!!.use { cursor ->
-            assertTrue(cursor.moveToNext())
-            assertEquals(group.id, cursor.getLong(0))
-            assertEquals(contact1.id, cursor.getLong(1))
-
-            assertFalse(cursor.moveToNext())
-        }
-    }
-
-    @Test
-    fun testApplyPendingMemberships_removeMembership() {
-        val ab = addressBookGroupsAsVCards
-
-        val contact1 = LocalContact(ab, Contact().apply {
-            uid = "test1"
-            displayName = "Test"
-        }, "test1.vcf", null, 0)
-        contact1.add()
-
-        val group = newGroup(ab)
-
-        // add contact1 to group
-        val batch = BatchOperation(ab.provider!!)
-        contact1.addToGroup(batch, group.id!!)
-        batch.commit()
-
-        // no pending memberships -> membership should be removed
-        LocalGroup.applyPendingMemberships(ab)
-
-        // check group membership
-        ab.provider!!.query(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(GroupMembership.GROUP_ROW_ID, GroupMembership.RAW_CONTACT_ID),
-            "${GroupMembership.MIMETYPE}=?", arrayOf(GroupMembership.CONTENT_ITEM_TYPE),
-            null
-        )!!.use { cursor ->
-            assertFalse(cursor.moveToNext())
-        }
-        // check cached group membership
-        ab.provider!!.query(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(CachedGroupMembership.GROUP_ID, CachedGroupMembership.RAW_CONTACT_ID),
-            "${CachedGroupMembership.MIMETYPE}=?", arrayOf(CachedGroupMembership.CONTENT_ITEM_TYPE),
-            null
-        )!!.use { cursor ->
-            assertFalse(cursor.moveToNext())
-        }
-    }
-
-
-    @Test
-    fun testClearDirty_addCachedGroupMembership() {
-        val ab = addressBookGroupsAsCategories
-        val group = newGroup(ab)
-
-        val contact1 = LocalContact(ab, Contact().apply { displayName = "Test" }, "fn.vcf", null, 0)
-        contact1.add()
-
-        // insert group membership, but no cached group membership
-        ab.provider!!.insert(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), ContentValues().apply {
-                put(GroupMembership.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE)
-                put(GroupMembership.RAW_CONTACT_ID, contact1.id)
-                put(GroupMembership.GROUP_ROW_ID, group.id)
-            }
-        )
-
-        group.clearDirty(null, null)
-
-        // check cached group membership
-        ab.provider!!.query(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(CachedGroupMembership.GROUP_ID, CachedGroupMembership.RAW_CONTACT_ID),
-            "${CachedGroupMembership.MIMETYPE}=?", arrayOf(CachedGroupMembership.CONTENT_ITEM_TYPE),
-            null
-        )!!.use { cursor ->
-            assertTrue(cursor.moveToNext())
-            assertEquals(group.id, cursor.getLong(0))
-            assertEquals(contact1.id, cursor.getLong(1))
-
-            assertFalse(cursor.moveToNext())
-        }
-    }
-
-    @Test
-    fun testClearDirty_removeCachedGroupMembership() {
-        val ab = addressBookGroupsAsCategories
-        val group = newGroup(ab)
-
-        val contact1 = LocalContact(ab, Contact().apply { displayName = "Test" }, "fn.vcf", null, 0)
-        contact1.add()
-
-        // insert cached group membership, but no group membership
-        ab.provider!!.insert(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), ContentValues().apply {
-                put(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
-                put(CachedGroupMembership.RAW_CONTACT_ID, contact1.id)
-                put(CachedGroupMembership.GROUP_ID, group.id)
-            }
-        )
-
-        group.clearDirty(null, null)
-
-        // cached group membership should be gone
-        ab.provider!!.query(
-            ab.syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(CachedGroupMembership.GROUP_ID, CachedGroupMembership.RAW_CONTACT_ID),
-            "${CachedGroupMembership.MIMETYPE}=?", arrayOf(CachedGroupMembership.CONTENT_ITEM_TYPE),
-            null
-        )!!.use { cursor ->
-            assertFalse(cursor.moveToNext())
-        }
-    }
-
-
-    @Test
-    fun testMarkMembersDirty() {
-        val ab = addressBookGroupsAsCategories
-        val group = newGroup(ab)
-
-        val contact1 = LocalContact(ab, Contact().apply { displayName = "Test" }, "fn.vcf", null, 0)
-        contact1.add()
-
-        val batch = BatchOperation(ab.provider!!)
-        contact1.addToGroup(batch, group.id!!)
-        batch.commit()
-
-        assertEquals(0, ab.findDirty().size)
-        group.markMembersDirty()
-        assertEquals(contact1.id, ab.findDirty().first().id)
-    }
-
-
-    @Test
-    fun testPrepareForUpload() {
-        val group = newGroup()
-        assertNull(group.getContact().uid)
-
-        val fileName = group.prepareForUpload()
-        val newUid = group.getContact().uid
-        assertNotNull(newUid)
-        assertEquals("$newUid.vcf", fileName)
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/LocalTestAddressBook.kt

@@ -1,38 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.Context
-import at.bitfire.vcard4android.GroupMethod
-
-class LocalTestAddressBook(
-    context: Context,
-    provider: ContentProviderClient,
-    override val groupMethod: GroupMethod
-): LocalAddressBook(context, ACCOUNT, provider) {
-
-    companion object {
-        val ACCOUNT = Account("LocalTestAddressBook", "at.bitfire.davdroid.test")
-    }
-
-    override var mainAccount: Account?
-        get() = throw NotImplementedError()
-        set(_) = throw NotImplementedError()
-
-    override var readOnly: Boolean
-        get() = false
-        set(_) = throw NotImplementedError()
-
-
-    fun clear() {
-        for (contact in queryContacts(null, null))
-            contact.delete()
-        for (group in queryGroups(null, null))
-            group.delete()
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/contactrow/CachedGroupMembershipHandlerTest.kt

@@ -1,63 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource.contactrow
-
-import android.Manifest
-import android.content.ContentProviderClient
-import android.content.ContentValues
-import android.provider.ContactsContract
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import at.bitfire.davdroid.resource.LocalContact
-import at.bitfire.davdroid.resource.LocalTestAddressBook
-import at.bitfire.vcard4android.CachedGroupMembership
-import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.GroupMethod
-import org.junit.*
-import org.junit.Assert.assertArrayEquals
-
-class CachedGroupMembershipHandlerTest {
-
-    companion object {
-
-        @JvmField
-        @ClassRule
-        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
-
-        private lateinit var provider: ContentProviderClient
-        private lateinit var addressBook: LocalTestAddressBook
-
-        @BeforeClass
-        @JvmStatic
-        fun connect() {
-            val context = InstrumentationRegistry.getInstrumentation().context
-            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
-            Assert.assertNotNull(provider)
-
-            addressBook = LocalTestAddressBook(context, provider, GroupMethod.GROUP_VCARDS)
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun disconnect() {
-            @Suppress("DEPRECATION")
-            provider.release()
-        }
-
-    }
-
-
-    @Test
-    fun testMembership() {
-        val contact = Contact()
-        val localContact = LocalContact(addressBook, contact, null, null, 0)
-        CachedGroupMembershipHandler(localContact).handle(ContentValues().apply {
-            put(CachedGroupMembership.GROUP_ID, 123456)
-            put(CachedGroupMembership.RAW_CONTACT_ID, 789)
-        }, contact)
-        assertArrayEquals(arrayOf(123456L), localContact.cachedGroupMemberships.toArray())
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/contactrow/GroupMembershipBuilderTest.kt

@@ -1,75 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource.contactrow
-
-import android.Manifest
-import android.content.ContentProviderClient
-import android.net.Uri
-import android.provider.ContactsContract
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import at.bitfire.davdroid.resource.LocalTestAddressBook
-import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.GroupMethod
-import org.junit.*
-import org.junit.Assert.assertEquals
-
-class GroupMembershipBuilderTest {
-
-    companion object {
-        @JvmField
-        @ClassRule
-        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
-
-        private lateinit var provider: ContentProviderClient
-
-        private lateinit var addressBookGroupsAsCategories: LocalTestAddressBook
-        private lateinit var addressBookGroupsAsVCards: LocalTestAddressBook
-
-        @BeforeClass
-        @JvmStatic
-        fun connect() {
-            val context = InstrumentationRegistry.getInstrumentation().targetContext
-            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
-            Assert.assertNotNull(provider)
-
-            addressBookGroupsAsCategories = LocalTestAddressBook(context, provider, GroupMethod.CATEGORIES)
-            addressBookGroupsAsVCards = LocalTestAddressBook(context, provider, GroupMethod.GROUP_VCARDS)
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun disconnect() {
-            @Suppress("DEPRECATION")
-            provider.release()
-        }
-    }
-
-
-    @Test
-    fun testCategories_GroupsAsCategories() {
-        val contact = Contact().apply {
-            categories += "TEST GROUP"
-        }
-        GroupMembershipBuilder(Uri.EMPTY, null, contact, addressBookGroupsAsCategories, false).build().also { result ->
-            assertEquals(1, result.size)
-            assertEquals(GroupMembership.CONTENT_ITEM_TYPE, result[0].values[GroupMembership.MIMETYPE])
-            assertEquals(addressBookGroupsAsCategories.findOrCreateGroup("TEST GROUP"), result[0].values[GroupMembership.GROUP_ROW_ID])
-        }
-    }
-
-    @Test
-    fun testCategories_GroupsAsVCards() {
-        val contact = Contact().apply {
-            categories += "TEST GROUP"
-        }
-        GroupMembershipBuilder(Uri.EMPTY, null, contact, addressBookGroupsAsVCards, false).build().also { result ->
-            // group membership is constructed during post-processing
-            assertEquals(0, result.size)
-        }
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/resource/contactrow/GroupMembershipHandlerTest.kt

@@ -1,79 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource.contactrow
-
-import android.Manifest
-import android.content.ContentProviderClient
-import android.content.ContentValues
-import android.provider.ContactsContract
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.test.rule.GrantPermissionRule
-import at.bitfire.davdroid.resource.LocalContact
-import at.bitfire.davdroid.resource.LocalTestAddressBook
-import at.bitfire.vcard4android.CachedGroupMembership
-import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.GroupMethod
-import org.junit.*
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertTrue
-
-class GroupMembershipHandlerTest {
-
-    @JvmField
-    @Rule
-    val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
-
-    private lateinit var provider: ContentProviderClient
-
-    private lateinit var addressBookGroupsAsCategories: LocalTestAddressBook
-    private var addressBookGroupsAsCategoriesGroup: Long = -1
-
-    private lateinit var addressBookGroupsAsVCards: LocalTestAddressBook
-
-    @Before
-    fun connect() {
-        val context = InstrumentationRegistry.getInstrumentation().targetContext
-        provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
-        Assert.assertNotNull(provider)
-
-        addressBookGroupsAsCategories = LocalTestAddressBook(context, provider, GroupMethod.CATEGORIES)
-        addressBookGroupsAsCategoriesGroup = addressBookGroupsAsCategories.findOrCreateGroup("TEST GROUP")
-
-        addressBookGroupsAsVCards = LocalTestAddressBook(context, provider, GroupMethod.GROUP_VCARDS)
-    }
-
-    @After
-    fun disconnect() {
-        @Suppress("DEPRECATION")
-        provider.release()
-    }
-
-
-    @Test
-    fun testMembership_GroupsAsCategories() {
-        val contact = Contact()
-        val localContact = LocalContact(addressBookGroupsAsCategories, contact, null, null, 0)
-        GroupMembershipHandler(localContact).handle(ContentValues().apply {
-            put(CachedGroupMembership.GROUP_ID, addressBookGroupsAsCategoriesGroup)
-            put(CachedGroupMembership.RAW_CONTACT_ID, -1)
-        }, contact)
-        assertArrayEquals(arrayOf(addressBookGroupsAsCategoriesGroup), localContact.groupMemberships.toArray())
-        assertArrayEquals(arrayOf("TEST GROUP"), contact.categories.toArray())
-    }
-
-
-    @Test
-    fun testMembership_GroupsAsVCards() {
-        val contact = Contact()
-        val localContact = LocalContact(addressBookGroupsAsVCards, contact, null, null, 0)
-        GroupMembershipHandler(localContact).handle(ContentValues().apply {
-            put(CachedGroupMembership.GROUP_ID, 12345)    // because the group name is not queried and put into CATEGORIES, the group doesn't have to really exist
-            put(CachedGroupMembership.RAW_CONTACT_ID, -1)
-        }, contact)
-        assertArrayEquals(arrayOf(12345L), localContact.groupMemberships.toArray())
-        assertTrue(contact.categories.isEmpty())
-    }
-
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/servicedetection/RefreshCollectionsWorkerTest.kt

@@ -1,755 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.servicedetection
-
-import android.content.Context
-import android.security.NetworkSecurityPolicy
-import android.util.Log
-import androidx.hilt.work.HiltWorkerFactory
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.work.Configuration
-import androidx.work.testing.WorkManagerTestInitHelper
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.HomeSet
-import at.bitfire.davdroid.db.Principal
-import at.bitfire.davdroid.db.Service
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.ui.NotificationUtils
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.mockk.every
-import io.mockk.junit4.MockKRule
-import io.mockk.mockk
-import okhttp3.mockwebserver.Dispatcher
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-import okhttp3.mockwebserver.RecordedRequest
-import org.apache.commons.lang3.StringUtils
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Assume
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import javax.inject.Inject
-
-@HiltAndroidTest
-class RefreshCollectionsWorkerTest {
-    
-    @get:Rule
-    var hiltRule = HiltAndroidRule(this)
-    @get:Rule
-    val mockkRule = MockKRule(this)
-
-    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    @Inject
-    lateinit var workerFactory: HiltWorkerFactory
-    
-    @Before
-    fun setUp() {
-        hiltRule.inject()
-
-        // The test application is an instance of HiltTestApplication, which doesn't initialize notification channels.
-        // However, we need notification channels for the ongoing work notifications.
-        NotificationUtils.createChannels(context)
-
-        // Initialize WorkManager for instrumentation tests.
-        val config = Configuration.Builder()
-            .setMinimumLoggingLevel(Log.DEBUG)
-            .setWorkerFactory(workerFactory)
-            .build()
-        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
-    }
-
-    
-    // Test dependencies
-
-    companion object {
-        private const val PATH_CALDAV = "/caldav"
-        private const val PATH_CARDDAV = "/carddav"
-
-        private const val SUBPATH_PRINCIPAL = "/principal"
-        private const val SUBPATH_PRINCIPAL_INACCESSIBLE = "/inaccessible-principal"
-        private const val SUBPATH_PRINCIPAL_WITHOUT_COLLECTIONS = "/principal2"
-        private const val SUBPATH_ADDRESSBOOK_HOMESET = "/addressbooks-homeset"
-        private const val SUBPATH_ADDRESSBOOK_HOMESET_EMPTY = "/addressbooks-homeset-empty"
-        private const val SUBPATH_ADDRESSBOOK = "/addressbooks/my-contacts"
-        private const val SUBPATH_ADDRESSBOOK_INACCESSIBLE = "/addressbooks/inaccessible-contacts"
-    }
-
-    @Inject
-    lateinit var db: AppDatabase
-
-    @Inject
-    lateinit var settings: SettingsManager
-
-    var mockServer =  MockWebServer()
-
-    lateinit var client: HttpClient
-
-    @Before
-    fun mockServerSetup() {
-        // Start mock web server
-        mockServer.dispatcher = TestDispatcher()
-        mockServer.start()
-
-        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build()
-
-        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
-    }
-
-    @After
-    fun cleanUp() {
-        mockServer.shutdown()
-        db.close()
-    }
-
-    
-    // Actual tests
-    
-    /* Often fails for unknown reasons:
-    @Test
-    fun testRefreshCollections_enqueuesWorker() {
-        val service = createTestService(Service.TYPE_CALDAV)!!
-
-        val (workerName, enqueueOp) = RefreshCollectionsWorker.enqueue(context, service.id)
-        enqueueOp.result.get()
-        assertTrue(workScheduledOrRunningOrSuccessful(context, workerName))
-    }*/
-
-    @Test
-    fun testDiscoverHomesets() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-        val baseUrl = mockServer.url(PATH_CARDDAV + SUBPATH_PRINCIPAL)
-
-        // Query home sets
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .discoverHomesets(baseUrl)
-
-        // Check home sets have been saved to database
-        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET/"), db.homeSetDao().getByService(service.id).first().url)
-        assertEquals(1, db.homeSetDao().getByService(service.id).size)
-    }
-
-
-    // refreshHomesetsAndTheirCollections
-
-    @Test
-    fun refreshHomesetsAndTheirCollections_addsNewCollection() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // save homeset in DB
-        val homesetId = db.homeSetDao().insert(
-            HomeSet(id=0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
-
-        // Check the collection defined in homeset is now in the database
-        assertEquals(
-            Collection(
-                1,
-                service.id,
-                homesetId,
-                1, // will have gotten an owner too
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-                displayName = "My Contacts",
-                description = "My Contacts Description"
-            ),
-            db.collectionDao().getByService(service.id).first()
-        )
-    }
-
-    @Test
-    fun refreshHomesetsAndTheirCollections_updatesExistingCollection() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // save "old" collection in DB
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-                displayName = "My Contacts",
-                description = "My Contacts Description"
-            )
-        )
-
-        // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
-
-        // Check the collection got updated
-        assertEquals(
-            Collection(
-                collectionId,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-                displayName = "My Contacts",
-                description = "My Contacts Description"
-            ),
-            db.collectionDao().get(collectionId)
-        )
-    }
-
-    @Test
-    fun refreshHomesetsAndTheirCollections_preservesCollectionFlags() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // save "old" collection in DB - with set flags
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-                displayName = "My Contacts",
-                description = "My Contacts Description",
-                forceReadOnly = true,
-                sync = true
-            )
-        )
-
-        // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
-
-        // Check the collection got updated
-        assertEquals(
-            Collection(
-                collectionId,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-                displayName = "My Contacts",
-                description = "My Contacts Description",
-                forceReadOnly = true,
-                sync = true
-            ),
-            db.collectionDao().get(collectionId)
-        )
-    }
-
-    @Test
-    fun refreshHomesetsAndTheirCollections_marksRemovedCollectionsAsHomeless() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // save homeset in DB - which is empty (zero address books) on the serverside
-        val homesetId = db.homeSetDao().insert(
-            HomeSet(id=0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET_EMPTY"))
-        )
-
-        // place collection in DB - as part of the homeset
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                homesetId,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-            )
-        )
-
-        // Refresh - should mark collection as homeless, because serverside homeset is empty
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
-
-        // Check the collection, is now marked as homeless
-        assertEquals(null, db.collectionDao().get(collectionId)!!.homeSetId)
-    }
-
-    @Test
-    fun refreshHomesetsAndTheirCollections_addsOwnerUrls() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // save a homeset in DB
-        val homesetId = db.homeSetDao().insert(
-            HomeSet(id=0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        // place collection in DB - as part of the homeset
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                homesetId, // part of above home set
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-            )
-        )
-
-        // Refresh - homesets and their collections
-        assertEquals(0, db.principalDao().getByService(service.id).size)
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
-
-        // Check principal saved and the collection was updated with its reference
-        val principals = db.principalDao().getByService(service.id)
-        assertEquals(1, principals.size)
-        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), principals[0].url)
-        assertEquals(null, principals[0].displayName)
-        assertEquals(
-            principals[0].id,
-            db.collectionDao().get(collectionId)!!.ownerId
-        )
-    }
-
-
-    // refreshHomelessCollections
-
-    @Test
-    fun refreshHomelessCollections_updatesExistingCollection() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // place homeless collection in DB
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-            )
-        )
-
-        // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomelessCollections()
-
-        // Check the collection got updated - with display name and description
-        assertEquals(
-            Collection(
-                collectionId,
-                service.id,
-                null,
-                1, // will have gotten an owner too
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-                displayName = "My Contacts",
-                description = "My Contacts Description"
-            ),
-            db.collectionDao().get(collectionId)
-        )
-    }
-
-    @Test
-    fun refreshHomelessCollections_deletesInaccessibleCollections() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // place homeless collection in DB - it is also inaccessible
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_INACCESSIBLE")
-            )
-        )
-
-        // Refresh - should delete collection
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomelessCollections()
-
-        // Check the collection got deleted
-        assertEquals(null, db.collectionDao().get(collectionId))
-    }
-
-    @Test
-    fun refreshHomelessCollections_addsOwnerUrls() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // place homeless collection in DB
-        val collectionId = db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                null,
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
-            )
-        )
-
-        // Refresh homeless collections
-        assertEquals(0, db.principalDao().getByService(service.id).size)
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomelessCollections()
-
-        // Check principal saved and the collection was updated with its reference
-        val principals = db.principalDao().getByService(service.id)
-        assertEquals(1, principals.size)
-        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), principals[0].url)
-        assertEquals(null, principals[0].displayName)
-        assertEquals(
-            principals[0].id,
-            db.collectionDao().get(collectionId)!!.ownerId
-        )
-    }
-
-
-    // refreshPrincipals
-
-    @Test
-    fun refreshPrincipals_inaccessiblePrincipal() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // place principal without display name in db
-        val principalId = db.principalDao().insert(
-            Principal(
-                0,
-                service.id,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL_INACCESSIBLE"), // no trailing slash
-                null // no display name for now
-            )
-        )
-        // add an associated collection - as the principal is rightfully removed otherwise
-        db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                principalId, // create association with principal
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"), // with trailing slash
-            )
-        )
-
-        // Refresh principals
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshPrincipals()
-
-        // Check principal was not updated
-        val principals = db.principalDao().getByService(service.id)
-        assertEquals(1, principals.size)
-        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL_INACCESSIBLE"), principals[0].url)
-        assertEquals(null, principals[0].displayName)
-    }
-
-    @Test
-    fun refreshPrincipals_updatesPrincipal() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // place principal without display name in db
-        val principalId = db.principalDao().insert(
-            Principal(
-                0,
-                service.id,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), // no trailing slash
-                null // no display name for now
-            )
-        )
-        // add an associated collection - as the principal is rightfully removed otherwise
-        db.collectionDao().insertOrUpdateByUrl(
-            Collection(
-                0,
-                service.id,
-                null,
-                principalId, // create association with principal
-                Collection.TYPE_ADDRESSBOOK,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"), // with trailing slash
-            )
-        )
-
-        // Refresh principals
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshPrincipals()
-
-        // Check principal now got a display name
-        val principals = db.principalDao().getByService(service.id)
-        assertEquals(1, principals.size)
-        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), principals[0].url)
-        assertEquals("Mr. Wobbles", principals[0].displayName)
-    }
-
-    @Test
-    fun refreshPrincipals_deletesPrincipalsWithoutCollections() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        // place principal without collections in DB
-        db.principalDao().insert(
-            Principal(
-                0,
-                service.id,
-                mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL_WITHOUT_COLLECTIONS/")
-            )
-        )
-
-        // Refresh principals - detecting it does not own collections
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshPrincipals()
-
-        // Check principal was deleted
-        val principals = db.principalDao().getByService(service.id)
-        assertEquals(0, principals.size)
-    }
-
-    // Others
-
-    @Test
-    fun shouldPreselect_none() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        val settings = mockk<SettingsManager>()
-        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_NONE
-        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
-
-        val collection = Collection(
-            0,
-            service.id,
-            0,
-            type = Collection.TYPE_ADDRESSBOOK,
-            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-        )
-        val homesets = listOf(
-            HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-        assertFalse(refresher.shouldPreselect(collection, homesets))
-    }
-
-    @Test
-    fun shouldPreselect_all() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        val settings = mockk<SettingsManager>()
-        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_ALL
-        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
-
-        val collection = Collection(
-            0,
-            service.id,
-            0,
-            type = Collection.TYPE_ADDRESSBOOK,
-            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-        )
-        val homesets = listOf(
-            HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-        assertTrue(refresher.shouldPreselect(collection, homesets))
-    }
-
-    @Test
-    fun shouldPreselect_all_blacklisted() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-        val url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-
-        val settings = mockk<SettingsManager>()
-        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_ALL
-        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns url.toString()
-
-        val collection = Collection(
-            0,
-            service.id,
-            0,
-            type = Collection.TYPE_ADDRESSBOOK,
-            url = url
-        )
-        val homesets = listOf(
-            HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-        assertFalse(refresher.shouldPreselect(collection, homesets))
-    }
-
-    @Test
-    fun shouldPreselect_personal_notPersonal() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        val settings = mockk<SettingsManager>()
-        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
-        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
-
-        val collection = Collection(
-            0,
-            service.id,
-            0,
-            type = Collection.TYPE_ADDRESSBOOK,
-            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-        )
-        val homesets = listOf(
-            HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-        assertFalse(refresher.shouldPreselect(collection, homesets))
-    }
-
-    @Test
-    fun shouldPreselect_personal_isPersonal() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-
-        val settings = mockk<SettingsManager>()
-        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
-        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
-
-        val collection = Collection(
-            0,
-            service.id,
-            0,
-            type = Collection.TYPE_ADDRESSBOOK,
-            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-        )
-        val homesets = listOf(
-            HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-        assertTrue(refresher.shouldPreselect(collection, homesets))
-    }
-
-    @Test
-    fun shouldPreselect_personal_isPersonalButBlacklisted() {
-        val service = createTestService(Service.TYPE_CARDDAV)!!
-        val collectionUrl = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
-
-        val settings = mockk<SettingsManager>()
-        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
-        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns collectionUrl.toString()
-
-        val collection = Collection(
-            0,
-            service.id,
-            0,
-            type = Collection.TYPE_ADDRESSBOOK,
-            url = collectionUrl
-        )
-        val homesets = listOf(
-            HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
-        )
-
-        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-        assertFalse(refresher.shouldPreselect(collection, homesets))
-    }
-
-    // Test helpers and dependencies
-    
-    private fun createTestService(serviceType: String) : Service? {
-        val service = Service(id=0, accountName="test", type=serviceType, principal = null)
-        val serviceId = db.serviceDao().insertOrReplace(service)
-        return db.serviceDao().get(serviceId)
-    }
-
-    class TestDispatcher: Dispatcher() {
-
-        override fun dispatch(request: RecordedRequest): MockResponse {
-            val path = StringUtils.removeEnd(request.path!!, "/")
-
-            if (request.method.equals("PROPFIND", true)) {
-                val properties = when (path) {
-                    PATH_CALDAV,
-                    PATH_CARDDAV ->
-                        "<current-user-principal>" +
-                        "   <href>$path${SUBPATH_PRINCIPAL}</href>" +
-                        "</current-user-principal>"
-
-                    PATH_CARDDAV + SUBPATH_PRINCIPAL ->
-                        "<resourcetype><principal/></resourcetype>" +
-                        "<displayname>Mr. Wobbles</displayname>" +
-                        "<CARD:addressbook-home-set>" +
-                        "   <href>${PATH_CARDDAV}${SUBPATH_ADDRESSBOOK_HOMESET}</href>" +
-                        "</CARD:addressbook-home-set>"
-
-                    PATH_CARDDAV + SUBPATH_PRINCIPAL_WITHOUT_COLLECTIONS ->
-                        "<CARD:addressbook-home-set>" +
-                        "   <href>${PATH_CARDDAV}${SUBPATH_ADDRESSBOOK_HOMESET_EMPTY}</href>" +
-                        "</CARD:addressbook-home-set>" +
-                        "<displayname>Mr. Wobbles Jr.</displayname>"
-
-                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK,
-                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK_HOMESET ->
-                        "<resourcetype>" +
-                        "   <collection/>" +
-                        "   <CARD:addressbook/>" +
-                        "</resourcetype>" +
-                        "<displayname>My Contacts</displayname>" +
-                        "<CARD:addressbook-description>My Contacts Description</CARD:addressbook-description>" +
-                        "<owner>" +
-                        "   <href>${PATH_CARDDAV + SUBPATH_PRINCIPAL}</href>" +
-                        "</owner>"
-
-                    PATH_CALDAV + SUBPATH_PRINCIPAL ->
-                        "<CAL:calendar-user-address-set>" +
-                        "  <href>urn:unknown-entry</href>" +
-                        "  <href>mailto:email1@example.com</href>" +
-                        "  <href>mailto:email2@example.com</href>" +
-                        "</CAL:calendar-user-address-set>"
-
-                    SUBPATH_ADDRESSBOOK_HOMESET_EMPTY -> ""
-
-                    else -> ""
-                }
-
-                var responseBody = ""
-                var responseCode = 207
-                when (path) {
-                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK_HOMESET ->
-                        responseBody =
-                            "<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
-                            "<response>" +
-                            "   <href>${PATH_CARDDAV + SUBPATH_ADDRESSBOOK}</href>" +
-                            "   <propstat><prop>" +
-                                    properties +
-                            "   </prop></propstat>" +
-                            "   <status>HTTP/1.1 200 OK</status>" +
-                            "</response>" +
-                            "</multistatus>"
-
-                    PATH_CARDDAV + SUBPATH_PRINCIPAL_INACCESSIBLE,
-                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK_INACCESSIBLE ->
-                        responseCode = 404
-
-                    else ->
-                        responseBody =
-                            "<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
-                            "<response>" +
-                            "   <href>$path</href>" +
-                            "   <propstat><prop>"+
-                                    properties +
-                            "   </prop></propstat>" +
-                            "</response>" +
-                            "</multistatus>"
-                }
-
-                Logger.log.info("Queried: $path")
-                Logger.log.info("Response: $responseBody")
-                return MockResponse()
-                    .setResponseCode(responseCode)
-                    .setBody(responseBody)
-            }
-
-            return MockResponse().setResponseCode(404)
-        }
-
-    }
-}

app/src/androidTest/kotlin/at/bitfire/davdroid/settings/AccountSettingsTest.kt

@@ -1,140 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.settings
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.ContentResolver
-import android.provider.CalendarContract
-import android.provider.ContactsContract
-import android.util.Log
-import androidx.annotation.RequiresApi
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.work.Configuration
-import androidx.work.testing.WorkManagerTestInitHelper
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.TestUtils
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.syncadapter.AccountUtils
-import at.bitfire.davdroid.syncadapter.PeriodicSyncWorker
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.ical4android.TaskProvider
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import javax.inject.Inject
-
-/*@HiltAndroidTest
-class AccountSettingsTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @Inject
-    lateinit var settingsManager: SettingsManager
-
-
-    private val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    val account = Account(javaClass.canonicalName, context.getString(R.string.account_type))
-    val fakeCredentials = Credentials("test", "test")
-
-    val authorities = listOf(
-        context.getString(R.string.address_books_authority),
-        CalendarContract.AUTHORITY,
-        TaskProvider.ProviderName.JtxBoard.authority,
-        TaskProvider.ProviderName.OpenTasks.authority,
-        TaskProvider.ProviderName.TasksOrg.authority
-    )
-
-    @Before
-    fun setUp() {
-        hiltRule.inject()
-
-        assertTrue(AccountUtils.createAccount(
-            context,
-            account,
-            AccountSettings.initialUserData(fakeCredentials)
-        ))
-        ContentResolver.setIsSyncable(account, CalendarContract.AUTHORITY, 1)
-        ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 0)
-
-        // The test application is an instance of HiltTestApplication, which doesn't initialize notification channels.
-        // However, we need notification channels for the ongoing work notifications.
-        NotificationUtils.createChannels(context)
-
-        // Initialize WorkManager for instrumentation tests.
-        val config = Configuration.Builder()
-            .setMinimumLoggingLevel(Log.DEBUG)
-            .build()
-        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
-    }
-
-    @After
-    @RequiresApi(22)
-    fun removeAccount() {
-        AccountManager.get(context).removeAccountExplicitly(account)
-    }
-
-
-    @Test
-    fun testSyncIntervals() {
-        val settings = AccountSettings(context, account)
-        val presetIntervals =
-            context.resources.getStringArray(R.array.settings_sync_interval_seconds)
-                .map { it.toLong() }
-                .filter { it != AccountSettings.SYNC_INTERVAL_MANUALLY }
-        for (interval in presetIntervals) {
-            assertTrue(settings.setSyncInterval(CalendarContract.AUTHORITY, interval))
-            assertEquals(interval, settings.getSyncInterval(CalendarContract.AUTHORITY))
-        }
-    }
-
-    @Test
-    fun testSyncIntervals_Syncable() {
-        val settings = AccountSettings(context, account)
-        val interval = 15*60L    // 15 min
-        val result = settings.setSyncInterval(CalendarContract.AUTHORITY, interval)
-        assertTrue(result)
-    }
-
-    @Test(expected = IllegalArgumentException::class)
-    fun testSyncIntervals_TooShort() {
-        val settings = AccountSettings(context, account)
-        val interval = 60L      // 1 min is not supported by Android
-        settings.setSyncInterval(CalendarContract.AUTHORITY, interval)
-    }
-
-    @Test
-    fun testSyncIntervals_activatesPeriodicSyncWorker() {
-        val settings = AccountSettings(context, account)
-        val interval = 15*60L
-        for (authority in authorities) {
-            ContentResolver.setIsSyncable(account, authority, 1)
-            assertTrue(settings.setSyncInterval(authority, interval))
-            assertTrue(TestUtils.workScheduledOrRunningOrSuccessful(context, PeriodicSyncWorker.workerName(account, authority)))
-            assertEquals(interval, settings.getSyncInterval(authority))
-        }
-    }
-
-    @Test
-    fun testSyncIntervals_disablesPeriodicSyncWorker() {
-        val settings = AccountSettings(context, account)
-        val interval = AccountSettings.SYNC_INTERVAL_MANUALLY // -1
-        for (authority in authorities) {
-            ContentResolver.setIsSyncable(account, authority, 1)
-            assertTrue(settings.setSyncInterval(authority, interval))
-            assertFalse(TestUtils.workScheduledOrRunningOrSuccessful(context, PeriodicSyncWorker.workerName(account, authority)))
-            assertEquals(AccountSettings.SYNC_INTERVAL_MANUALLY, settings.getSyncInterval(authority))
-        }
-    }
-
-}*/

app/src/androidTest/res/values/strings.xml

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright (c) Ricki Hirner (bitfire web engineering).
-  ~ All rights reserved. This program and the accompanying materials
-  ~ are made available under the terms of the GNU Public License v3.0
-  ~ which accompanies this distribution, and is available at
-  ~ http://www.gnu.org/licenses/gpl.html
-  -->
-
-<resources>
-
-    <string name="app_name">Davx5Test</string>
-
-</resources>

app/src/androidTest/res/xml/test_account_authenticator.xml

@@ -1,3 +0,0 @@
-<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
-    android:accountType="at.bitfire.davdroid.SyncManagerTest"
-    android:label="Test Account" />

app/src/androidTestOse/kotlin/at/bitfire/davdroid/syncadapter/BaseSyncWorkerTest.kt

@@ -1,150 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.ContentResolver
-import android.net.wifi.WifiInfo
-import android.net.wifi.WifiManager
-import android.provider.CalendarContract
-import android.provider.ContactsContract
-import android.util.Log
-import androidx.core.content.getSystemService
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.work.Configuration
-import androidx.work.testing.WorkManagerTestInitHelper
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.network.ConnectionUtils
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.util.PermissionUtils
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.mockk.every
-import io.mockk.junit4.MockKRule
-import io.mockk.mockk
-import io.mockk.mockkObject
-import io.mockk.spyk
-import org.junit.After
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-
-@HiltAndroidTest
-class BaseSyncWorkerTest {
-
-    val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    private val accountManager = AccountManager.get(context)
-    private val account = Account("Test Account", context.getString(R.string.account_type))
-    private val fakeCredentials = Credentials("test", "test")
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-    @get:Rule
-    val mockkRule = MockKRule(this)
-
-    @Before
-    fun inject() = hiltRule.inject()
-
-
-    @Before
-    fun setUp() {
-        assertTrue(AccountUtils.createAccount(context, account, AccountSettings.initialUserData(fakeCredentials)))
-        ContentResolver.setIsSyncable(account, CalendarContract.AUTHORITY, 1)
-        ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 0)
-
-        // The test application is an instance of HiltTestApplication, which doesn't initialize notification channels.
-        // However, we need notification channels for the ongoing work notifications.
-        NotificationUtils.createChannels(context)
-
-        // Initialize WorkManager for instrumentation tests.
-        val config = Configuration.Builder()
-            .setMinimumLoggingLevel(Log.DEBUG)
-            .build()
-        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
-    }
-
-    @After
-    fun removeAccount() {
-        accountManager.removeAccountExplicitly(account)
-    }
-
-
-    @Test
-    fun testWifiConditionsMet_withoutWifi() {
-        val accountSettings = mockk<AccountSettings>()
-        every { accountSettings.getSyncWifiOnly() } returns false
-        assertTrue(BaseSyncWorker.wifiConditionsMet(context, accountSettings))
-    }
-    
-    @Test
-    fun testWifiConditionsMet_anyWifi_wifiEnabled() {
-        val accountSettings = AccountSettings(context, account)
-        accountSettings.setSyncWiFiOnly(true)
-
-        mockkObject(ConnectionUtils)
-        every { ConnectionUtils.wifiAvailable(any()) } returns true
-        mockkObject(BaseSyncWorker.Companion)
-        every { BaseSyncWorker.correctWifiSsid(any(), any()) } returns true
-
-        assertTrue(BaseSyncWorker.wifiConditionsMet(context, accountSettings))
-    }
-
-    @Test
-    fun testWifiConditionsMet_anyWifi_wifiDisabled() {
-        val accountSettings = AccountSettings(context, account)
-        accountSettings.setSyncWiFiOnly(true)
-
-        mockkObject(ConnectionUtils)
-        every { ConnectionUtils.wifiAvailable(any()) } returns false
-        mockkObject(BaseSyncWorker.Companion)
-        every { BaseSyncWorker.correctWifiSsid(any(), any()) } returns true
-
-        assertFalse(BaseSyncWorker.wifiConditionsMet(context, accountSettings))
-    }
-
-
-    @Test
-    fun testCorrectWifiSsid_CorrectWiFiSsid() {
-        val accountSettings = AccountSettings(context, account)
-        mockkObject(accountSettings)
-        every { accountSettings.getSyncWifiOnlySSIDs() } returns listOf("SampleWiFi1","ConnectedWiFi")
-
-        mockkObject(PermissionUtils)
-        every { PermissionUtils.canAccessWifiSsid(any()) } returns true
-
-        val wifiManager = context.getSystemService<WifiManager>()!!
-        mockkObject(wifiManager)
-        every { wifiManager.connectionInfo } returns spyk<WifiInfo>().apply {
-            every { ssid } returns "ConnectedWiFi"
-        }
-
-        assertTrue(BaseSyncWorker.correctWifiSsid(context, accountSettings))
-    }
-
-    @Test
-    fun testCorrectWifiSsid_WrongWiFiSsid() {
-        val accountSettings = AccountSettings(context, account)
-        mockkObject(accountSettings)
-        every { accountSettings.getSyncWifiOnlySSIDs() } returns listOf("SampleWiFi1","SampleWiFi2")
-
-        mockkObject(PermissionUtils)
-        every { PermissionUtils.canAccessWifiSsid(any()) } returns true
-
-        val wifiManager = context.getSystemService<WifiManager>()!!
-        mockkObject(wifiManager)
-        every { wifiManager.connectionInfo } returns spyk<WifiInfo>().apply {
-            every { ssid } returns "ConnectedWiFi"
-        }
-
-        assertFalse(BaseSyncWorker.correctWifiSsid(context, accountSettings))
-    }
-
-}

app/src/androidTestOse/kotlin/at/bitfire/davdroid/syncadapter/OneTimeSyncWorkerTest.kt

@@ -1,28 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.content.Context
-import android.provider.CalendarContract
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.TestUtils
-import at.bitfire.davdroid.syncadapter.SyncManagerTest.Companion.account
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.Assert
-import org.junit.Test
-
-@HiltAndroidTest
-class OneTimeSyncWorkerTest {
-
-    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    @Test
-    fun testEnqueue_enqueuesWorker() {
-        OneTimeSyncWorker.enqueue(context, account, CalendarContract.AUTHORITY)
-        val workerName = OneTimeSyncWorker.workerName(account, CalendarContract.AUTHORITY)
-        Assert.assertTrue(TestUtils.workScheduledOrRunningOrSuccessful(context, workerName))
-    }
-
-}

app/src/androidTestOse/kotlin/at/bitfire/davdroid/syncadapter/PeriodicSyncWorkerTest.kt

@@ -1,148 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.ContentResolver
-import android.content.Context
-import android.provider.CalendarContract
-import android.provider.ContactsContract
-import android.util.Log
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.work.Configuration
-import androidx.work.ListenableWorker
-import androidx.work.WorkManager
-import androidx.work.WorkerFactory
-import androidx.work.WorkerParameters
-import androidx.work.testing.TestListenableWorkerBuilder
-import androidx.work.testing.WorkManagerTestInitHelper
-import androidx.work.workDataOf
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.TestUtils.workScheduledOrRunning
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.ui.NotificationUtils
-import dagger.assisted.AssistedFactory
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.mockk.junit4.MockKRule
-import io.mockk.mockkObject
-import io.mockk.verify
-import kotlinx.coroutines.runBlocking
-import org.junit.AfterClass
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.BeforeClass
-import org.junit.Rule
-import org.junit.Test
-import javax.inject.Inject
-
-@HiltAndroidTest
-class PeriodicSyncWorkerTest {
-
-    companion object {
-
-        val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
-
-        private val accountManager = AccountManager.get(context)
-        private val account = Account("Test Account", context.getString(R.string.account_type))
-        private val fakeCredentials = Credentials("test", "test")
-
-        @BeforeClass
-        @JvmStatic
-        fun setUp() {
-            // The test application is an instance of HiltTestApplication, which doesn't initialize notification channels.
-            // However, we need notification channels for the ongoing work notifications.
-            NotificationUtils.createChannels(context)
-
-            // Initialize WorkManager for instrumentation tests.
-            val config = Configuration.Builder()
-                .setMinimumLoggingLevel(Log.DEBUG)
-                .build()
-            WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
-
-            assertTrue(AccountUtils.createAccount(context, account, AccountSettings.initialUserData(fakeCredentials)))
-            ContentResolver.setIsSyncable(account, CalendarContract.AUTHORITY, 1)
-            ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 1)
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun removeAccount() {
-            accountManager.removeAccountExplicitly(account)
-        }
-
-    }
-
-    @AssistedFactory
-    interface PeriodicSyncWorkerFactory {
-        fun create(appContext: Context, workerParams: WorkerParameters): PeriodicSyncWorker
-    }
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-    @get:Rule
-    val mockkRule = MockKRule(this)
-
-    @Inject
-    lateinit var syncWorkerFactory: PeriodicSyncWorkerFactory
-
-    @Before
-    fun inject() {
-        hiltRule.inject()
-    }
-
-
-    @Test
-    fun enable_enqueuesPeriodicWorker() {
-        PeriodicSyncWorker.enable(context, account, CalendarContract.AUTHORITY, 60, false)
-        val workerName = PeriodicSyncWorker.workerName(account, CalendarContract.AUTHORITY)
-        assertTrue(workScheduledOrRunning(context, workerName))
-    }
-
-    @Test
-    fun disable_removesPeriodicWorker() {
-        PeriodicSyncWorker.enable(context, account, CalendarContract.AUTHORITY, 60, false)
-        PeriodicSyncWorker.disable(context, account, CalendarContract.AUTHORITY)
-        val workerName = PeriodicSyncWorker.workerName(account, CalendarContract.AUTHORITY)
-        assertFalse(workScheduledOrRunning(context, workerName))
-    }
-
-    @Test
-    fun doWork_cancelsItselfOnInvalidAccount() {
-        val invalidAccount = Account("invalid", context.getString(R.string.account_type))
-
-        // Run PeriodicSyncWorker as TestWorker
-        val inputData = workDataOf(
-            BaseSyncWorker.INPUT_AUTHORITY to CalendarContract.AUTHORITY,
-            BaseSyncWorker.INPUT_ACCOUNT_NAME to invalidAccount.name,
-            BaseSyncWorker.INPUT_ACCOUNT_TYPE to invalidAccount.type
-        )
-
-        // mock WorkManager to observe cancellation call
-        val workManager = WorkManager.getInstance(context)
-        mockkObject(workManager)
-
-        // run test worker, expect failure
-        val testWorker = TestListenableWorkerBuilder<PeriodicSyncWorker>(context, inputData)
-            .setWorkerFactory(object: WorkerFactory() {
-                override fun createWorker(appContext: Context, workerClassName: String, workerParameters: WorkerParameters) =
-                    syncWorkerFactory.create(appContext, workerParameters)
-            })
-            .build()
-        val result = runBlocking {
-            testWorker.doWork()
-        }
-        assertTrue(result is ListenableWorker.Result.Failure)
-
-        // verify that worker called WorkManager.cancelWorkById(<its ID>)
-        verify {
-            workManager.cancelWorkById(testWorker.id)
-        }
-    }
-
-}

app/src/androidTestOse/kotlin/at/bitfire/davdroid/syncadapter/SyncerTest.kt

@@ -1,73 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.Context
-import android.content.SyncResult
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.R
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.Assert.assertEquals
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import java.util.concurrent.atomic.AtomicInteger
-
-@HiltAndroidTest
-class SyncerTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    val context = InstrumentationRegistry.getInstrumentation().targetContext
-
-    /** use our WebDAV provider as a mock provider because it's our own and we don't need any permissions for it */
-    val mockAuthority = context.getString(R.string.webdav_authority)
-    val mockProvider = context.contentResolver!!.acquireContentProviderClient(mockAuthority)!!
-
-    val account = Account(javaClass.canonicalName, context.getString(R.string.account_type))
-
-
-    @Before
-    fun setUp() {
-        hiltRule.inject()
-    }
-
-    @Test
-    fun testOnPerformSync_runsSyncAndSetsClassLoader() {
-        val syncer = TestSyncer(context)
-        syncer.onPerformSync(account, arrayOf(), mockAuthority, mockProvider, SyncResult())
-
-        // check whether onPerformSync() actually calls sync()
-        assertEquals(1, syncer.syncCalled.get())
-
-        // check whether contextClassLoader is set
-        assertEquals(context.classLoader, Thread.currentThread().contextClassLoader)
-    }
-
-
-    class TestSyncer(context: Context) : Syncer(context) {
-
-        val syncCalled = AtomicInteger()
-
-        override fun sync(
-            account: Account,
-            extras: Array<String>,
-            authority: String,
-            httpClient: Lazy<HttpClient>,
-            provider: ContentProviderClient,
-            syncResult: SyncResult
-        ) {
-            Thread.sleep(1000)
-            syncCalled.incrementAndGet()
-        }
-
-    }
-
-}

app/src/main/assets/translators.json

@@ -1 +0,0 @@
-{"ar_SA":["abdunnasir"],"bg":["dpa_transifex"],"ca":["Kintu","jordibrus","zagur"],"cs":["pavelb","svetlemodry","tomas.odehnal"],"da":["Tntdruid_","knutztar","mjjzf","twikedk"],"de":["Atalanttore","TheName","Wyrrrd","YvanM","amandablue","anestiskaci","corppneq","crit12","hammaschlach","maxkl","nicolas_git","owncube"],"el":["KristinaQejvanaj","anestiskaci","diamond_gr"],"es":["Ark74","Elhea","GranPC","aluaces","jcvielma","plaguna","polkhas","xphnx"],"eu":["Osoitz","Thadah","cockeredradiation"],"fa":["Numb","ahangarha","amiraliakbari","joojoojoo","maryambehzi","mtashackori","taranehsaei"],"fr":["AlainR","Amadeen","Floflr","JorisBodin","Llorc","LoiX07","Novick","Poussinou","Thecross","YvanM","alkino2","boutil","callmemagnus","chrcha","grenatrad","jokx","mathieugfortin","paullbn","vincen","ÉricB."],"fr_FR":["Llorc","Poussinou","chrcha"],"gl":["aluaces","pikamoku"],"hu":["Roshek","infeeeee","jtg"],"it":["Damtux","FranzMari","ed0","malaerba","noccio","nwandy","rickyroo","technezio"],"it_IT":["malaerba"],"ja":["Naofumi","yanorei32"],"nb_NO":["elonus"],"nl":["XtremeNova","davtemp","dehart","erikhubers","frankyboy1963"],"pl":["TORminator","TheName","Valdnet","gsz","mg6","oskarjakiela"],"pt":["amalvarenga","wanderlei.huttel"],"pt_BR":["wanderlei.huttel"],"ru":["aigoshin","anm","ashed","astalavister","nick.savin","vaddd"],"sk_SK":["brango67","tiborepcek"],"sl_SI":["MrLaaky","uroszor"],"sr":["daimonion"],"sv":["Mikaelb","campbelldavid"],"szl":["chlodny"],"tr_TR":["ooguz","pultars"],"uk":["androsua","olexn","twixi007"],"uk_UA":["astalavister"],"zh_CN":["anolir","jxj2zzz79pfp9bpo","linuxbckp","mofitt2016","oksjd","phy","spice2wolf"],"zh_TW":["linuxbckp","mofitt2016","phy","waiabsfabuloushk"]}

app/src/main/kotlin/at/bitfire/davdroid/App.kt

@@ -1,85 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid
-
-import android.app.Application
-import android.os.StrictMode
-import androidx.hilt.work.HiltWorkerFactory
-import androidx.work.Configuration
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.syncadapter.AccountsCleanupWorker
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.UiUtils
-import dagger.hilt.android.HiltAndroidApp
-import kotlinx.coroutines.DelicateCoroutinesApi
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.GlobalScope
-import kotlinx.coroutines.launch
-import java.util.logging.Level
-import javax.inject.Inject
-import kotlin.system.exitProcess
-
-@HiltAndroidApp
-class App: Application(), Thread.UncaughtExceptionHandler, Configuration.Provider {
-
-    @Inject lateinit var workerFactory: HiltWorkerFactory
-
-    override val workManagerConfiguration: Configuration
-        get() = Configuration.Builder()
-            .setWorkerFactory(workerFactory)
-            .build()
-
-    override fun onCreate() {
-        super.onCreate()
-        Logger.initialize(this)
-
-        if (BuildConfig.DEBUG)
-            // debug builds
-            StrictMode.setVmPolicy(StrictMode.VmPolicy.Builder()
-                    .detectActivityLeaks()
-                    .detectFileUriExposure()
-                    .detectLeakedClosableObjects()
-                    .detectLeakedRegistrationObjects()
-                    .detectLeakedSqlLiteObjects()
-                    .penaltyLog()
-                    .build())
-        else // if (BuildConfig.FLAVOR == FLAVOR_STANDARD)
-            // handle uncaught exceptions in non-debug standard flavor
-            Thread.setDefaultUncaughtExceptionHandler(this)
-
-        NotificationUtils.createChannels(this)
-
-        // set light/dark mode
-        UiUtils.updateTheme(this)   // when this is called in the asynchronous thread below, it recreates
-                                 // some current activity and causes an IllegalStateException in rare cases
-
-        // don't block UI for some background checks
-        @OptIn(DelicateCoroutinesApi::class)
-        GlobalScope.launch(Dispatchers.Default) {
-            // clean up orphaned accounts in DB from time to time
-            AccountsCleanupWorker.enqueue(this@App)
-
-            // watch installed/removed tasks apps over whole app lifetime and update sync settings accordingly
-            TasksAppWatcher.watchInstalledTaskApps(this@App, this)
-
-            // create/update app shortcuts
-            UiUtils.updateShortcuts(this@App)
-        }
-    }
-
-    override fun uncaughtException(t: Thread, e: Throwable) {
-        Logger.log.log(Level.SEVERE, "Unhandled exception!", e)
-
-        val intent = DebugInfoActivity.IntentBuilder(this)
-            .withCause(e)
-            .newTask()
-            .build()
-        startActivity(intent)
-
-        exitProcess(1)
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/Constants.kt

@@ -1,53 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-package at.bitfire.davdroid
-
-import android.net.Uri
-import androidx.core.net.toUri
-
-/**
- * Brand-specific constants like (non-theme) colors, homepage URLs etc.
- */
-object Constants {
-
-    const val DAVDROID_GREEN_RGBA = 0xFF8bc34a.toInt()
-
-    val HOMEPAGE_URL = "https://www.davx5.com".toUri()
-    const val HOMEPAGE_PATH_FAQ = "faq"
-    const val HOMEPAGE_PATH_FAQ_SYNC_NOT_RUN = "synchronization-is-not-run-as-expected"
-    const val HOMEPAGE_PATH_FAQ_LOCATION_PERMISSION = "wifi-ssid-restriction-location-permission"
-    const val HOMEPAGE_PATH_OPEN_SOURCE = "donate"
-    const val HOMEPAGE_PATH_PRIVACY = "privacy"
-    const val HOMEPAGE_PATH_TESTED_SERVICES = "tested-with"
-
-    val MANUAL_URL = "https://manual.davx5.com".toUri()
-    const val MANUAL_PATH_ACCOUNTS_COLLECTIONS = "accounts_collections.html"
-    const val MANUAL_FRAGMENT_SERVICE_DISCOVERY = "how-does-service-discovery-work"
-    const val MANUAL_PATH_SETTINGS = "settings.html"
-    const val MANUAL_FRAGMENT_APP_SETTINGS = "app-wide-settings"
-    const val MANUAL_FRAGMENT_ACCOUNT_SETTINGS = "account-settings"
-    const val MANUAL_PATH_WEBDAV_MOUNTS = "webdav_mounts.html"
-
-    val COMMUNITY_URL = "https://github.com/bitfireAT/davx5-ose/discussions".toUri()
-
-    val FEDIVERSE_HANDLE = "@davx5app@fosstodon.org"
-    val FEDIVERSE_URL = "https://fosstodon.org/@davx5app".toUri()
-
-    /**
-     * Appends query parameters for anonymized usage statistics (app ID, version).
-     * Can be used by the called Website to get an idea of which versions etc. are currently used.
-     *
-     * @param context   optional info about from where the URL was opened (like a specific Activity)
-     */
-    fun Uri.Builder.withStatParams(context: String? = null): Uri.Builder {
-        appendQueryParameter("pk_campaign", BuildConfig.APPLICATION_ID)
-        appendQueryParameter("app-version", BuildConfig.VERSION_NAME)
-
-        if (context != null)
-            appendQueryParameter("pk_kwd", context)
-
-        return this
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/TasksAppWatcher.kt

@@ -1,53 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid
-
-import android.content.Context
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.util.TaskUtils
-import at.bitfire.davdroid.util.packageChangedFlow
-import at.bitfire.ical4android.TaskProvider
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-
-/**
- * Watches whether a tasks app has been installed or uninstalled and updates
- * the selected tasks app and task sync settings accordingly.
- */
-object TasksAppWatcher {
-
-    fun watchInstalledTaskApps(context: Context, externalScope: CoroutineScope) {
-        externalScope.launch(Dispatchers.Default)  {
-            packageChangedFlow(context).collect {
-                onPackageChanged(context)
-            }
-        }
-    }
-
-    private fun onPackageChanged(context: Context) {
-        val currentProvider = TaskUtils.currentProvider(context)
-        Logger.log.info("App launched or package (un)installed; current tasks provider = $currentProvider")
-
-        if (currentProvider == null) {
-            // Iterate through all supported providers and select one, if available.
-            var providerSelected = false
-            for (provider in TaskProvider.ProviderName.entries) {
-                val available = context.packageManager.resolveContentProvider(provider.authority, 0) != null
-                if (available) {
-                    Logger.log.info("Selecting new tasks provider: $provider")
-                    TaskUtils.selectProvider(context, provider)
-                    providerSelected = true
-                    break
-                }
-            }
-
-            if (!providerSelected)
-                // no provider available (anymore), also clear setting and sync
-                TaskUtils.selectProvider(context, null)
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/db/AppDatabase.kt

@@ -1,305 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.db
-
-import android.accounts.AccountManager
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.database.sqlite.SQLiteQueryBuilder
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.core.database.getStringOrNull
-import androidx.room.AutoMigration
-import androidx.room.Database
-import androidx.room.DeleteColumn
-import androidx.room.ProvidedAutoMigrationSpec
-import androidx.room.Room
-import androidx.room.RoomDatabase
-import androidx.room.TypeConverters
-import androidx.room.migration.AutoMigrationSpec
-import androidx.room.migration.Migration
-import androidx.sqlite.db.SupportSQLiteDatabase
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.TextTable
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.servicedetection.RefreshCollectionsWorker
-import at.bitfire.davdroid.ui.AccountsActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.NotificationUtils.notifyIfPossible
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.InstallIn
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import java.io.Writer
-import javax.inject.Singleton
-
-@Suppress("ClassName")
-@Database(entities = [
-    Service::class,
-    HomeSet::class,
-    Collection::class,
-    Principal::class,
-    SyncStats::class,
-    WebDavDocument::class,
-    WebDavMount::class
-], exportSchema = true, version = 13, autoMigrations = [
-    AutoMigration(from = 9, to = 10),
-    AutoMigration(from = 10, to = 11),
-    AutoMigration(from = 11, to = 12, spec = AppDatabase.AutoMigration11_12::class),
-    AutoMigration(from = 12, to = 13)
-])
-@TypeConverters(Converters::class)
-abstract class AppDatabase: RoomDatabase() {
-
-    @Module
-    @InstallIn(SingletonComponent::class)
-    object AppDatabaseModule {
-        @Provides
-        @Singleton
-        fun appDatabase(@ApplicationContext context: Context): AppDatabase =
-            Room.databaseBuilder(context.applicationContext, AppDatabase::class.java, "services.db")
-                .addMigrations(*migrations)
-                .addAutoMigrationSpec(AutoMigration11_12(context))
-                .fallbackToDestructiveMigration()   // as a last fallback, recreate database instead of crashing
-                .addCallback(object: Callback() {
-                    override fun onDestructiveMigration(db: SupportSQLiteDatabase) {
-                        val nm = NotificationManagerCompat.from(context)
-                        val launcherIntent = Intent(context, AccountsActivity::class.java)
-                        val notify = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_GENERAL)
-                            .setSmallIcon(R.drawable.ic_warning_notify)
-                            .setContentTitle(context.getString(R.string.database_destructive_migration_title))
-                            .setContentText(context.getString(R.string.database_destructive_migration_text))
-                            .setCategory(NotificationCompat.CATEGORY_ERROR)
-                            .setContentIntent(PendingIntent.getActivity(context, 0, launcherIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE))
-                            .setAutoCancel(true)
-                            .build()
-                        nm.notifyIfPossible(NotificationUtils.NOTIFY_DATABASE_CORRUPTED, notify)
-
-                        // remove all accounts because they're unfortunately useless without database
-                        val am = AccountManager.get(context)
-                        for (account in am.getAccountsByType(context.getString(R.string.account_type)))
-                            am.removeAccount(account, null, null)
-                    }
-                })
-                .build()
-    }
-
-    // auto migrations
-
-    @ProvidedAutoMigrationSpec
-    @DeleteColumn(tableName = "collection", columnName = "owner")
-    class AutoMigration11_12(val context: Context): AutoMigrationSpec {
-        override fun onPostMigrate(db: SupportSQLiteDatabase) {
-            Logger.log.info("Database update to v12, refreshing services to get display names of owners")
-            db.query("SELECT id FROM service", arrayOf()).use { cursor ->
-                while (cursor.moveToNext()) {
-                    val serviceId = cursor.getLong(0)
-                    RefreshCollectionsWorker.enqueue(context, serviceId)
-                }
-            }
-        }
-    }
-
-
-    companion object {
-
-        // manual migrations
-
-        val migrations: Array<Migration> = arrayOf(
-            object : Migration(8, 9) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    db.execSQL("CREATE TABLE syncstats (" +
-                            "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
-                            "collectionId INTEGER NOT NULL REFERENCES collection(id) ON DELETE CASCADE," +
-                            "authority TEXT NOT NULL," +
-                            "lastSync INTEGER NOT NULL)")
-                    db.execSQL("CREATE UNIQUE INDEX index_syncstats_collectionId_authority ON syncstats(collectionId, authority)")
-
-                    db.execSQL("CREATE INDEX index_collection_url ON collection(url)")
-                }
-            },
-
-            object : Migration(7, 8) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    db.execSQL("ALTER TABLE homeset ADD COLUMN personal INTEGER NOT NULL DEFAULT 1")
-                    db.execSQL("ALTER TABLE collection ADD COLUMN homeSetId INTEGER DEFAULT NULL REFERENCES homeset(id) ON DELETE SET NULL")
-                    db.execSQL("ALTER TABLE collection ADD COLUMN owner TEXT DEFAULT NULL")
-                    db.execSQL("CREATE INDEX index_collection_homeSetId_type ON collection(homeSetId, type)")
-                }
-            },
-
-            object : Migration(6, 7) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    db.execSQL("ALTER TABLE homeset ADD COLUMN privBind INTEGER NOT NULL DEFAULT 1")
-                    db.execSQL("ALTER TABLE homeset ADD COLUMN displayName TEXT DEFAULT NULL")
-                }
-            },
-
-            object : Migration(5, 6) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    val sql = arrayOf(
-                        // migrate "services" to "service": rename columns, make id NOT NULL
-                        "CREATE TABLE service(" +
-                                "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
-                                "accountName TEXT NOT NULL," +
-                                "type TEXT NOT NULL," +
-                                "principal TEXT DEFAULT NULL" +
-                                ")",
-                        "CREATE UNIQUE INDEX index_service_accountName_type ON service(accountName, type)",
-                        "INSERT INTO service(id, accountName, type, principal) SELECT _id, accountName, service, principal FROM services",
-                        "DROP TABLE services",
-
-                        // migrate "homesets" to "homeset": rename columns, make id NOT NULL
-                        "CREATE TABLE homeset(" +
-                                "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
-                                "serviceId INTEGER NOT NULL," +
-                                "url TEXT NOT NULL," +
-                                "FOREIGN KEY (serviceId) REFERENCES service(id) ON DELETE CASCADE" +
-                                ")",
-                        "CREATE UNIQUE INDEX index_homeset_serviceId_url ON homeset(serviceId, url)",
-                        "INSERT INTO homeset(id, serviceId, url) SELECT _id, serviceID, url FROM homesets",
-                        "DROP TABLE homesets",
-
-                        // migrate "collections" to "collection": rename columns, make id NOT NULL
-                        "CREATE TABLE collection(" +
-                                "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
-                                "serviceId INTEGER NOT NULL," +
-                                "type TEXT NOT NULL," +
-                                "url TEXT NOT NULL," +
-                                "privWriteContent INTEGER NOT NULL DEFAULT 1," +
-                                "privUnbind INTEGER NOT NULL DEFAULT 1," +
-                                "forceReadOnly INTEGER NOT NULL DEFAULT 0," +
-                                "displayName TEXT DEFAULT NULL," +
-                                "description TEXT DEFAULT NULL," +
-                                "color INTEGER DEFAULT NULL," +
-                                "timezone TEXT DEFAULT NULL," +
-                                "supportsVEVENT INTEGER DEFAULT NULL," +
-                                "supportsVTODO INTEGER DEFAULT NULL," +
-                                "supportsVJOURNAL INTEGER DEFAULT NULL," +
-                                "source TEXT DEFAULT NULL," +
-                                "sync INTEGER NOT NULL DEFAULT 0," +
-                                "FOREIGN KEY (serviceId) REFERENCES service(id) ON DELETE CASCADE" +
-                                ")",
-                        "CREATE INDEX index_collection_serviceId_type ON collection(serviceId,type)",
-                        "INSERT INTO collection(id, serviceId, type, url, privWriteContent, privUnbind, forceReadOnly, displayName, description, color, timezone, supportsVEVENT, supportsVTODO, source, sync) " +
-                                "SELECT _id, serviceID, type, url, privWriteContent, privUnbind, forceReadOnly, displayName, description, color, timezone, supportsVEVENT, supportsVTODO, source, sync FROM collections",
-                        "DROP TABLE collections"
-                    )
-                    sql.forEach { db.execSQL(it) }
-                }
-            },
-
-            object : Migration(4, 5) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    db.execSQL("ALTER TABLE collections ADD COLUMN privWriteContent INTEGER DEFAULT 0 NOT NULL")
-                    db.execSQL("UPDATE collections SET privWriteContent=NOT readOnly")
-
-                    db.execSQL("ALTER TABLE collections ADD COLUMN privUnbind INTEGER DEFAULT 0 NOT NULL")
-                    db.execSQL("UPDATE collections SET privUnbind=NOT readOnly")
-
-                    // there's no DROP COLUMN in SQLite, so just keep the "readOnly" column
-                }
-            },
-
-            object : Migration(3, 4) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    db.execSQL("ALTER TABLE collections ADD COLUMN forceReadOnly INTEGER DEFAULT 0 NOT NULL")
-                }
-            },
-
-            object : Migration(2, 3) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    // We don't have access to the context in a Room migration now, so
-                    // we will just drop those settings from old DAVx5 versions.
-                    Logger.log.warning("Dropping settings distrustSystemCerts and overrideProxy*")
-
-                    /*val edit = PreferenceManager.getDefaultSharedPreferences(context).edit()
-                    try {
-                        db.query("settings", arrayOf("setting", "value"), null, null, null, null, null).use { cursor ->
-                            while (cursor.moveToNext()) {
-                                when (cursor.getString(0)) {
-                                    "distrustSystemCerts" -> edit.putBoolean(App.DISTRUST_SYSTEM_CERTIFICATES, cursor.getInt(1) != 0)
-                                    "overrideProxy" -> edit.putBoolean(App.OVERRIDE_PROXY, cursor.getInt(1) != 0)
-                                    "overrideProxyHost" -> edit.putString(App.OVERRIDE_PROXY_HOST, cursor.getString(1))
-                                    "overrideProxyPort" -> edit.putInt(App.OVERRIDE_PROXY_PORT, cursor.getInt(1))
-
-                                    StartupDialogFragment.HINT_GOOGLE_PLAY_ACCOUNTS_REMOVED ->
-                                        edit.putBoolean(StartupDialogFragment.HINT_GOOGLE_PLAY_ACCOUNTS_REMOVED, cursor.getInt(1) != 0)
-                                    StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED ->
-                                        edit.putBoolean(StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED, cursor.getInt(1) != 0)
-                                }
-                            }
-                        }
-                        db.execSQL("DROP TABLE settings")
-                    } finally {
-                        edit.apply()
-                    }*/
-                }
-            },
-
-            object : Migration(1, 2) {
-                override fun migrate(db: SupportSQLiteDatabase) {
-                    db.execSQL("ALTER TABLE collections ADD COLUMN type TEXT NOT NULL DEFAULT ''")
-                    db.execSQL("ALTER TABLE collections ADD COLUMN source TEXT DEFAULT NULL")
-                    db.execSQL("UPDATE collections SET type=(" +
-                            "SELECT CASE service WHEN ? THEN ? ELSE ? END " +
-                            "FROM services WHERE _id=collections.serviceID" +
-                            ")",
-                            arrayOf("caldav", "CALENDAR", "ADDRESS_BOOK"))
-                }
-            }
-        )
-
-    }
-
-
-    // DAOs
-
-    abstract fun serviceDao(): ServiceDao
-    abstract fun homeSetDao(): HomeSetDao
-    abstract fun collectionDao(): CollectionDao
-    abstract fun principalDao(): PrincipalDao
-    abstract fun syncStatsDao(): SyncStatsDao
-    abstract fun webDavDocumentDao(): WebDavDocumentDao
-    abstract fun webDavMountDao(): WebDavMountDao
-
-
-    // helpers
-
-    fun dump(writer: Writer, ignoreTables: Array<String>) {
-        val db = openHelper.readableDatabase
-        db.beginTransactionNonExclusive()
-
-        // iterate through all tables
-        db.query(SQLiteQueryBuilder.buildQueryString(false, "sqlite_master", arrayOf("name"), "type='table'", null, null, null, null)).use { cursorTables ->
-            while (cursorTables.moveToNext()) {
-                val tableName = cursorTables.getString(0)
-                if (ignoreTables.contains(tableName)) {
-                    writer.append("$tableName: ")
-                    db.query("SELECT COUNT(*) FROM $tableName").use { cursor ->
-                        if (cursor.moveToNext())
-                            writer.append("${cursor.getInt(0)} row(s), data not listed here\n\n")
-                    }
-                } else {
-                    writer.append("$tableName\n")
-                    db.query("SELECT * FROM $tableName").use { cursor ->
-                        val table = TextTable(*cursor.columnNames)
-                        val cols = cursor.columnCount
-                        // print rows
-                        while (cursor.moveToNext()) {
-                            val values = Array(cols) { idx -> cursor.getStringOrNull(idx) }
-                            table.addLine(*values)
-                        }
-                        writer.append(table.toString())
-                    }
-                }
-            }
-            db.endTransaction()
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/log/LogcatHandler.kt

@@ -1,46 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.log
-
-import android.util.Log
-
-import org.apache.commons.lang3.math.NumberUtils
-
-import java.util.logging.Handler
-import java.util.logging.Level
-import java.util.logging.LogRecord
-
-object LogcatHandler: Handler() {
-
-    private const val MAX_LINE_LENGTH = 3000
-
-    init {
-        formatter = PlainTextFormatter.LOGCAT
-        level = Level.ALL
-    }
-
-    override fun publish(r: LogRecord) {
-        val text = formatter.format(r)
-        val level = r.level.intValue()
-
-        val end = text.length
-        var pos = 0
-        while (pos < end) {
-            val line = text.substring(pos, NumberUtils.min(pos + MAX_LINE_LENGTH, end))
-            when {
-                level >= Level.SEVERE.intValue()  -> Log.e(r.loggerName, line)
-                level >= Level.WARNING.intValue() -> Log.w(r.loggerName, line)
-                level >= Level.CONFIG.intValue()  -> Log.i(r.loggerName, line)
-                level >= Level.FINER.intValue()   -> Log.d(r.loggerName, line)
-                else                              -> Log.v(r.loggerName, line)
-            }
-            pos += MAX_LINE_LENGTH
-        }
-    }
-
-    override fun flush() {}
-    override fun close() {}
-
-}

app/src/main/kotlin/at/bitfire/davdroid/log/Logger.kt

@@ -1,157 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.log
-
-import android.app.Application
-import android.app.PendingIntent
-import android.content.Intent
-import android.content.SharedPreferences
-import android.os.Process
-import android.util.Log
-import android.widget.Toast
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.preference.PreferenceManager
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.ui.AppSettingsActivity
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.NotificationUtils.notifyIfPossible
-import java.io.File
-import java.io.IOException
-import java.util.Date
-import java.util.logging.FileHandler
-import java.util.logging.Level
-
-object Logger : SharedPreferences.OnSharedPreferenceChangeListener {
-
-    private const val LOGGER_NAME = "davx5"
-    const val LOG_TO_FILE = "log_to_file"
-
-    val log: java.util.logging.Logger = java.util.logging.Logger.getLogger(LOGGER_NAME)
-
-    private lateinit var context: Application
-    private lateinit var preferences: SharedPreferences
-
-
-    fun initialize(app: Application) {
-        context = app
-        preferences = PreferenceManager.getDefaultSharedPreferences(context)
-        preferences.registerOnSharedPreferenceChangeListener(this)
-
-        reinitialize()
-    }
-
-    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String?) {
-        if (key == LOG_TO_FILE) {
-            log.info("Logging settings changed; re-initializing logger")
-            reinitialize()
-        }
-    }
-
-    @Synchronized
-    private fun reinitialize() {
-        val logToFile = preferences.getBoolean(LOG_TO_FILE, false)
-        val logVerbose = logToFile || BuildConfig.DEBUG || Log.isLoggable(log.name, Log.DEBUG)
-
-        log.info("Verbose logging: $logVerbose; to file: $logToFile")
-
-        // set logging level according to preferences
-        val rootLogger = java.util.logging.Logger.getLogger("")
-        rootLogger.level = if (logVerbose) Level.ALL else Level.INFO
-
-        // reset all handlers and add our own logcat handler
-        rootLogger.useParentHandlers = false
-        rootLogger.handlers.forEach { handler ->
-            rootLogger.removeHandler(handler)
-            if (handler is FileHandler)     // gracefully close previous verbose-logging FileHandlers
-                handler.close()
-        }
-        rootLogger.addHandler(LogcatHandler)
-
-        val nm = NotificationManagerCompat.from(context)
-        // log to external file according to preferences
-        if (logToFile) {
-            val logFile = getDebugLogFile() ?: return log.warning("Log file could not be retrieved.")
-            if (logFile.createNewFile())
-                logFile.writeText("Log file created at ${Date()}; PID ${Process.myPid()}; UID ${Process.myUid()}\n")
-
-            try {
-                val fileHandler = FileHandler(logFile.toString(), true).apply {
-                    formatter = PlainTextFormatter.DEFAULT
-                }
-                rootLogger.addHandler(fileHandler)
-                log.info("Now logging to file: $logFile")
-
-                val builder = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_DEBUG)
-                builder .setSmallIcon(R.drawable.ic_sd_card_notify)
-                        .setContentTitle(context.getString(R.string.app_settings_logging))
-                        .setCategory(NotificationCompat.CATEGORY_STATUS)
-                        .setPriority(NotificationCompat.PRIORITY_HIGH)
-                        .setContentText(context.getString(R.string.logging_notification_text, context.getString(R.string.app_name)))
-                        .setOngoing(true)
-
-                val shareIntent = DebugInfoActivity.IntentBuilder(context)
-                    .newTask()
-                    .share()
-                val pendingShare = PendingIntent.getActivity(context, 0, shareIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-                builder.addAction(NotificationCompat.Action.Builder(
-                        R.drawable.ic_share,
-                        context.getString(R.string.logging_notification_view_share),
-                        pendingShare
-                ).build())
-
-                val prefIntent = Intent(context, AppSettingsActivity::class.java)
-                prefIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                val pendingPref = PendingIntent.getActivity(context, 0, prefIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-                builder.addAction(NotificationCompat.Action.Builder(
-                        R.drawable.ic_settings,
-                        context.getString(R.string.logging_notification_disable),
-                        pendingPref
-                ).build())
-
-                nm.notifyIfPossible(NotificationUtils.NOTIFY_VERBOSE_LOGGING, builder.build())
-            } catch(e: IOException) {
-                log.log(Level.SEVERE, "Couldn't create log file", e)
-                Toast.makeText(context, context.getString(R.string.logging_couldnt_create_file), Toast.LENGTH_LONG).show()
-            }
-        } else {
-            // verbose logging is disabled -> cancel notification and remove old logs
-            nm.cancel(NotificationUtils.NOTIFY_VERBOSE_LOGGING)
-            debugDir()?.deleteRecursively()
-        }
-    }
-
-
-    /**
-     * Creates (when necessary) and returns the directory where all the debug files (such as log files) are stored.
-     * Must match the contents of `res/xml/debug.paths.xml`.
-     *
-     * @return The directory where all debug info are stored, or `null` if the directory couldn't be created successfully.
-     */
-    fun debugDir(): File? {
-        val dir = File(context.filesDir, "debug")
-        if (dir.exists() && dir.isDirectory)
-            return dir
-
-        if (dir.mkdir())
-            return dir
-
-        Toast.makeText(context, context.getString(R.string.logging_couldnt_create_file), Toast.LENGTH_LONG).show()
-        return null
-    }
-
-    /**
-     * The file (in [debugDir]) where verbose logs are stored.
-     *
-     * @return The file where verbose logs are stored, or `null` if there's no [debugDir].
-     */
-    fun getDebugLogFile(): File? {
-        val logDir = debugDir() ?: return null
-        return File(logDir, "davx5-log.txt")
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/log/PlainTextFormatter.kt

@@ -1,58 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.log
-
-import org.apache.commons.lang3.StringUtils
-import org.apache.commons.lang3.exception.ExceptionUtils
-import org.apache.commons.lang3.time.DateFormatUtils
-import java.util.Locale
-import java.util.logging.Formatter
-import java.util.logging.LogRecord
-
-class PlainTextFormatter private constructor(
-        private val logcat: Boolean
-): Formatter() {
-
-    companion object {
-        val LOGCAT = PlainTextFormatter(true)
-        val DEFAULT = PlainTextFormatter(false)
-
-        const val MAX_MESSAGE_LENGTH = 20000
-    }
-
-    override fun format(r: LogRecord): String {
-        val builder = StringBuilder()
-
-        if (!logcat)
-            builder .append(DateFormatUtils.format(r.millis, "yyyy-MM-dd HH:mm:ss", Locale.ROOT))
-                    .append(" ").append(r.threadID).append(" ")
-
-        val className = shortClassName(r.sourceClassName)
-        if (className != r.loggerName)
-            builder.append("[").append(className).append("] ")
-
-        builder.append(StringUtils.abbreviate(r.message, MAX_MESSAGE_LENGTH))
-
-        r.thrown?.let {
-            builder .append("\nEXCEPTION ")
-                    .append(ExceptionUtils.getStackTrace(it))
-        }
-
-        r.parameters?.let {
-            for ((idx, param) in it.withIndex())
-                builder.append("\n\tPARAMETER #").append(idx).append(" = ").append(param)
-        }
-
-        if (!logcat)
-            builder.append("\n")
-
-        return builder.toString()
-    }
-
-    private fun shortClassName(className: String) = className
-            .replace(Regex("^at\\.bitfire\\.(dav|cert4an|dav4an|ical4an|vcard4an)droid\\."), "")
-            .replace(Regex("\\$.*$"), "")
-
-}

app/src/main/kotlin/at/bitfire/davdroid/log/StringHandler.kt

@@ -1,27 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.log
-
-import java.util.logging.Handler
-import java.util.logging.LogRecord
-
-class StringHandler: Handler() {
-
-    val builder = StringBuilder()
-
-    init {
-        formatter = PlainTextFormatter.DEFAULT
-    }
-
-    override fun publish(record: LogRecord) {
-        builder.append(formatter.format(record))
-    }
-
-    override fun flush() {}
-    override fun close() {}
-
-    override fun toString() = builder.toString()
-
-}

app/src/main/kotlin/at/bitfire/davdroid/network/BearerAuthInterceptor.kt

@@ -1,69 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.network
-
-import at.bitfire.davdroid.log.Logger
-import kotlinx.coroutines.CancellationException
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.runBlocking
-import net.openid.appauth.AuthState
-import net.openid.appauth.AuthorizationException
-import net.openid.appauth.AuthorizationService
-import okhttp3.Interceptor
-import okhttp3.Response
-import java.util.logging.Level
-
-/**
- * Sends an OAuth Bearer token authorization as described in RFC 6750.
- */
-class BearerAuthInterceptor(
-    private val accessToken: String
-): Interceptor {
-
-    companion object {
-
-        fun fromAuthState(authService: AuthorizationService, authState: AuthState, callback: AuthStateUpdateCallback? = null): BearerAuthInterceptor? {
-            return runBlocking {
-                val accessTokenFuture = CompletableDeferred<String>()
-
-                authState.performActionWithFreshTokens(authService) { accessToken: String?, _: String?, ex: AuthorizationException? ->
-                    if (accessToken != null) {
-                        // persist updated AuthState
-                        callback?.onUpdate(authState)
-
-                        // emit access token
-                        accessTokenFuture.complete(accessToken)
-                    }
-                    else {
-                        Logger.log.log(Level.WARNING, "Couldn't obtain access token", ex)
-                        accessTokenFuture.cancel()
-                    }
-                }
-
-                // return value
-                try {
-                    BearerAuthInterceptor(accessTokenFuture.await())
-                } catch (ignored: CancellationException) {
-                    null
-                }
-            }
-        }
-
-    }
-
-    override fun intercept(chain: Interceptor.Chain): Response {
-        Logger.log.finer("Authenticating request with access token")
-        val rq = chain.request().newBuilder()
-            .header("Authorization", "Bearer $accessToken")
-            .build()
-        return chain.proceed(rq)
-    }
-
-
-    fun interface AuthStateUpdateCallback {
-        fun onUpdate(authState: AuthState)
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/network/ConnectionUtils.kt

@@ -1,73 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.network
-
-import android.net.ConnectivityManager
-import android.net.NetworkCapabilities
-import at.bitfire.davdroid.log.Logger
-import java.util.logging.Level
-
-object ConnectionUtils {
-
-    /**
-     * Checks whether we are connected to validated WiFi
-     */
-    internal fun wifiAvailable(connectivityManager: ConnectivityManager): Boolean {
-        connectivityManager.allNetworks.forEach { network ->
-            connectivityManager.getNetworkCapabilities(network)?.let { capabilities ->
-                if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI) &&
-                    capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED))
-                    return true
-            }
-        }
-        return false
-    }
-
-    /**
-     * Checks whether we are connected to the Internet.
-     *
-     * On API 26+ devices, if a VPN is used, WorkManager might start the SyncWorker without an
-     * Internet connection (because [NetworkCapabilities.NET_CAPABILITY_VALIDATED] is always set for VPN connections).
-     * To prevent the start without internet access, we don't check for VPN connections by default
-     * (by using [NetworkCapabilities.NET_CAPABILITY_NOT_VPN]).
-     *
-     * However in special occasions (when syncing over a VPN without validated Internet on the
-     * underlying connection) we do not want to exclude VPNs.
-     *
-     * @param ignoreVpns *true* filters VPN connections in the Internet check; *false* allows them as valid connection
-     * @return whether we are connected to the Internet
-     */
-    internal fun internetAvailable(connectivityManager: ConnectivityManager, ignoreVpns: Boolean): Boolean {
-        return connectivityManager.allNetworks.any { network ->
-            val capabilities = connectivityManager.getNetworkCapabilities(network)
-            Logger.log.log(Level.FINE, "Looking for validated Internet over this connection.",
-                arrayOf(connectivityManager.getNetworkInfo(network), capabilities))
-
-            if (capabilities != null) {
-                if (!capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)) {
-                    Logger.log.fine("Missing network capability: INTERNET")
-                    return@any false
-                }
-
-                if (!capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
-                    Logger.log.fine("Missing network capability: VALIDATED")
-                    return@any false
-                }
-
-                if (ignoreVpns)
-                    if (!capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN)) {
-                        Logger.log.fine("Missing network capability: NOT_VPN")
-                        return@any false
-                    }
-
-                Logger.log.fine("This connection can be used.")
-                /* return@any */ true
-            } else
-                // no network capabilities available, we can't use this connection
-                /* return@any */ false
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/network/GoogleLogin.kt

@@ -1,88 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.network
-
-import android.net.Uri
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.log.Logger
-import kotlinx.coroutines.CompletableDeferred
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import net.openid.appauth.AuthState
-import net.openid.appauth.AuthorizationException
-import net.openid.appauth.AuthorizationRequest
-import net.openid.appauth.AuthorizationResponse
-import net.openid.appauth.AuthorizationService
-import net.openid.appauth.AuthorizationServiceConfiguration
-import net.openid.appauth.ResponseTypeValues
-import net.openid.appauth.TokenResponse
-import java.net.URI
-
-class GoogleLogin(
-    val authService: AuthorizationService
-) {
-
-    companion object {
-
-        // davx5integration@gmail.com (for davx5-ose)
-        private const val CLIENT_ID = "1069050168830-eg09u4tk1cmboobevhm4k3bj1m4fav9i.apps.googleusercontent.com"
-
-        private val SCOPES = arrayOf(
-            "https://www.googleapis.com/auth/calendar",     // CalDAV
-            "https://www.googleapis.com/auth/carddav"       // CardDAV
-        )
-
-        /**
-         * Gets the Google CalDAV/CardDAV base URI. See https://developers.google.com/calendar/caldav/v2/guide;
-         * _calid_ of the primary calendar is the account name.
-         *
-         * This URL allows CardDAV (over well-known URLs) and CalDAV detection including calendar-homesets and secondary
-         * calendars.
-         */
-        fun googleBaseUri(googleAccount: String): URI =
-            URI("https", "apidata.googleusercontent.com", "/caldav/v2/$googleAccount/user", null)
-
-        private val serviceConfig = AuthorizationServiceConfiguration(
-            Uri.parse("https://accounts.google.com/o/oauth2/v2/auth"),
-            Uri.parse("https://oauth2.googleapis.com/token")
-        )
-
-    }
-
-    fun signIn(email: String, customClientId: String?, locale: String?): AuthorizationRequest {
-        val builder = AuthorizationRequest.Builder(
-            GoogleLogin.serviceConfig,
-            customClientId ?: CLIENT_ID,
-            ResponseTypeValues.CODE,
-            Uri.parse(BuildConfig.APPLICATION_ID + ":/oauth2/redirect")
-        )
-        return builder
-            .setScopes(*SCOPES)
-            .setLoginHint(email)
-            .setUiLocales(locale)
-            .build()
-    }
-
-    suspend fun authenticate(authResponse: AuthorizationResponse): Credentials {
-        val authState = AuthState(authResponse, null)       // authorization code must not be stored; exchange it to refresh token
-        val credentials = CompletableDeferred<Credentials>()
-
-        withContext(Dispatchers.IO) {
-            authService.performTokenRequest(authResponse.createTokenExchangeRequest()) { tokenResponse: TokenResponse?, refreshTokenException: AuthorizationException? ->
-                Logger.log.info("Refresh token response: ${tokenResponse?.jsonSerializeString()}")
-
-                if (tokenResponse != null) {
-                    // success, save authState (= refresh token)
-                    authState.update(tokenResponse, refreshTokenException)
-                    credentials.complete(Credentials(authState = authState))
-                }
-            }
-        }
-
-        return credentials.await()
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/network/HttpClient.kt

@@ -1,343 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.network
-
-import android.content.Context
-import android.os.Build
-import android.security.KeyChain
-import at.bitfire.cert4android.CustomCertManager
-import at.bitfire.dav4jvm.BasicDigestAuthHandler
-import at.bitfire.dav4jvm.UrlUtils
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import dagger.hilt.EntryPoint
-import dagger.hilt.InstallIn
-import dagger.hilt.android.EntryPointAccessors
-import dagger.hilt.components.SingletonComponent
-import kotlinx.coroutines.flow.MutableStateFlow
-import net.openid.appauth.AuthState
-import net.openid.appauth.AuthorizationService
-import okhttp3.Cache
-import okhttp3.ConnectionSpec
-import okhttp3.CookieJar
-import okhttp3.Interceptor
-import okhttp3.OkHttp
-import okhttp3.OkHttpClient
-import okhttp3.Protocol
-import okhttp3.Response
-import okhttp3.brotli.BrotliInterceptor
-import okhttp3.internal.tls.OkHostnameVerifier
-import okhttp3.logging.HttpLoggingInterceptor
-import java.io.File
-import java.net.InetSocketAddress
-import java.net.Proxy
-import java.net.Socket
-import java.security.KeyStore
-import java.security.Principal
-import java.text.SimpleDateFormat
-import java.util.Date
-import java.util.Locale
-import java.util.concurrent.TimeUnit
-import java.util.logging.Level
-import javax.net.ssl.KeyManager
-import javax.net.ssl.SSLContext
-import javax.net.ssl.TrustManagerFactory
-import javax.net.ssl.X509ExtendedKeyManager
-import javax.net.ssl.X509TrustManager
-
-class HttpClient @AssistedInject constructor(
-    @Assisted val okHttpClient: OkHttpClient,
-    @Assisted private var authService: AuthorizationService? = null,
-    val settingsManager: SettingsManager
-): AutoCloseable {
-
-    companion object {
-        /** max. size of disk cache (10 MB) */
-        const val DISK_CACHE_MAX_SIZE: Long = 10*1024*1024
-
-        /** Base Builder to build all clients from. Use rarely; [OkHttpClient]s should
-         * be reused as much as possible. */
-        fun baseBuilder() =
-            OkHttpClient.Builder()
-                // Set timeouts. According to [AbstractThreadedSyncAdapter], when there is no network
-                // traffic within a minute, a sync will be cancelled.
-                .connectTimeout(15, TimeUnit.SECONDS)
-                .writeTimeout(30, TimeUnit.SECONDS)
-                .readTimeout(120, TimeUnit.SECONDS)
-                .pingInterval(
-                    45,
-                    TimeUnit.SECONDS
-                )     // avoid cancellation because of missing traffic; only works for HTTP/2
-
-                // keep TLS 1.0 and 1.1 for now; remove when major browsers have dropped it (probably 2020)
-                .connectionSpecs(
-                    listOf(
-                        ConnectionSpec.CLEARTEXT,
-                        ConnectionSpec.COMPATIBLE_TLS
-                    )
-                )
-
-                // don't allow redirects by default, because it would break PROPFIND handling
-                .followRedirects(false)
-
-                // add User-Agent to every request
-                .addInterceptor(UserAgentInterceptor)
-    }
-
-    @AssistedFactory
-    interface Factory {
-        fun create(okHttpClient: OkHttpClient, authService: AuthorizationService?): HttpClient
-    }
-
-
-    override fun close() {
-        authService?.dispose()
-        okHttpClient.cache?.close()
-    }
-
-
-    class Builder(
-        val context: Context,
-        accountSettings: AccountSettings? = null,
-        val logger: java.util.logging.Logger? = Logger.log,
-        val loggerLevel: HttpLoggingInterceptor.Level = HttpLoggingInterceptor.Level.BODY
-    ) {
-
-        @EntryPoint
-        @InstallIn(SingletonComponent::class)
-        interface HttpClientBuilderEntryPoint {
-            fun authorizationService(): AuthorizationService
-            fun httpClientFactory(): HttpClient.Factory
-            fun settingsManager(): SettingsManager
-        }
-
-        private val entryPoint = EntryPointAccessors.fromApplication<HttpClientBuilderEntryPoint>(context)
-
-        fun interface CertManagerProducer {
-            fun certManager(): CustomCertManager
-        }
-
-        private var appInForeground: MutableStateFlow<Boolean>? =
-                MutableStateFlow(false)
-        private var authService: AuthorizationService? = null
-        private var certManagerProducer: CertManagerProducer? = null
-        private var certificateAlias: String? = null
-        private var offerCompression: Boolean = false
-
-        // default cookie store for non-persistent cookies (some services like Horde use cookies for session tracking)
-        private var cookieStore: CookieJar? = MemoryCookieStore()
-
-        private val orig = baseBuilder()
-
-        init {
-            // add network logging, if requested
-            if (logger != null && logger.isLoggable(Level.FINEST)) {
-                val loggingInterceptor = HttpLoggingInterceptor { message -> logger.finest(message) }
-                loggingInterceptor.level = loggerLevel
-                orig.addNetworkInterceptor(loggingInterceptor)
-            }
-
-            val settings = entryPoint.settingsManager()
-
-            // custom proxy support
-            try {
-                val proxyTypeValue = settings.getInt(Settings.PROXY_TYPE)
-                if (proxyTypeValue != Settings.PROXY_TYPE_SYSTEM) {
-                    // we set our own proxy
-                    val address by lazy {           // lazy because not required for PROXY_TYPE_NONE
-                        InetSocketAddress(
-                            settings.getString(Settings.PROXY_HOST),
-                            settings.getInt(Settings.PROXY_PORT)
-                        )
-                    }
-                    val proxy =
-                        when (proxyTypeValue) {
-                            Settings.PROXY_TYPE_NONE -> Proxy.NO_PROXY
-                            Settings.PROXY_TYPE_HTTP -> Proxy(Proxy.Type.HTTP, address)
-                            Settings.PROXY_TYPE_SOCKS -> Proxy(Proxy.Type.SOCKS, address)
-                            else -> throw IllegalArgumentException("Invalid proxy type")
-                        }
-                    orig.proxy(proxy)
-                    Logger.log.log(Level.INFO, "Using proxy setting", proxy)
-                }
-            } catch (e: Exception) {
-                Logger.log.log(Level.SEVERE, "Can't set proxy, ignoring", e)
-            }
-
-            customCertManager {
-                // by default, use a CustomCertManager that respects the "distrust system certificates" setting
-                val trustSystemCerts = !settings.getBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES)
-                CustomCertManager(context, trustSystemCerts, appInForeground)
-            }
-
-            // use account settings for authentication and cookies
-            if (accountSettings != null)
-                addAuthentication(null, accountSettings.credentials(), authStateCallback = { authState: AuthState ->
-                    accountSettings.credentials(Credentials(authState = authState))
-                })
-        }
-
-        constructor(context: Context, host: String?, credentials: Credentials?) : this(context) {
-            if (credentials != null)
-                addAuthentication(host, credentials)
-        }
-
-        fun addAuthentication(host: String?, credentials: Credentials, insecurePreemptive: Boolean = false, authStateCallback: BearerAuthInterceptor.AuthStateUpdateCallback? = null): Builder {
-            if (credentials.username != null && credentials.password != null) {
-                val authHandler = BasicDigestAuthHandler(UrlUtils.hostToDomain(host), credentials.username, credentials.password, insecurePreemptive)
-                orig.addNetworkInterceptor(authHandler)
-                    .authenticator(authHandler)
-            }
-
-            if (credentials.certificateAlias != null)
-                certificateAlias = credentials.certificateAlias
-
-            credentials.authState?.let { authState ->
-                val newAuthService = entryPoint.authorizationService()
-                authService = newAuthService
-                BearerAuthInterceptor.fromAuthState(newAuthService, authState, authStateCallback)?.let { bearerAuthInterceptor ->
-                    orig.addNetworkInterceptor(bearerAuthInterceptor)
-                }
-            }
-            return this
-        }
-
-        fun allowCompression(allow: Boolean): Builder {
-            offerCompression = allow
-            return this
-        }
-
-        fun cookieStore(store: CookieJar?): Builder {
-            cookieStore = store
-            return this
-        }
-
-        fun followRedirects(follow: Boolean): Builder {
-            orig.followRedirects(follow)
-            return this
-        }
-
-        fun customCertManager(producer: CertManagerProducer) {
-            certManagerProducer = producer
-        }
-        fun setForeground(foreground: Boolean): Builder {
-            appInForeground?.value = foreground
-            return this
-        }
-
-        fun withDiskCache(): Builder {
-            for (dir in arrayOf(context.externalCacheDir, context.cacheDir).filterNotNull()) {
-                if (dir.exists() && dir.canWrite()) {
-                    val cacheDir = File(dir, "HttpClient")
-                    cacheDir.mkdir()
-                    Logger.log.fine("Using disk cache: $cacheDir")
-                    orig.cache(Cache(cacheDir, DISK_CACHE_MAX_SIZE))
-                    break
-                }
-            }
-            return this
-        }
-
-        fun build(): HttpClient {
-            cookieStore?.let {
-                orig.cookieJar(it)
-            }
-
-            if (offerCompression)
-                // offer Brotli and gzip compression
-                orig.addInterceptor(BrotliInterceptor)
-
-            var keyManager: KeyManager? = null
-            certificateAlias?.let { alias ->
-                // get provider certificate and private key
-                val certs = KeyChain.getCertificateChain(context, alias) ?: return@let
-                val key = KeyChain.getPrivateKey(context, alias) ?: return@let
-                logger?.fine("Using provider certificate $alias for authentication (chain length: ${certs.size})")
-
-                // create KeyManager
-                keyManager = object : X509ExtendedKeyManager() {
-                    override fun getServerAliases(p0: String?, p1: Array<out Principal>?): Array<String>? = null
-                    override fun chooseServerAlias(p0: String?, p1: Array<out Principal>?, p2: Socket?) = null
-
-                    override fun getClientAliases(p0: String?, p1: Array<out Principal>?) =
-                            arrayOf(alias)
-
-                    override fun chooseClientAlias(p0: Array<out String>?, p1: Array<out Principal>?, p2: Socket?) =
-                            alias
-
-                    override fun getCertificateChain(forAlias: String?) =
-                            certs.takeIf { forAlias == alias }
-
-                    override fun getPrivateKey(forAlias: String?) =
-                            key.takeIf { forAlias == alias }
-                }
-
-                // HTTP/2 doesn't support client certificates (yet)
-                // see https://tools.ietf.org/html/draft-ietf-httpbis-http2-secondary-certs-04
-                orig.protocols(listOf(Protocol.HTTP_1_1))
-            }
-
-            if (certManagerProducer != null || keyManager != null) {
-                val manager = certManagerProducer?.certManager()
-
-                val trustManager = manager ?: /* fall back to system default trust manager */
-                    TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
-                    .let { factory ->
-                        factory.init(null as KeyStore?)
-                        factory.trustManagers.first() as X509TrustManager
-                    }
-
-                val hostnameVerifier =
-                    if (manager != null)
-                        manager.HostnameVerifier(OkHostnameVerifier)
-                    else
-                        OkHostnameVerifier
-
-                val sslContext = SSLContext.getInstance("TLS")
-                sslContext.init(
-                    if (keyManager != null) arrayOf(keyManager) else null,
-                    arrayOf(trustManager),
-                    null)
-                orig.sslSocketFactory(sslContext.socketFactory, trustManager)
-                orig.hostnameVerifier(hostnameVerifier)
-            }
-
-            return entryPoint.httpClientFactory().create(orig.build(), authService = authService)
-        }
-
-    }
-
-
-    object UserAgentInterceptor: Interceptor {
-
-        // use Locale.ROOT because numbers may be encoded as non-ASCII characters in other locales
-        private val userAgentDateFormat = SimpleDateFormat("yyyy/MM/dd", Locale.ROOT)
-        private val userAgentDate = userAgentDateFormat.format(Date(BuildConfig.buildTime))
-        val userAgent = "${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ($userAgentDate; dav4jvm; " +
-                "okhttp/${OkHttp.VERSION}) Android/${Build.VERSION.RELEASE}"
-
-        init {
-            Logger.log.info("Will set \"User-Agent: $userAgent\" for further requests")
-        }
-
-        override fun intercept(chain: Interceptor.Chain): Response {
-            val locale = Locale.getDefault()
-            val request = chain.request().newBuilder()
-                    .header("User-Agent", userAgent)
-                    .header("Accept-Language", "${locale.language}-${locale.country}, ${locale.language};q=0.7, *;q=0.5")
-                    .build()
-            return chain.proceed(request)
-        }
-
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/network/MemoryCookieStore.kt

@@ -1,59 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.network
-
-import okhttp3.Cookie
-import okhttp3.CookieJar
-import okhttp3.HttpUrl
-import org.apache.commons.collections4.keyvalue.MultiKey
-import org.apache.commons.collections4.map.HashedMap
-import org.apache.commons.collections4.map.MultiKeyMap
-import java.util.LinkedList
-
-/**
- * Primitive cookie store that stores cookies in a (volatile) hash map.
- * Will be sufficient for session cookies.
- */
-class MemoryCookieStore: CookieJar {
-
-    /**
-     * Stored cookies. The multi-key consists of three parts: name, domain, and path.
-     * This ensures that cookies can be overwritten. [RFC 6265 5.3 Storage Model]
-     * Not thread-safe!
-     */
-    private val storage = MultiKeyMap.multiKeyMap(HashedMap<MultiKey<out String>, Cookie>())!!
-
-    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
-        synchronized(storage) {
-            for (cookie in cookies)
-                storage.put(cookie.name, cookie.domain, cookie.path, cookie)
-        }
-    }
-
-    override fun loadForRequest(url: HttpUrl): List<Cookie> {
-        val cookies = LinkedList<Cookie>()
-
-        synchronized(storage) {
-            val iter = storage.mapIterator()
-            while (iter.hasNext()) {
-                iter.next()
-                val cookie = iter.value
-
-                // remove expired cookies
-                if (cookie.expiresAt <= System.currentTimeMillis()) {
-                    iter.remove()
-                    continue
-                }
-
-                // add applicable cookies
-                if (cookie.matches(url))
-                    cookies += cookie
-            }
-        }
-
-        return cookies
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/network/NextcloudLoginFlow.kt

@@ -1,141 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.network
-
-import android.content.Context
-import at.bitfire.dav4jvm.exception.DavException
-import at.bitfire.dav4jvm.exception.HttpException
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.ui.setup.LoginInfo
-import at.bitfire.vcard4android.GroupMethod
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
-import okhttp3.HttpUrl
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import okhttp3.MediaType.Companion.toMediaType
-import okhttp3.Request
-import okhttp3.RequestBody
-import okhttp3.RequestBody.Companion.toRequestBody
-import org.apache.commons.lang3.StringUtils
-import org.json.JSONObject
-import java.net.HttpURLConnection
-import java.net.URI
-
-/**
- * Implements Nextcloud Login Flow v2.
- *
- * See https://docs.nextcloud.com/server/latest/developer_manual/client_apis/LoginFlow/index.html#login-flow-v2
- */
-class NextcloudLoginFlow(
-    context: Context
-): AutoCloseable {
-
-    companion object {
-        const val FLOW_V1_PATH = "index.php/login/flow"
-        const val FLOW_V2_PATH = "index.php/login/v2"
-
-        /** Path to DAV endpoint (e.g. `remote.php/dav`). Will be appended to the server URL returned by Login Flow. */
-        const val DAV_PATH = "remote.php/dav"
-    }
-
-    val httpClient = HttpClient.Builder(context)
-        .setForeground(true)
-        .build()
-
-    override fun close() {
-        httpClient.close()
-    }
-
-
-    // Login flow state
-    var loginUrl: HttpUrl? = null
-    var pollUrl: HttpUrl? = null
-    var token: String? = null
-
-
-    suspend fun initiate(baseUrl: HttpUrl): HttpUrl? {
-        loginUrl = null
-        pollUrl = null
-        token = null
-
-        val json = postForJson(initiateUrl(baseUrl), "".toRequestBody())
-
-        loginUrl = json.getString("login").toHttpUrlOrNull()
-        json.getJSONObject("poll").let { poll ->
-            pollUrl = poll.getString("endpoint").toHttpUrl()
-            token = poll.getString("token")
-        }
-
-        return loginUrl
-    }
-
-    fun initiateUrl(baseUrl: HttpUrl): HttpUrl {
-        val path = baseUrl.encodedPath
-
-        if (path.endsWith(FLOW_V2_PATH))
-            // already a Login Flow v2 URL
-            return baseUrl
-
-        if (path.endsWith(FLOW_V1_PATH))
-            // Login Flow v1 URL, rewrite to v2
-            return baseUrl.newBuilder()
-                .encodedPath(path.replace(FLOW_V1_PATH, FLOW_V2_PATH))
-                .build()
-
-        // other URL, make it a Login Flow v2 URL
-        return baseUrl.newBuilder()
-            .addPathSegments(FLOW_V2_PATH)
-            .build()
-    }
-
-
-    suspend fun fetchLoginInfo(): LoginInfo {
-        val pollUrl = pollUrl ?: throw IllegalArgumentException("Missing pollUrl")
-        val token = token ?: throw IllegalArgumentException("Missing token")
-
-        // send HTTP request to request server, login name and app password
-        val json = postForJson(pollUrl, "token=$token".toRequestBody("application/x-www-form-urlencoded".toMediaType()))
-
-        // make sure server URL ends with a slash so that DAV_PATH can be appended
-        val serverUrl = StringUtils.appendIfMissing(json.getString("server"), "/")
-
-        return LoginInfo(
-            baseUri = URI(serverUrl).resolve(DAV_PATH),
-            credentials = Credentials(
-                username = json.getString("loginName"),
-                password = json.getString("appPassword")
-            ),
-            suggestedGroupMethod = GroupMethod.CATEGORIES
-        )
-    }
-
-
-    private suspend fun postForJson(url: HttpUrl, requestBody: RequestBody): JSONObject = withContext(Dispatchers.IO) {
-        val postRq = Request.Builder()
-            .url(url)
-            .post(requestBody)
-            .build()
-        val response = runInterruptible {
-            httpClient.okHttpClient.newCall(postRq).execute()
-        }
-
-        if (response.code != HttpURLConnection.HTTP_OK)
-            throw HttpException(response)
-
-        response.body?.use { body ->
-            val mimeType = body.contentType() ?: throw DavException("Login Flow response without MIME type")
-            if (mimeType.type != "application" || mimeType.subtype != "json")
-                throw DavException("Invalid Login Flow response (not JSON)")
-
-            // decode JSON
-            return@withContext JSONObject(body.string())
-        }
-
-        throw DavException("Invalid Login Flow response (no body)")
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/repository/AccountRepository.kt

@@ -1,311 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.repository
-
-import android.Manifest
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.accounts.OnAccountsUpdateListener
-import android.app.Application
-import android.content.ContentResolver
-import android.content.pm.PackageManager
-import android.provider.CalendarContract
-import android.provider.ContactsContract
-import androidx.core.content.ContextCompat
-import at.bitfire.davdroid.InvalidAccountException
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.db.HomeSet
-import at.bitfire.davdroid.db.Service
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.resource.LocalTaskList
-import at.bitfire.davdroid.servicedetection.DavResourceFinder
-import at.bitfire.davdroid.servicedetection.RefreshCollectionsWorker
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.syncadapter.AccountUtils
-import at.bitfire.davdroid.syncadapter.AccountsCleanupWorker
-import at.bitfire.davdroid.syncadapter.BaseSyncWorker
-import at.bitfire.davdroid.syncadapter.PeriodicSyncWorker
-import at.bitfire.davdroid.util.TaskUtils
-import at.bitfire.vcard4android.GroupMethod
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.channels.awaitClose
-import kotlinx.coroutines.flow.callbackFlow
-import kotlinx.coroutines.withContext
-import java.util.logging.Level
-import javax.inject.Inject
-
-/**
- * Repository for managing CalDAV/CardDAV accounts.
- *
- * *Note:* This class is not related to address book accounts, which are managed by
- * [at.bitfire.davdroid.resource.LocalAddressBook].
- */
-class AccountRepository @Inject constructor(
-    val context: Application,
-    val db: AppDatabase,
-    val settingsManager: SettingsManager,
-    val serviceRepository: DavServiceRepository
-) {
-
-    private val accountType = context.getString(R.string.account_type)
-    private val accountManager = AccountManager.get(context)
-
-    /**
-     * Creates a new main account with discovered services and enables periodic syncs with
-     * default sync interval times.
-     *
-     * @param accountName   name of the account
-     * @param credentials   server credentials
-     * @param config        discovered server capabilities for syncable authorities
-     * @param groupMethod   whether CardDAV contact groups are separate VCards or as contact categories
-     *
-     * @return account if account creation was successful; null otherwise (for instance because an account with this name already exists)
-     */
-    fun create(accountName: String, credentials: Credentials?, config: DavResourceFinder.Configuration, groupMethod: GroupMethod): Account? {
-        val account = account(accountName)
-
-        // create Android account
-        val userData = AccountSettings.initialUserData(credentials)
-        Logger.log.log(Level.INFO, "Creating Android account with initial config", arrayOf(account, userData))
-
-        if (!AccountUtils.createAccount(context, account, userData, credentials?.password))
-            return null
-
-        // add entries for account to service DB
-        Logger.log.log(Level.INFO, "Writing account configuration to database", config)
-        try {
-            val accountSettings = AccountSettings(context, account)
-            val defaultSyncInterval = settingsManager.getLong(Settings.DEFAULT_SYNC_INTERVAL)
-
-            // Configure CardDAV service
-            val addrBookAuthority = context.getString(R.string.address_books_authority)
-            if (config.cardDAV != null) {
-                // insert CardDAV service
-                val id = insertService(accountName, Service.TYPE_CARDDAV, config.cardDAV)
-
-                // initial CardDAV account settings
-                accountSettings.setGroupMethod(groupMethod)
-
-                // start CardDAV service detection (refresh collections)
-                RefreshCollectionsWorker.enqueue(context, id)
-
-                // set default sync interval and enable sync regardless of permissions
-                ContentResolver.setIsSyncable(account, addrBookAuthority, 1)
-                accountSettings.setSyncInterval(addrBookAuthority, defaultSyncInterval)
-            } else
-                ContentResolver.setIsSyncable(account, addrBookAuthority, 0)
-
-            // Configure CalDAV service
-            if (config.calDAV != null) {
-                // insert CalDAV service
-                val id = insertService(accountName, Service.TYPE_CALDAV, config.calDAV)
-
-                // start CalDAV service detection (refresh collections)
-                RefreshCollectionsWorker.enqueue(context, id)
-
-                // set default sync interval and enable sync regardless of permissions
-                ContentResolver.setIsSyncable(account, CalendarContract.AUTHORITY, 1)
-                accountSettings.setSyncInterval(CalendarContract.AUTHORITY, defaultSyncInterval)
-
-                // if task provider present, set task sync interval and enable sync
-                val taskProvider = TaskUtils.currentProvider(context)
-                if (taskProvider != null) {
-                    ContentResolver.setIsSyncable(account, taskProvider.authority, 1)
-                    accountSettings.setSyncInterval(taskProvider.authority, defaultSyncInterval)
-                    // further changes will be handled by TasksWatcher on app start or when tasks app is (un)installed
-                    Logger.log.info("Tasks provider ${taskProvider.authority} found. Tasks sync enabled.")
-                } else
-                    Logger.log.info("No tasks provider found. Did not enable tasks sync.")
-            } else
-                ContentResolver.setIsSyncable(account, CalendarContract.AUTHORITY, 0)
-
-        } catch(e: InvalidAccountException) {
-            Logger.log.log(Level.SEVERE, "Couldn't access account settings", e)
-            return null
-        }
-        return account
-    }
-
-    suspend fun delete(accountName: String): Boolean {
-        // remove account
-        val future = accountManager.removeAccount(account(accountName), null, null, null)
-        return try {
-            // wait for operation to complete
-            withContext(Dispatchers.Default) {
-                // blocks calling thread
-                future.result
-            }
-
-            // delete address book accounts
-            LocalAddressBook.deleteByAccount(context, accountName)
-
-            // delete from database
-            serviceRepository.deleteByAccount(accountName)
-
-            true
-        } catch (e: Exception) {
-            Logger.log.log(Level.WARNING, "Couldn't remove account $accountName", e)
-            false
-        }
-    }
-
-    fun exists(accountName: String): Boolean =
-        if (accountName.isEmpty())
-            false
-        else
-            accountManager
-                .getAccountsByType(accountType)
-                .contains(Account(accountName, accountType))
-
-    fun getAll(): Array<Account> = accountManager.getAccountsByType(accountType)
-
-    fun getAllFlow() = callbackFlow<Set<Account>> {
-        val listener = OnAccountsUpdateListener { accounts ->
-            trySend(accounts.filter { it.type == accountType }.toSet())
-        }
-        accountManager.addOnAccountsUpdatedListener(listener, null, true)
-
-        awaitClose {
-            accountManager.removeOnAccountsUpdatedListener(listener)
-        }
-    }
-
-    /**
-     * Renames an account.
-     *
-     * **Not**: It is highly advised to re-sync the account after renaming in order to restore
-     * a consistent state.
-     *
-     * @param oldName current name of the account
-     * @param newName new name the account shall be re named to
-     *
-     * @throws InvalidAccountException if the account does not exist
-     * @throws IllegalArgumentException if the new account name already exists
-     * @throws Exception (or sub-classes) on other errors
-     */
-    suspend fun rename(oldName: String, newName: String) {
-        val oldAccount = account(oldName)
-        val newAccount = account(newName)
-
-        // check whether new account name already exists
-        if (accountManager.getAccountsByType(context.getString(R.string.account_type)).contains(newAccount))
-            throw IllegalArgumentException("Account with name \"$newName\" already exists")
-
-        // remember sync intervals
-        val oldSettings = AccountSettings(context, oldAccount)
-        val authorities = mutableListOf(
-            context.getString(R.string.address_books_authority),
-            CalendarContract.AUTHORITY
-        )
-        val tasksProvider = TaskUtils.currentProvider(context)
-        tasksProvider?.authority?.let { authorities.add(it) }
-        val syncIntervals = authorities.map { Pair(it, oldSettings.getSyncInterval(it)) }
-
-        // rename account
-        try {
-            /* https://github.com/bitfireAT/davx5/issues/135
-            Lock accounts cleanup so that the AccountsCleanupWorker doesn't run while we rename the account
-            because this can cause problems when:
-            1. The account is renamed.
-            2. The AccountsCleanupWorker is called BEFORE the services table is updated.
-               → AccountsCleanupWorker removes the "orphaned" services because they belong to the old account which doesn't exist anymore
-            3. Now the services would be renamed, but they're not here anymore. */
-            AccountsCleanupWorker.lockAccountsCleanup()
-
-            // rename account
-            val future = accountManager.renameAccount(oldAccount, newName, null, null)
-
-            // wait for operation to complete
-            withContext(Dispatchers.Default) {
-                // blocks calling thread
-                val newNameFromApi: Account = future.result
-                if (newNameFromApi.name != newName)
-                    throw IllegalStateException("renameAccount returned ${newNameFromApi.name} instead of $newName")
-            }
-
-            // account renamed, cancel maybe running synchronization of old account
-            BaseSyncWorker.cancelAllWork(context, oldAccount)
-
-            // disable periodic syncs for old account
-            syncIntervals.forEach { (authority, _) ->
-                PeriodicSyncWorker.disable(context, oldAccount, authority)
-            }
-
-            // update account name references in database
-            serviceRepository.renameAccount(oldName, newName)
-
-            // update main account of address book accounts
-            if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CONTACTS) == PackageManager.PERMISSION_GRANTED)
-                try {
-                    context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.use { provider ->
-                        for (addrBookAccount in accountManager.getAccountsByType(context.getString(R.string.account_type_address_book))) {
-                            val addressBook = LocalAddressBook(context, addrBookAccount, provider)
-                            if (oldAccount == addressBook.mainAccount)
-                                addressBook.mainAccount = Account(newName, oldAccount.type)
-                        }
-                    }
-                } catch (e: Exception) {
-                    Logger.log.log(Level.SEVERE, "Couldn't update address book accounts", e)
-                    // Couldn't update address book accounts, but this is not a fatal error (will be fixed at next sync)
-                }
-
-            // calendar provider doesn't allow changing account_name of Events
-            // (all events will have to be downloaded again at next sync)
-
-            // update account_name of local tasks
-            try {
-                LocalTaskList.onRenameAccount(context, oldAccount.name, newName)
-            } catch (e: Exception) {
-                Logger.log.log(Level.WARNING, "Couldn't propagate new account name to tasks provider", e)
-                // Couldn't update task lists, but this is not a fatal error (will be fixed at next sync)
-            }
-
-            // restore sync intervals
-            val newSettings = AccountSettings(context, newAccount)
-            for ((authority, interval) in syncIntervals) {
-                if (interval == null)
-                    ContentResolver.setIsSyncable(newAccount, authority, 0)
-                else {
-                    ContentResolver.setIsSyncable(newAccount, authority, 1)
-                    newSettings.setSyncInterval(authority, interval)
-                }
-            }
-        } finally {
-            // release AccountsCleanupWorker mutex at the end of this async coroutine
-            AccountsCleanupWorker.unlockAccountsCleanup()
-        }
-    }
-
-
-    // helpers
-
-    private fun account(accountName: String) = Account(accountName, accountType)
-
-    private fun insertService(accountName: String, type: String, info: DavResourceFinder.Configuration.ServiceInfo): Long {
-        // insert service
-        val service = Service(0, accountName, type, info.principal)
-        val serviceId = db.serviceDao().insertOrReplace(service)
-
-        // insert home sets
-        val homeSetDao = db.homeSetDao()
-        for (homeSet in info.homeSets)
-            homeSetDao.insertOrUpdateByUrl(HomeSet(0, serviceId, true, homeSet))
-
-        // insert collections
-        val collectionDao = db.collectionDao()
-        for (collection in info.collections.values) {
-            collection.serviceId = serviceId
-            collectionDao.insertOrUpdateByUrl(collection)
-        }
-
-        return serviceId
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/repository/DavCollectionRepository.kt

@@ -1,291 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.repository
-
-import android.accounts.Account
-import android.app.Application
-import at.bitfire.dav4jvm.DavResource
-import at.bitfire.dav4jvm.XmlUtils
-import at.bitfire.dav4jvm.XmlUtils.insertTag
-import at.bitfire.dav4jvm.property.caldav.CalendarColor
-import at.bitfire.dav4jvm.property.caldav.CalendarDescription
-import at.bitfire.dav4jvm.property.caldav.CalendarTimezone
-import at.bitfire.dav4jvm.property.caldav.NS_CALDAV
-import at.bitfire.dav4jvm.property.caldav.SupportedCalendarComponentSet
-import at.bitfire.dav4jvm.property.carddav.AddressbookDescription
-import at.bitfire.dav4jvm.property.carddav.NS_CARDDAV
-import at.bitfire.dav4jvm.property.webdav.DisplayName
-import at.bitfire.dav4jvm.property.webdav.NS_WEBDAV
-import at.bitfire.dav4jvm.property.webdav.ResourceType
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.HomeSet
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.servicedetection.RefreshCollectionsWorker
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.util.DavUtils
-import at.bitfire.ical4android.util.DateUtils
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
-import net.fortuna.ical4j.model.Component
-import okhttp3.HttpUrl
-import java.io.StringWriter
-import java.util.UUID
-import javax.inject.Inject
-
-class DavCollectionRepository @Inject constructor(
-    val context: Application,
-    db: AppDatabase
-) {
-
-    private val serviceDao = db.serviceDao()
-    private val dao = db.collectionDao()
-
-    suspend fun anyWebcal(serviceId: Long) =
-        dao.anyOfType(serviceId, Collection.TYPE_WEBCAL)
-
-    suspend fun createAddressBook(
-        account: Account,
-        homeSet: HomeSet,
-        displayName: String,
-        description: String?
-    ) {
-        val folderName = UUID.randomUUID().toString()
-        val url = homeSet.url.newBuilder()
-            .addPathSegment(folderName)
-            .addPathSegment("")     // trailing slash
-            .build()
-
-        // create collection on server
-        createOnServer(
-            account = account,
-            url = url,
-            method = "MKCOL",
-            xmlBody = generateMkColXml(
-                addressBook = true,
-                displayName = displayName,
-                description = description
-            )
-        )
-
-        // no HTTP error -> create collection locally
-        val collection = Collection(
-            serviceId = homeSet.serviceId,
-            homeSetId = homeSet.id,
-            url = url,
-            type = Collection.TYPE_ADDRESSBOOK, //if (addressBook) Collection.TYPE_ADDRESSBOOK else Collection.TYPE_CALENDAR,
-            displayName = displayName,
-            description = description
-        )
-        dao.insertAsync(collection)
-    }
-
-    suspend fun createCalendar(
-        account: Account,
-        homeSet: HomeSet,
-        color: Int?,
-        displayName: String,
-        description: String?,
-        timeZoneId: String?,
-        supportVEVENT: Boolean,
-        supportVTODO: Boolean,
-        supportVJOURNAL: Boolean
-    ) {
-        val folderName = UUID.randomUUID().toString()
-        val url = homeSet.url.newBuilder()
-            .addPathSegment(folderName)
-            .addPathSegment("")     // trailing slash
-            .build()
-
-        // create collection on server
-        createOnServer(
-            account = account,
-            url = url,
-            method = "MKCALENDAR",
-            xmlBody = generateMkColXml(
-                addressBook = false,
-                displayName = displayName,
-                description = description,
-                color = color,
-                timezoneDef = timeZoneId,
-                supportsVEVENT = supportVEVENT,
-                supportsVTODO = supportVTODO,
-                supportsVJOURNAL = supportVJOURNAL
-            )
-        )
-
-        // no HTTP error -> create collection locally
-        val collection = Collection(
-            serviceId = homeSet.serviceId,
-            homeSetId = homeSet.id,
-            url = url,
-            type = Collection.TYPE_CALENDAR,
-            displayName = displayName,
-            description = description,
-            color = color,
-            timezone = timeZoneId?.let { getVTimeZone(it) },
-            supportsVEVENT = supportVEVENT,
-            supportsVTODO = supportVTODO,
-            supportsVJOURNAL = supportVJOURNAL
-        )
-        dao.insertAsync(collection)
-
-        // Trigger service detection (because the collection may actually have other properties than the ones we have inserted).
-        // Some servers are known to change the supported components (VEVENT, …) after creation.
-        RefreshCollectionsWorker.enqueue(context, homeSet.serviceId)
-    }
-
-    /** Deletes the given collection from the server and the database. */
-    suspend fun delete(collection: Collection) {
-        val service = serviceDao.get(collection.serviceId) ?: throw IllegalArgumentException("Service not found")
-        val account = Account(service.accountName, context.getString(R.string.account_type))
-
-        HttpClient.Builder(context, AccountSettings(context, account))
-            .setForeground(true)
-            .build().use { httpClient ->
-                withContext(Dispatchers.IO) {
-                    runInterruptible {
-                        DavResource(httpClient.okHttpClient, collection.url).delete() {
-                            // success, otherwise an exception would have been thrown
-                            dao.delete(collection)
-                        }
-                    }
-                }
-            }
-    }
-
-    fun getFlow(id: Long) = dao.getFlow(id)
-
-    suspend fun setForceReadOnly(id: Long, forceReadOnly: Boolean) {
-        dao.updateForceReadOnly(id, forceReadOnly)
-    }
-
-    suspend fun setSync(id: Long, forceReadOnly: Boolean) {
-        dao.updateSync(id, forceReadOnly)
-    }
-
-
-    // helpers
-
-    private suspend fun createOnServer(account: Account, url: HttpUrl, method: String, xmlBody: String) {
-        HttpClient.Builder(context, AccountSettings(context, account))
-            .setForeground(true)
-            .build().use { httpClient ->
-                withContext(Dispatchers.IO) {
-                    runInterruptible {
-                        DavResource(httpClient.okHttpClient, url).mkCol(
-                            xmlBody = xmlBody,
-                            method = method
-                        ) {
-                            // success, otherwise an exception would have been thrown
-                        }
-                    }
-                }
-            }
-    }
-
-    private fun generateMkColXml(
-        addressBook: Boolean,
-        displayName: String?,
-        description: String?,
-        color: Int? = null,
-        timezoneDef: String? = null,
-        supportsVEVENT: Boolean = true,
-        supportsVTODO: Boolean = true,
-        supportsVJOURNAL: Boolean = true
-    ): String {
-        val writer = StringWriter()
-        val serializer = XmlUtils.newSerializer()
-        serializer.apply {
-            setOutput(writer)
-
-            startDocument("UTF-8", null)
-            setPrefix("", NS_WEBDAV)
-            setPrefix("CAL", NS_CALDAV)
-            setPrefix("CARD", NS_CARDDAV)
-
-            if (addressBook)
-                startTag(NS_WEBDAV, "mkcol")
-            else
-                startTag(NS_CALDAV, "mkcalendar")
-
-            insertTag(DavResource.SET) {
-                insertTag(DavResource.PROP) {
-                    insertTag(ResourceType.NAME) {
-                        insertTag(ResourceType.COLLECTION)
-                        if (addressBook)
-                            insertTag(ResourceType.ADDRESSBOOK)
-                        else
-                            insertTag(ResourceType.CALENDAR)
-                    }
-
-                    displayName?.let {
-                        insertTag(DisplayName.NAME) {
-                            text(it)
-                        }
-                    }
-
-                    if (addressBook) {
-                        // addressbook-specific properties
-                        description?.let {
-                            insertTag(AddressbookDescription.NAME) {
-                                text(it)
-                            }
-                        }
-
-                    } else {
-                        // calendar-specific properties
-                        description?.let {
-                            insertTag(CalendarDescription.NAME) {
-                                text(it)
-                            }
-                        }
-                        color?.let {
-                            insertTag(CalendarColor.NAME) {
-                                text(DavUtils.ARGBtoCalDAVColor(it))
-                            }
-                        }
-                        timezoneDef?.let {
-                            insertTag(CalendarTimezone.NAME) {
-                                cdsect(it)
-                            }
-                        }
-
-                        if (!supportsVEVENT || !supportsVTODO || !supportsVJOURNAL) {
-                            insertTag(SupportedCalendarComponentSet.NAME) {
-                                // Only if there's at least one not explicitly supported calendar component set,
-                                // otherwise don't include the property, which means "supports everything".
-                                if (supportsVEVENT)
-                                    insertTag(SupportedCalendarComponentSet.COMP) {
-                                        attribute(null, "name", Component.VEVENT)
-                                    }
-                                if (supportsVTODO)
-                                    insertTag(SupportedCalendarComponentSet.COMP) {
-                                        attribute(null, "name", Component.VTODO)
-                                    }
-                                if (supportsVJOURNAL)
-                                    insertTag(SupportedCalendarComponentSet.COMP) {
-                                        attribute(null, "name", Component.VJOURNAL)
-                                    }
-                            }
-                        }
-                    }
-                }
-            }
-            if (addressBook)
-                endTag(NS_WEBDAV, "mkcol")
-            else
-                endTag(NS_CALDAV, "mkcalendar")
-            endDocument()
-        }
-        return writer.toString()
-    }
-
-    private fun getVTimeZone(tzId: String): String? =
-        DateUtils.ical4jTimeZone(tzId)?.toString()
-
-}

app/src/main/kotlin/at/bitfire/davdroid/repository/DavSyncStatsRepository.kt

@@ -1,60 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.repository
-
-import android.app.Application
-import android.content.pm.PackageManager
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.log.Logger
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
-import java.text.Collator
-import javax.inject.Inject
-
-class DavSyncStatsRepository @Inject constructor(
-    val context: Application,
-    db: AppDatabase
-) {
-
-    private val dao = db.syncStatsDao()
-
-    data class LastSynced(
-        val appName: String,
-        val lastSynced: Long
-    )
-    fun getLastSyncedFlow(collectionId: Long): Flow<List<LastSynced>> =
-        dao.getByCollectionIdFlow(collectionId).map { list ->
-            val collator = Collator.getInstance()
-            list.map { stats ->
-                LastSynced(
-                    appName = appNameFromAuthority(stats.authority),
-                    lastSynced = stats.lastSync
-                )
-            }.sortedWith { a, b ->
-                collator.compare(a.appName, b.appName)
-            }
-        }
-
-
-    /**
-     * Tries to find the application name for given authority. Returns the authority if not
-     * found.
-     *
-     * @param authority authority to find the application name for (ie "at.techbee.jtx")
-     * @return the application name of authority (ie "jtx Board")
-     */
-    private fun appNameFromAuthority(authority: String): String {
-        val packageManager = context.packageManager
-        val packageName = packageManager.resolveContentProvider(authority, 0)?.packageName ?: authority
-        return try {
-            val appInfo = packageManager.getPackageInfo(packageName, 0).applicationInfo
-            packageManager.getApplicationLabel(appInfo).toString()
-        } catch (e: PackageManager.NameNotFoundException) {
-            Logger.log.warning("Application name not found for authority: $authority")
-            authority
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalAddressBook.kt

@@ -1,452 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.ContentProviderClient
-import android.content.ContentResolver
-import android.content.ContentUris
-import android.content.ContentValues
-import android.content.Context
-import android.os.Build
-import android.os.Bundle
-import android.os.RemoteException
-import android.provider.ContactsContract
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
-import android.provider.ContactsContract.Groups
-import android.provider.ContactsContract.RawContacts
-import android.util.Base64
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.SyncState
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.syncadapter.AccountUtils
-import at.bitfire.davdroid.util.lastSegment
-import at.bitfire.davdroid.util.setAndVerifyUserData
-import at.bitfire.vcard4android.AndroidAddressBook
-import at.bitfire.vcard4android.AndroidContact
-import at.bitfire.vcard4android.AndroidGroup
-import at.bitfire.vcard4android.Constants
-import at.bitfire.vcard4android.GroupMethod
-import java.io.ByteArrayOutputStream
-import java.util.LinkedList
-import java.util.logging.Level
-
-/**
- * A local address book. Requires an own Android account, because Android manages contacts per
- * account and there is no such thing as "address books". So, DAVx5 creates a "DAVx5
- * address book" account for every CardDAV address book. These accounts are bound to a
- * DAVx5 main account.
- */
-open class LocalAddressBook(
-        private val context: Context,
-        account: Account,
-        provider: ContentProviderClient?
-): AndroidAddressBook<LocalContact, LocalGroup>(account, provider, LocalContact.Factory, LocalGroup.Factory), LocalCollection<LocalAddress> {
-
-    companion object {
-
-        const val USER_DATA_MAIN_ACCOUNT_TYPE = "real_account_type"
-        const val USER_DATA_MAIN_ACCOUNT_NAME = "real_account_name"
-        const val USER_DATA_URL = "url"
-        const val USER_DATA_READ_ONLY = "read_only"
-
-        /**
-         * Creates a local address book.
-         *
-         * @param context        app context to resolve string resources
-         * @param provider       contacts provider client
-         * @param mainAccount    main account this address book (account) belongs to
-         * @param info           collection where to take the name and settings from
-         * @param forceReadOnly  `true`: set the address book to "force read-only"; `false`: determine read-only flag from [info]
-         */
-        fun create(context: Context, provider: ContentProviderClient, mainAccount: Account, info: Collection, forceReadOnly: Boolean): LocalAddressBook {
-            val account = Account(accountName(mainAccount, info), context.getString(R.string.account_type_address_book))
-            val userData = initialUserData(mainAccount, info.url.toString())
-            Logger.log.log(Level.INFO, "Creating local address book $account", userData)
-            if (!AccountUtils.createAccount(context, account, userData))
-                throw IllegalStateException("Couldn't create address book account")
-
-            val addressBook = LocalAddressBook(context, account, provider)
-            addressBook.updateSyncFrameworkSettings()
-
-            // initialize Contacts Provider Settings
-            val values = ContentValues(2)
-            values.put(ContactsContract.Settings.SHOULD_SYNC, 1)
-            values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, 1)
-            addressBook.settings = values
-            addressBook.readOnly = forceReadOnly || !info.privWriteContent || info.forceReadOnly
-
-            return addressBook
-        }
-
-        fun deleteByAccount(context: Context, accountName: String) {
-            val mainAccount = Account(accountName, context.getString(R.string.account_type))
-            findAll(context, null, mainAccount).forEach {
-                it.delete()
-            }
-        }
-
-        /**
-         * Finds and returns all the local address books belonging to a given main account
-         *
-         * @param mainAccount the main account to use
-         * @return list of [mainAccount]'s address books
-         */
-        fun findAll(context: Context, provider: ContentProviderClient?, mainAccount: Account) = AccountManager.get(context)
-                .getAccountsByType(context.getString(R.string.account_type_address_book))
-                .map { LocalAddressBook(context, it, provider) }
-                .filter {
-                    try {
-                        it.mainAccount == mainAccount
-                    } catch(e: IllegalArgumentException) {
-                        false
-                    }
-                }
-                .toList()
-
-        fun accountName(mainAccount: Account, info: Collection): String {
-            val baos = ByteArrayOutputStream()
-            baos.write(info.url.hashCode())
-            val hash = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP or Base64.NO_PADDING)
-
-            val sb = StringBuilder(info.displayName.let {
-                if (it.isNullOrEmpty())
-                    info.url.lastSegment
-                else
-                    it
-            })
-            sb.append(" (${mainAccount.name} $hash)")
-            return sb.toString()
-        }
-
-        fun initialUserData(mainAccount: Account, url: String): Bundle {
-            val bundle = Bundle(3)
-            bundle.putString(USER_DATA_MAIN_ACCOUNT_NAME, mainAccount.name)
-            bundle.putString(USER_DATA_MAIN_ACCOUNT_TYPE, mainAccount.type)
-            bundle.putString(USER_DATA_URL, url)
-            return bundle
-        }
-
-        /**
-         * Finds and returns the main account of the given address book's account (sub-account)
-         *
-         * @param account the address book account to find the main account for
-         *
-         * @return the associated main account, `null` if none can be found (e.g. when main account has been deleted)
-         *
-         * @throws IllegalArgumentException when [account] is not an address book account
-         */
-        fun mainAccount(context: Context, account: Account): Account? =
-            if (account.type == context.getString(R.string.account_type_address_book)) {
-                val manager = AccountManager.get(context)
-                val accountName = manager.getUserData(account, USER_DATA_MAIN_ACCOUNT_NAME)
-                val accountType = manager.getUserData(account, USER_DATA_MAIN_ACCOUNT_TYPE)
-                if (accountName != null && accountType != null)
-                    Account(accountName, accountType)
-                else
-                    null
-            } else
-                throw IllegalArgumentException("$account is not an address book account")
-
-    }
-
-    override val tag: String
-        get() = "contacts-${account.name}"
-
-    override val title = account.name!!
-
-    /**
-     * Whether contact groups ([LocalGroup]) are included in query results
-     * and are affected by updates/deletes on generic members.
-     *
-     * For instance, if groupMethod is GROUP_VCARDS, [findDirty] will find only dirty [LocalContact]s,
-     * but if it is enabled, [findDirty] will find dirty [LocalContact]s and [LocalGroup]s.
-     */
-    open val groupMethod: GroupMethod by lazy {
-        val accountSettings = AccountSettings(context, requireMainAccount())
-        accountSettings.getGroupMethod()
-    }
-    val includeGroups
-        get() = groupMethod == GroupMethod.GROUP_VCARDS
-
-    private var _mainAccount: Account? = null
-    /**
-     * The associated main account which this address book's accounts belong to.
-     *
-     * @throws IllegalArgumentException when [account] is not an address book account or when no main account is assigned
-     */
-    open var mainAccount: Account?
-        get() {
-            _mainAccount?.let { return it }
-
-            val result = mainAccount(context, account)
-            _mainAccount = result
-            return result
-        }
-        set(newMainAccount) {
-            if (newMainAccount == null)
-                throw IllegalArgumentException("Main account must not be null")
-
-            AccountManager.get(context).let { accountManager ->
-                accountManager.setAndVerifyUserData(account, USER_DATA_MAIN_ACCOUNT_NAME, newMainAccount.name)
-                accountManager.setAndVerifyUserData(account, USER_DATA_MAIN_ACCOUNT_TYPE, newMainAccount.type)
-            }
-
-            _mainAccount = newMainAccount
-        }
-    fun requireMainAccount(): Account =
-        mainAccount ?: throw IllegalArgumentException("No main account assigned to address book $account")
-
-    var url: String
-        get() = AccountManager.get(context).getUserData(account, USER_DATA_URL)
-                ?: throw IllegalStateException("Address book has no URL")
-        set(url) = AccountManager.get(context).setAndVerifyUserData(account, USER_DATA_URL, url)
-
-    override var readOnly: Boolean
-        get() = AccountManager.get(context).getUserData(account, USER_DATA_READ_ONLY) != null
-        set(readOnly) = AccountManager.get(context).setAndVerifyUserData(account, USER_DATA_READ_ONLY, if (readOnly) "1" else null)
-
-    override var lastSyncState: SyncState?
-        get() = syncState?.let { SyncState.fromString(String(it)) }
-        set(state) {
-            syncState = state?.toString()?.toByteArray()
-        }
-
-
-    /* operations on the collection (address book) itself */
-
-    override fun markNotDirty(flags: Int): Int {
-        val values = ContentValues(1)
-        values.put(LocalContact.COLUMN_FLAGS, flags)
-        var number = provider!!.update(rawContactsSyncUri(), values, "${RawContacts.DIRTY}=0", null)
-
-        if (includeGroups) {
-            values.clear()
-            values.put(LocalGroup.COLUMN_FLAGS, flags)
-            number += provider!!.update(groupsSyncUri(), values, "NOT ${Groups.DIRTY}", null)
-        }
-
-        return number
-    }
-
-    override fun removeNotDirtyMarked(flags: Int): Int {
-        var number = provider!!.delete(rawContactsSyncUri(),
-                "NOT ${RawContacts.DIRTY} AND ${LocalContact.COLUMN_FLAGS}=?", arrayOf(flags.toString()))
-
-        if (includeGroups)
-            number += provider!!.delete(groupsSyncUri(),
-                    "NOT ${Groups.DIRTY} AND ${LocalGroup.COLUMN_FLAGS}=?", arrayOf(flags.toString()))
-
-        return number
-    }
-
-    /**
-     * Updates the address book settings.
-     *
-     * @param info  collection where to take the settings from
-     * @param forceReadOnly  `true`: set the address book to "force read-only"; `false`: determine read-only flag from [info]
-     */
-    fun update(info: Collection, forceReadOnly: Boolean) {
-        val newAccountName = accountName(requireMainAccount(), info)
-
-        if (account.name != newAccountName) {
-            // no need to re-assign contacts to new account, because they will be deleted by contacts provider in any case
-            val accountManager = AccountManager.get(context)
-            val future = accountManager.renameAccount(account, newAccountName, null, null)
-            account = future.result
-        }
-
-        val nowReadOnly = forceReadOnly || !info.privWriteContent || info.forceReadOnly
-        if (nowReadOnly != readOnly) {
-            Constants.log.info("Address book now read-only = $nowReadOnly, updating contacts")
-
-            // update address book itself
-            readOnly = nowReadOnly
-
-            // update raw contacts
-            val rawContactValues = ContentValues(1)
-            rawContactValues.put(RawContacts.RAW_CONTACT_IS_READ_ONLY, if (nowReadOnly) 1 else 0)
-            provider!!.update(rawContactsSyncUri(), rawContactValues, null, null)
-
-            // update data rows
-            val dataValues = ContentValues(1)
-            dataValues.put(ContactsContract.Data.IS_READ_ONLY, if (nowReadOnly) 1 else 0)
-            provider!!.update(syncAdapterURI(ContactsContract.Data.CONTENT_URI), dataValues, null, null)
-
-            // update group rows
-            val groupValues = ContentValues(1)
-            groupValues.put(Groups.GROUP_IS_READ_ONLY, if (nowReadOnly) 1 else 0)
-            provider!!.update(groupsSyncUri(), groupValues, null, null)
-        }
-
-        // make sure it will still be synchronized when contacts are updated
-        updateSyncFrameworkSettings()
-    }
-
-    fun delete() {
-        val accountManager = AccountManager.get(context)
-        accountManager.removeAccount(account, null, null, null)
-    }
-
-
-    /**
-     * Updates the sync framework settings for this address book:
-     *
-     * - Contacts sync of this address book account shall be possible -> isSyncable = 1
-     * - When a contact is changed, a sync shall be initiated -> syncAutomatically = true
-     * - Remove unwanted sync framework periodic syncs created by setSyncAutomatically, as
-     * we use PeriodicSyncWorker for scheduled syncs
-     */
-    fun updateSyncFrameworkSettings() {
-        // Enable sync-ability
-        if (ContentResolver.getIsSyncable(account, ContactsContract.AUTHORITY) != 1)
-            ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 1)
-
-        // Enable content trigger
-        if (!ContentResolver.getSyncAutomatically(account, ContactsContract.AUTHORITY))
-            ContentResolver.setSyncAutomatically(account, ContactsContract.AUTHORITY, true)
-
-        // Remove periodic syncs (setSyncAutomatically also creates periodic syncs, which we don't want)
-        for (periodicSync in ContentResolver.getPeriodicSyncs(account, ContactsContract.AUTHORITY))
-            ContentResolver.removePeriodicSync(periodicSync.account, periodicSync.authority, periodicSync.extras)
-    }
-
-
-    /* operations on members (contacts/groups) */
-
-    override fun findByName(name: String): LocalAddress? {
-        val result = queryContacts("${AndroidContact.COLUMN_FILENAME}=?", arrayOf(name)).firstOrNull()
-        return if (includeGroups)
-            result ?: queryGroups("${AndroidGroup.COLUMN_FILENAME}=?", arrayOf(name)).firstOrNull()
-        else
-            result
-    }
-
-
-    /**
-     * Returns an array of local contacts/groups which have been deleted locally. (DELETED != 0).
-     * @throws RemoteException on content provider errors
-     */
-    override fun findDeleted() =
-            if (includeGroups)
-                findDeletedContacts() + findDeletedGroups()
-            else
-                findDeletedContacts()
-
-    fun findDeletedContacts() = queryContacts(RawContacts.DELETED, null)
-    fun findDeletedGroups() = queryGroups(Groups.DELETED, null)
-
-    /**
-     * Returns an array of local contacts/groups which have been changed locally (DIRTY != 0).
-     * @throws RemoteException on content provider errors
-     */
-    override fun findDirty() =
-            if (includeGroups)
-                findDirtyContacts() + findDirtyGroups()
-            else
-                findDirtyContacts()
-    fun findDirtyContacts() = queryContacts(RawContacts.DIRTY, null)
-    fun findDirtyGroups() = queryGroups(Groups.DIRTY, null)
-
-    override fun forgetETags() {
-        if (includeGroups) {
-            val values = ContentValues(1)
-            values.putNull(AndroidGroup.COLUMN_ETAG)
-            provider!!.update(groupsSyncUri(), values, null, null)
-        }
-        val values = ContentValues(1)
-        values.putNull(AndroidContact.COLUMN_ETAG)
-        provider!!.update(rawContactsSyncUri(), values, null, null)
-    }
-
-
-    fun getContactIdsByGroupMembership(groupId: Long): List<Long> {
-        val ids = LinkedList<Long>()
-        provider!!.query(syncAdapterURI(ContactsContract.Data.CONTENT_URI), arrayOf(GroupMembership.RAW_CONTACT_ID),
-            "(${GroupMembership.MIMETYPE}=? AND ${GroupMembership.GROUP_ROW_ID}=?)",
-            arrayOf(GroupMembership.CONTENT_ITEM_TYPE, groupId.toString()), null)?.use { cursor ->
-            while (cursor.moveToNext())
-                ids += cursor.getLong(0)
-        }
-        return ids
-    }
-
-    fun getContactUidFromId(contactId: Long): String? {
-        provider!!.query(rawContactsSyncUri(), arrayOf(AndroidContact.COLUMN_UID),
-            "${RawContacts._ID}=?", arrayOf(contactId.toString()), null)?.use { cursor ->
-            if (cursor.moveToNext())
-                return cursor.getString(0)
-        }
-        return null
-    }
-
-
-    /**
-     * Queries all contacts with DIRTY flag and checks whether their data checksum has changed, i.e.
-     * if they're "really dirty" (= data has changed, not only metadata, which is not hashed).
-     * The DIRTY flag is removed from contacts which are not "really dirty", i.e. from contacts
-     * whose contact data checksum has not changed.
-     * @return number of "really dirty" contacts
-     * @throws RemoteException on content provider errors
-     */
-    fun verifyDirty(): Int {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
-            throw IllegalStateException("verifyDirty() should not be called on Android != 7.0")
-
-        var reallyDirty = 0
-        for (contact in findDirtyContacts()) {
-            val lastHash = contact.getLastHashCode()
-            val currentHash = contact.dataHashCode()
-            if (lastHash == currentHash) {
-                // hash is code still the same, contact is not "really dirty" (only metadata been have changed)
-                Logger.log.log(Level.FINE, "Contact data hash has not changed, resetting dirty flag", contact)
-                contact.resetDirty()
-            } else {
-                Logger.log.log(Level.FINE, "Contact data has changed from hash $lastHash to $currentHash", contact)
-                reallyDirty++
-            }
-        }
-
-        if (includeGroups)
-            reallyDirty += findDirtyGroups().size
-
-        return reallyDirty
-    }
-
-
-    /* special group operations */
-
-    /**
-     * Finds the first group with the given title. If there is no group with this
-     * title, a new group is created.
-     * @param title title of the group to look for
-     * @return id of the group with given title
-     * @throws RemoteException on content provider errors
-     */
-    fun findOrCreateGroup(title: String): Long {
-        provider!!.query(syncAdapterURI(Groups.CONTENT_URI), arrayOf(Groups._ID),
-                "${Groups.TITLE}=?", arrayOf(title), null)?.use { cursor ->
-            if (cursor.moveToNext())
-                return cursor.getLong(0)
-        }
-
-        val values = ContentValues(1)
-        values.put(Groups.TITLE, title)
-        val uri = provider!!.insert(syncAdapterURI(Groups.CONTENT_URI), values) ?: throw RemoteException("Couldn't create contact group")
-        return ContentUris.parseId(uri)
-    }
-
-    fun removeEmptyGroups() {
-        // find groups without members
-        /** should be done using {@link Groups.SUMMARY_COUNT}, but it's not implemented in Android yet */
-        queryGroups(null, null).filter { it.getMembers().isEmpty() }.forEach { group ->
-            Logger.log.log(Level.FINE, "Deleting group", group)
-            group.delete()
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalCalendar.kt

@@ -1,296 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentUris
-import android.content.ContentValues
-import android.net.Uri
-import android.provider.CalendarContract.Calendars
-import android.provider.CalendarContract.Events
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.SyncState
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.util.lastSegment
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.AndroidCalendarFactory
-import at.bitfire.ical4android.BatchOperation
-import at.bitfire.ical4android.util.DateUtils
-import at.bitfire.ical4android.util.MiscUtils.asSyncAdapter
-import java.util.LinkedList
-import java.util.logging.Level
-
-class LocalCalendar private constructor(
-        account: Account,
-        provider: ContentProviderClient,
-        id: Long
-): AndroidCalendar<LocalEvent>(account, provider, LocalEvent.Factory, id), LocalCollection<LocalEvent> {
-
-    companion object {
-
-        private const val COLUMN_SYNC_STATE = Calendars.CAL_SYNC1
-
-        fun create(account: Account, provider: ContentProviderClient, info: Collection): Uri {
-            val values = valuesFromCollectionInfo(info, true)
-
-            // ACCOUNT_NAME and ACCOUNT_TYPE are required (see docs)! If it's missing, other apps will crash.
-            values.put(Calendars.ACCOUNT_NAME, account.name)
-            values.put(Calendars.ACCOUNT_TYPE, account.type)
-
-            // Email address for scheduling. Used by the calendar provider to determine whether the
-            // user is ORGANIZER/ATTENDEE for a certain event.
-            values.put(Calendars.OWNER_ACCOUNT, account.name)
-
-            // flag as visible & synchronizable at creation, might be changed by user at any time
-            values.put(Calendars.VISIBLE, 1)
-            values.put(Calendars.SYNC_EVENTS, 1)
-            return create(account, provider, values)
-        }
-
-        private fun valuesFromCollectionInfo(info: Collection, withColor: Boolean): ContentValues {
-            val values = ContentValues()
-            values.put(Calendars.NAME, info.url.toString())
-            values.put(Calendars.CALENDAR_DISPLAY_NAME,
-                if (info.displayName.isNullOrBlank()) info.url.lastSegment else info.displayName)
-
-            if (withColor)
-                values.put(Calendars.CALENDAR_COLOR, info.color ?: Constants.DAVDROID_GREEN_RGBA)
-
-            if (info.privWriteContent && !info.forceReadOnly) {
-                values.put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_OWNER)
-                values.put(Calendars.CAN_MODIFY_TIME_ZONE, 1)
-                values.put(Calendars.CAN_ORGANIZER_RESPOND, 1)
-            } else
-                values.put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_READ)
-
-            info.timezone?.let { tzData ->
-                try {
-                    val timeZone = DateUtils.parseVTimeZone(tzData)
-                    timeZone.timeZoneId?.let { tzId ->
-                        values.put(Calendars.CALENDAR_TIME_ZONE, DateUtils.findAndroidTimezoneID(tzId.value))
-                    }
-                } catch(e: IllegalArgumentException) {
-                    Logger.log.log(Level.WARNING, "Couldn't parse calendar default time zone", e)
-                }
-            }
-
-            // add base values for Calendars
-            values.putAll(calendarBaseValues)
-
-            return values
-        }
-
-    }
-
-    override val tag: String
-        get() = "events-${account.name}-$id"
-
-    override val title: String
-        get() = displayName ?: id.toString()
-
-    private var accessLevel: Int = Calendars.CAL_ACCESS_OWNER   // assume full access if not specified
-    override val readOnly
-        get() = accessLevel <= Calendars.CAL_ACCESS_READ
-
-    override var lastSyncState: SyncState?
-        get() = provider.query(calendarSyncURI(), arrayOf(COLUMN_SYNC_STATE), null, null, null)?.use { cursor ->
-                    if (cursor.moveToNext())
-                        return SyncState.fromString(cursor.getString(0))
-                    else
-                        null
-                }
-        set(state) {
-            val values = ContentValues(1)
-            values.put(COLUMN_SYNC_STATE, state.toString())
-            provider.update(calendarSyncURI(), values, null, null)
-        }
-
-
-    override fun populate(info: ContentValues) {
-        super.populate(info)
-        accessLevel = info.getAsInteger(Calendars.CALENDAR_ACCESS_LEVEL) ?: Calendars.CAL_ACCESS_OWNER
-    }
-
-    fun update(info: Collection, updateColor: Boolean) =
-            update(valuesFromCollectionInfo(info, updateColor))
-
-
-    override fun findDeleted() =
-            queryEvents("${Events.DELETED} AND ${Events.ORIGINAL_ID} IS NULL", null)
-
-    override fun findDirty(): List<LocalEvent> {
-        val dirty = LinkedList<LocalEvent>()
-
-        /*
-         * RFC 5545 3.8.7.4. Sequence Number
-         * When a calendar component is created, its sequence number is 0. It is monotonically incremented by the "Organizer's"
-         * CUA each time the "Organizer" makes a significant revision to the calendar component.
-         */
-        for (localEvent in queryEvents("${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NULL", null)) {
-            try {
-                val event = requireNotNull(localEvent.event)
-
-                val nonGroupScheduled = event.attendees.isEmpty()
-                val weAreOrganizer = localEvent.weAreOrganizer
-
-                val sequence = event.sequence
-                if (sequence == null)
-                    // sequence has not been assigned yet (i.e. this event was just locally created)
-                    event.sequence = 0
-                else if (nonGroupScheduled || weAreOrganizer)   // increase sequence
-                    event.sequence = sequence + 1
-
-            } catch(e: Exception) {
-                Logger.log.log(Level.WARNING, "Couldn't check/increase sequence", e)
-            }
-            dirty += localEvent
-        }
-
-        return dirty
-    }
-
-    override fun findByName(name: String) =
-            queryEvents("${Events._SYNC_ID}=?", arrayOf(name)).firstOrNull()
-
-
-    override fun markNotDirty(flags: Int): Int {
-        val values = ContentValues(1)
-        values.put(LocalEvent.COLUMN_FLAGS, flags)
-        return provider.update(Events.CONTENT_URI.asSyncAdapter(account), values,
-                "${Events.CALENDAR_ID}=? AND NOT ${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NULL",
-                arrayOf(id.toString()))
-    }
-
-    override fun removeNotDirtyMarked(flags: Int): Int {
-        var deleted = 0
-        // list all non-dirty events with the given flags and delete every row + its exceptions
-        provider.query(Events.CONTENT_URI.asSyncAdapter(account), arrayOf(Events._ID),
-                "${Events.CALENDAR_ID}=? AND NOT ${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NULL AND ${LocalEvent.COLUMN_FLAGS}=?",
-                arrayOf(id.toString(), flags.toString()), null)?.use { cursor ->
-            val batch = BatchOperation(provider)
-            while (cursor.moveToNext()) {
-                val id = cursor.getLong(0)
-                // delete event and possible exceptions (content provider doesn't delete exceptions itself)
-                batch.enqueue(BatchOperation.CpoBuilder
-                        .newDelete(Events.CONTENT_URI.asSyncAdapter(account))
-                        .withSelection("${Events._ID}=? OR ${Events.ORIGINAL_ID}=?", arrayOf(id.toString(), id.toString())))
-            }
-            deleted = batch.commit()
-        }
-        return deleted
-    }
-
-    override fun forgetETags() {
-        val values = ContentValues(1)
-        values.putNull(LocalEvent.COLUMN_ETAG)
-        provider.update(Events.CONTENT_URI.asSyncAdapter(account), values, "${Events.CALENDAR_ID}=?",
-                arrayOf(id.toString()))
-    }
-
-
-    fun processDirtyExceptions() {
-        // process deleted exceptions
-        Logger.log.info("Processing deleted exceptions")
-        provider.query(
-                Events.CONTENT_URI.asSyncAdapter(account),
-                arrayOf(Events._ID, Events.ORIGINAL_ID, LocalEvent.COLUMN_SEQUENCE),
-                "${Events.CALENDAR_ID}=? AND ${Events.DELETED} AND ${Events.ORIGINAL_ID} IS NOT NULL",
-                arrayOf(id.toString()), null)?.use { cursor ->
-            while (cursor.moveToNext()) {
-                Logger.log.fine("Found deleted exception, removing and re-scheduling original event (if available)")
-                val id = cursor.getLong(0)             // can't be null (by definition)
-                val originalID = cursor.getLong(1)     // can't be null (by query)
-
-                val batch = BatchOperation(provider)
-
-                // get original event's SEQUENCE
-                provider.query(
-                        ContentUris.withAppendedId(Events.CONTENT_URI, originalID).asSyncAdapter(account),
-                        arrayOf(LocalEvent.COLUMN_SEQUENCE),
-                        null, null, null)?.use { cursor2 ->
-                    if (cursor2.moveToNext()) {
-                        // original event is available
-                        val originalSequence = if (cursor2.isNull(0)) 0 else cursor2.getInt(0)
-
-                        // re-schedule original event and set it to DIRTY
-                        batch.enqueue(BatchOperation.CpoBuilder
-                                .newUpdate(ContentUris.withAppendedId(Events.CONTENT_URI, originalID).asSyncAdapter(account))
-                                .withValue(LocalEvent.COLUMN_SEQUENCE, originalSequence + 1)
-                                .withValue(Events.DIRTY, 1))
-                    }
-                }
-
-                // completely remove deleted exception
-                batch.enqueue(BatchOperation.CpoBuilder.newDelete(ContentUris.withAppendedId(Events.CONTENT_URI, id).asSyncAdapter(account)))
-                batch.commit()
-            }
-        }
-
-        // process dirty exceptions
-        Logger.log.info("Processing dirty exceptions")
-        provider.query(
-                Events.CONTENT_URI.asSyncAdapter(account),
-                arrayOf(Events._ID, Events.ORIGINAL_ID, LocalEvent.COLUMN_SEQUENCE),
-                "${Events.CALENDAR_ID}=? AND ${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NOT NULL",
-                arrayOf(id.toString()), null)?.use { cursor ->
-            while (cursor.moveToNext()) {
-                Logger.log.fine("Found dirty exception, increasing SEQUENCE to re-schedule")
-                val id = cursor.getLong(0)             // can't be null (by definition)
-                val originalID = cursor.getLong(1)     // can't be null (by query)
-                val sequence = if (cursor.isNull(2)) 0 else cursor.getInt(2)
-
-                val batch = BatchOperation(provider)
-                // original event to DIRTY
-                batch.enqueue(BatchOperation.CpoBuilder
-                        .newUpdate(ContentUris.withAppendedId(Events.CONTENT_URI, originalID).asSyncAdapter(account))
-                        .withValue(Events.DIRTY, 1))
-                // increase SEQUENCE and set DIRTY to 0
-                batch.enqueue(BatchOperation.CpoBuilder
-                        .newUpdate(ContentUris.withAppendedId(Events.CONTENT_URI, id).asSyncAdapter(account))
-                        .withValue(LocalEvent.COLUMN_SEQUENCE, sequence + 1)
-                        .withValue(Events.DIRTY, 0))
-                batch.commit()
-            }
-        }
-    }
-
-    /**
-     * Marks dirty events (which are not already marked as deleted) which got no valid instances as "deleted"
-     *
-     * @return number of affected events
-     */
-    fun deleteDirtyEventsWithoutInstances() {
-        provider.query(
-            Events.CONTENT_URI.asSyncAdapter(account),
-            arrayOf(Events._ID),
-            "${Events.DIRTY} AND NOT ${Events.DELETED} AND ${Events.ORIGINAL_ID} IS NULL",    // Get dirty main events (and no exception events)
-            null, null
-        )?.use { cursor ->
-            while (cursor.moveToNext()) {
-                val eventID = cursor.getLong(0)
-
-                // get number of instances
-                val numEventInstances = LocalEvent.numInstances(provider, account, eventID)
-
-                // delete event if there are no instances
-                if (numEventInstances == 0) {
-                    Logger.log.info("Marking event #$eventID without instances as deleted")
-                    LocalEvent.markAsDeleted(provider, account, eventID)
-                }
-            }
-        }
-    }
-
-
-    object Factory: AndroidCalendarFactory<LocalCalendar> {
-
-        override fun newInstance(account: Account, provider: ContentProviderClient, id: Long) =
-            LocalCalendar(account, provider, id)
-
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalContact.kt

@@ -1,250 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.content.ContentValues
-import android.os.Build
-import android.os.RemoteException
-import android.provider.ContactsContract
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
-import android.provider.ContactsContract.RawContacts.Data
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.contactrow.CachedGroupMembershipHandler
-import at.bitfire.davdroid.resource.contactrow.GroupMembershipBuilder
-import at.bitfire.davdroid.resource.contactrow.GroupMembershipHandler
-import at.bitfire.davdroid.resource.contactrow.UnknownPropertiesBuilder
-import at.bitfire.davdroid.resource.contactrow.UnknownPropertiesHandler
-import at.bitfire.vcard4android.AndroidAddressBook
-import at.bitfire.vcard4android.AndroidContact
-import at.bitfire.vcard4android.AndroidContactFactory
-import at.bitfire.vcard4android.BatchOperation
-import at.bitfire.vcard4android.CachedGroupMembership
-import at.bitfire.vcard4android.Contact
-import ezvcard.Ezvcard
-import java.io.FileNotFoundException
-import java.util.UUID
-
-class LocalContact: AndroidContact, LocalAddress {
-
-    override val addressBook: LocalAddressBook
-        get() = super.addressBook as LocalAddressBook
-
-    companion object {
-        init {
-            Contact.productID = "+//IDN bitfire.at//${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ez-vcard/" + Ezvcard.VERSION
-        }
-
-        const val COLUMN_FLAGS = ContactsContract.RawContacts.SYNC4
-        const val COLUMN_HASHCODE = ContactsContract.RawContacts.SYNC3
-    }
-
-    internal val cachedGroupMemberships = HashSet<Long>()
-    internal val groupMemberships = HashSet<Long>()
-
-    override var scheduleTag: String?
-        get() = null
-        set(_) = throw NotImplementedError()
-
-    override var flags: Int = 0
-
-
-    constructor(addressBook: LocalAddressBook, values: ContentValues): super(addressBook, values) {
-        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
-    }
-
-    constructor(addressBook: LocalAddressBook, contact: Contact, fileName: String?, eTag: String?, _flags: Int): super(addressBook, contact, fileName, eTag) {
-        flags = _flags
-    }
-
-    init {
-        processor.registerHandler(CachedGroupMembershipHandler(this))
-        processor.registerHandler(GroupMembershipHandler(this))
-        processor.registerHandler(UnknownPropertiesHandler)
-        processor.registerBuilderFactory(GroupMembershipBuilder.Factory(addressBook))
-        processor.registerBuilderFactory(UnknownPropertiesBuilder.Factory)
-    }
-
-
-    override fun prepareForUpload(): String {
-        val contact = getContact()
-        val uid: String = contact.uid ?: run {
-            // generate new UID
-            val newUid = UUID.randomUUID().toString()
-
-            // update in contacts provider
-            val values = ContentValues(1)
-            values.put(COLUMN_UID, newUid)
-            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-
-            // update this event
-            contact.uid = newUid
-
-            newUid
-        }
-
-        return "$uid.vcf"
-    }
-
-    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
-        if (scheduleTag != null)
-            throw IllegalArgumentException("Contacts must not have a Schedule-Tag")
-
-        val values = ContentValues(4)
-        if (fileName != null)
-            values.put(COLUMN_FILENAME, fileName)
-        values.put(COLUMN_ETAG, eTag)
-        values.put(ContactsContract.RawContacts.DIRTY, 0)
-
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-            // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
-            val hashCode = dataHashCode()
-            values.put(COLUMN_HASHCODE, hashCode)
-            Logger.log.finer("Clearing dirty flag with eTag = $eTag, contact hash = $hashCode")
-        }
-
-        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-
-        if (fileName != null)
-            this.fileName = fileName
-        this.eTag = eTag
-    }
-
-    override fun resetDeleted() {
-        val values = ContentValues(1)
-        values.put(ContactsContract.Groups.DELETED, 0)
-        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-    }
-
-    fun resetDirty() {
-        val values = ContentValues(1)
-        values.put(ContactsContract.RawContacts.DIRTY, 0)
-        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-    }
-
-    override fun updateFlags(flags: Int) {
-        val values = ContentValues(1)
-        values.put(COLUMN_FLAGS, flags)
-        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-
-        this.flags = flags
-    }
-
-
-    /**
-     * Calculates a hash code from the contact's data (VCard) and group memberships.
-     * Attention: re-reads {@link #contact} from the database, discarding all changes in memory
-     * @return hash code of contact data (including group memberships)
-     */
-    internal fun dataHashCode(): Int {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
-            throw IllegalStateException("dataHashCode() should not be called on Android != 7")
-
-        // reset contact so that getContact() reads from database
-        _contact = null
-
-        // groupMemberships is filled by getContact()
-        val dataHash = getContact().hashCode()
-        val groupHash = groupMemberships.hashCode()
-        Logger.log.finest("Calculated data hash = $dataHash, group memberships hash = $groupHash")
-        return dataHash xor groupHash
-    }
-
-    fun updateHashCode(batch: BatchOperation?) {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
-            throw IllegalStateException("updateHashCode() should not be called on Android != 7")
-
-        val hashCode = dataHashCode()
-        Logger.log.fine("Storing contact hash = $hashCode")
-
-        if (batch == null) {
-            val values = ContentValues(1)
-            values.put(COLUMN_HASHCODE, hashCode)
-            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-        } else
-            batch.enqueue(BatchOperation.CpoBuilder
-                    .newUpdate(rawContactSyncURI())
-                    .withValue(COLUMN_HASHCODE, hashCode))
-    }
-
-    fun getLastHashCode(): Int {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
-            throw IllegalStateException("getLastHashCode() should not be called on Android != 7")
-
-        addressBook.provider!!.query(rawContactSyncURI(), arrayOf(COLUMN_HASHCODE), null, null, null)?.use { c ->
-            if (c.moveToNext() && !c.isNull(0))
-                return c.getInt(0)
-        }
-        return 0
-    }
-
-
-    fun addToGroup(batch: BatchOperation, groupID: Long) {
-        batch.enqueue(BatchOperation.CpoBuilder
-                .newInsert(dataSyncURI())
-                .withValue(GroupMembership.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE)
-                .withValue(GroupMembership.RAW_CONTACT_ID, id)
-                .withValue(GroupMembership.GROUP_ROW_ID, groupID))
-        groupMemberships += groupID
-
-        batch.enqueue(BatchOperation.CpoBuilder
-                .newInsert(dataSyncURI())
-                .withValue(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
-                .withValue(CachedGroupMembership.RAW_CONTACT_ID, id)
-                .withValue(CachedGroupMembership.GROUP_ID, groupID)
-        )
-        cachedGroupMemberships += groupID
-    }
-
-    fun removeGroupMemberships(batch: BatchOperation) {
-        batch.enqueue(BatchOperation.CpoBuilder
-                .newDelete(dataSyncURI())
-                .withSelection(
-                        "${Data.RAW_CONTACT_ID}=? AND ${Data.MIMETYPE} IN (?,?)",
-                        arrayOf(id.toString(), GroupMembership.CONTENT_ITEM_TYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
-                ))
-        groupMemberships.clear()
-        cachedGroupMemberships.clear()
-    }
-
-    /**
-     * Returns the IDs of all groups the contact was member of (cached memberships).
-     * Cached memberships are kept in sync with memberships by DAVx5 and are used to determine
-     * whether a membership has been deleted/added when a raw contact is dirty.
-     * @return set of {@link GroupMembership#GROUP_ROW_ID} (may be empty)
-     * @throws FileNotFoundException if the current contact can't be found
-     * @throws RemoteException on contacts provider errors
-     */
-    fun getCachedGroupMemberships(): Set<Long> {
-        getContact()
-        return cachedGroupMemberships
-    }
-
-    /**
-     * Returns the IDs of all groups the contact is member of.
-     * @return set of {@link GroupMembership#GROUP_ROW_ID}s (may be empty)
-     * @throws FileNotFoundException if the current contact can't be found
-     * @throws RemoteException on contacts provider errors
-     */
-    fun getGroupMemberships(): Set<Long> {
-        getContact()
-        return groupMemberships
-    }
-
-
-    // data rows
-    override fun buildContact(builder: BatchOperation.CpoBuilder, update: Boolean) {
-        builder.withValue(COLUMN_FLAGS, flags)
-        super.buildContact(builder, update)
-    }
-
-    // factory
-
-    object Factory: AndroidContactFactory<LocalContact> {
-        override fun fromProvider(addressBook: AndroidAddressBook<LocalContact, *>, values: ContentValues) =
-                LocalContact(addressBook as LocalAddressBook, values)
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalEvent.kt

@@ -1,270 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentUris
-import android.content.ContentValues
-import android.provider.CalendarContract
-import android.provider.CalendarContract.Events
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.AndroidEvent
-import at.bitfire.ical4android.AndroidEventFactory
-import at.bitfire.ical4android.BatchOperation
-import at.bitfire.ical4android.Event
-import at.bitfire.ical4android.ICalendar
-import at.bitfire.ical4android.Ical4Android
-import at.bitfire.ical4android.util.MiscUtils.asSyncAdapter
-import net.fortuna.ical4j.model.property.ProdId
-import java.util.UUID
-class LocalEvent: AndroidEvent, LocalResource<Event> {
-
-    companion object {
-        init {
-            ICalendar.prodId = ProdId("${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ical4j/" + Ical4Android.ical4jVersion)
-        }
-
-        const val COLUMN_ETAG = Events.SYNC_DATA1
-        const val COLUMN_FLAGS = Events.SYNC_DATA2
-        const val COLUMN_SEQUENCE = Events.SYNC_DATA3
-        const val COLUMN_SCHEDULE_TAG = Events.SYNC_DATA4
-
-        /**
-         * Marks the event as deleted
-         * @param eventID
-         */
-        fun markAsDeleted(provider: ContentProviderClient, account: Account, eventID: Long) {
-            provider.update(
-                ContentUris.withAppendedId(
-                    Events.CONTENT_URI,
-                    eventID
-                ).asSyncAdapter(account),
-                ContentValues(1).apply {
-                    put(Events.DELETED, 1)
-                },
-                null,null
-            )
-        }
-
-
-        /**
-         * Finds the amount of direct instances this event has (without exceptions); used by [numInstances]
-         * to find the number of instances of exceptions.
-         *
-         * The number of returned instances may vary with the Android version.
-         *
-         * @return number of direct event instances (not counting instances of exceptions); *null* if
-         * the number can't be determined or if the event has no last date (recurring event without last instance)
-         */
-        fun numDirectInstances(provider: ContentProviderClient, account: Account, eventID: Long): Int? {
-            // query event to get first and last instance
-            var first: Long? = null
-            var last: Long? = null
-            provider.query(
-                ContentUris.withAppendedId(
-                    Events.CONTENT_URI,
-                    eventID
-                ),
-                arrayOf(Events.DTSTART, Events.LAST_DATE), null, null, null
-            )?.use { cursor ->
-                cursor.moveToNext()
-                if (!cursor.isNull(0))
-                    first = cursor.getLong(0)
-                if (!cursor.isNull(1))
-                    last = cursor.getLong(1)
-            }
-            // if this event doesn't have a last occurence, it's endless and always has instances
-            if (first == null || last == null)
-                return null
-
-            /* We can't use Long.MIN_VALUE and Long.MAX_VALUE because Android generates the instances
-             on the fly and it doesn't accept those values. So we use the first/last actual occurence
-             of the event (calculated by Android). */
-            val instancesUri = CalendarContract.Instances.CONTENT_URI.asSyncAdapter(account)
-                .buildUpon()
-                .appendPath(first.toString())       // begin timestamp
-                .appendPath(last.toString())        // end timestamp
-                .build()
-
-            var numInstances = 0
-            provider.query(
-                instancesUri, null,
-                "${CalendarContract.Instances.EVENT_ID}=?", arrayOf(eventID.toString()),
-                null
-            )?.use { cursor ->
-                numInstances += cursor.count
-            }
-            return numInstances
-        }
-
-        /**
-         * Finds the total number of instances this event has (including instances of exceptions)
-         *
-         * The number of returned instances may vary with the Android version.
-         *
-         * @return number of direct event instances (not counting instances of exceptions); *null* if
-         * the number can't be determined or if the event has no last date (recurring event without last instance)
-         */
-        fun numInstances(provider: ContentProviderClient, account: Account, eventID: Long): Int? {
-            // num instances of the main event
-            var numInstances = numDirectInstances(provider, account, eventID) ?: return null
-
-            // add the number of instances of every main event's exception
-            provider.query(
-                Events.CONTENT_URI,
-                arrayOf(Events._ID),
-                "${Events.ORIGINAL_ID}=?", // get exception events of the main event
-                arrayOf("$eventID"), null
-            )?.use { exceptionsEventCursor ->
-                while (exceptionsEventCursor.moveToNext()) {
-                    val exceptionEventID = exceptionsEventCursor.getLong(0)
-                    val exceptionInstances = numDirectInstances(provider, account, exceptionEventID)
-
-                    if (exceptionInstances == null)
-                        // number of instances of exception can't be determined; so the total number of instances is also unclear
-                        return null
-
-                    numInstances += exceptionInstances
-                }
-            }
-            return numInstances
-        }
-
-    }
-
-    override var fileName: String? = null
-        private set
-
-    override var eTag: String? = null
-    override var scheduleTag: String? = null
-
-    override var flags: Int = 0
-        private set
-
-    var weAreOrganizer = false
-        private set
-
-
-    constructor(calendar: AndroidCalendar<*>, event: Event, fileName: String?, eTag: String?, scheduleTag: String?, flags: Int): super(calendar, event) {
-        this.fileName = fileName
-        this.eTag = eTag
-        this.scheduleTag = scheduleTag
-        this.flags = flags
-    }
-
-    private constructor(calendar: AndroidCalendar<*>, values: ContentValues): super(calendar, values) {
-        fileName = values.getAsString(Events._SYNC_ID)
-        eTag = values.getAsString(COLUMN_ETAG)
-        scheduleTag = values.getAsString(COLUMN_SCHEDULE_TAG)
-        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
-    }
-
-    override fun populateEvent(row: ContentValues, groupScheduled: Boolean) {
-        val event = requireNotNull(event)
-        event.sequence = row.getAsInteger(COLUMN_SEQUENCE)
-
-        val isOrganizer = row.getAsInteger(Events.IS_ORGANIZER)
-        weAreOrganizer = isOrganizer != null && isOrganizer != 0
-
-        super.populateEvent(row, groupScheduled)
-    }
-
-    override fun buildEvent(recurrence: Event?, builder: BatchOperation.CpoBuilder) {
-        val event = requireNotNull(event)
-
-        val buildException = recurrence != null
-        val eventToBuild = recurrence ?: event
-
-        builder .withValue(COLUMN_SEQUENCE, eventToBuild.sequence)
-                .withValue(Events.DIRTY, 0)
-                .withValue(Events.DELETED, 0)
-                .withValue(COLUMN_FLAGS, flags)
-
-        if (buildException)
-            builder .withValue(Events.ORIGINAL_SYNC_ID, fileName)
-        else
-            builder .withValue(Events._SYNC_ID, fileName)
-                    .withValue(COLUMN_ETAG, eTag)
-                    .withValue(COLUMN_SCHEDULE_TAG, scheduleTag)
-
-        super.buildEvent(recurrence, builder)
-    }
-
-
-    /**
-     * Creates and sets a new UID in the calendar provider, if no UID is already set.
-     * It also returns the desired file name for the event for further processing in the sync algorithm.
-     *
-     * @return file name to use at upload
-     */
-    override fun prepareForUpload(): String {
-        // make sure that UID is set
-        val uid: String = event!!.uid ?: run {
-            // generate new UID
-            val newUid = UUID.randomUUID().toString()
-
-            // update in calendar provider
-            val values = ContentValues(1)
-            values.put(Events.UID_2445, newUid)
-            calendar.provider.update(eventSyncURI(), values, null, null)
-
-            // update this event
-            event?.uid = newUid
-
-            newUid
-        }
-
-        val uidIsGoodFilename = uid.all { char ->
-            // see RFC 2396 2.2
-            char.isLetterOrDigit() || arrayOf(          // allow letters and digits
-                ';',':','@','&','=','+','$',',',        // allow reserved characters except '/' and '?'
-                '-','_','.','!','~','*','\'','(',')'    // allow unreserved characters
-            ).contains(char)
-        }
-        return if (uidIsGoodFilename)
-            "$uid.ics"                      // use UID as file name
-        else
-            "${UUID.randomUUID()}.ics"      // UID would be dangerous as file name, use random UUID instead
-    }
-
-
-    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
-        val values = ContentValues(5)
-        if (fileName != null)
-            values.put(Events._SYNC_ID, fileName)
-        values.put(COLUMN_ETAG, eTag)
-        values.put(COLUMN_SCHEDULE_TAG, scheduleTag)
-        values.put(COLUMN_SEQUENCE, event!!.sequence)
-        values.put(Events.DIRTY, 0)
-        calendar.provider.update(eventSyncURI(), values, null, null)
-
-        if (fileName != null)
-            this.fileName = fileName
-        this.eTag = eTag
-        this.scheduleTag = scheduleTag
-    }
-
-    override fun updateFlags(flags: Int) {
-        val values = ContentValues(1)
-        values.put(COLUMN_FLAGS, flags)
-        calendar.provider.update(eventSyncURI(), values, null, null)
-
-        this.flags = flags
-    }
-
-    override fun resetDeleted() {
-        val values = ContentValues(1).apply { put(Events.DELETED, 0) }
-        calendar.provider.update(eventSyncURI(), values, null, null)
-    }
-
-    object Factory: AndroidEventFactory<LocalEvent> {
-        override fun fromProvider(calendar: AndroidCalendar<*>, values: ContentValues) =
-                LocalEvent(calendar, values)
-    }
-
-}
-

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalJtxCollection.kt

@@ -1,114 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentValues
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.Principal
-import at.bitfire.davdroid.db.SyncState
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.util.lastSegment
-import at.bitfire.ical4android.JtxCollection
-import at.bitfire.ical4android.JtxCollectionFactory
-import at.bitfire.ical4android.JtxICalObject
-import at.techbee.jtx.JtxContract
-import java.util.logging.Level
-
-class LocalJtxCollection(account: Account, client: ContentProviderClient, id: Long):
-    JtxCollection<JtxICalObject>(account, client, LocalJtxICalObject.Factory, id),
-    LocalCollection<LocalJtxICalObject>{
-
-    companion object {
-
-        fun create(account: Account, client: ContentProviderClient, info: Collection, owner: Principal?) {
-            val values = valuesFromCollection(info, account, owner, true)
-            create(account, client, values)
-        }
-
-        fun valuesFromCollection(info: Collection, account: Account, owner: Principal?, withColor: Boolean) =
-            ContentValues().apply {
-                put(JtxContract.JtxCollection.URL, info.url.toString())
-                put(
-                    JtxContract.JtxCollection.DISPLAYNAME,
-                    info.displayName ?: info.url.lastSegment
-                )
-                put(JtxContract.JtxCollection.DESCRIPTION, info.description)
-                if (owner != null)
-                    put(JtxContract.JtxCollection.OWNER, owner.url.toString())
-                else Logger.log.log(Level.SEVERE, "No collection owner given. Will create jtx collection without owner")
-                put(JtxContract.JtxCollection.OWNER_DISPLAYNAME, owner?.displayName)
-                if (withColor)
-                    put(JtxContract.JtxCollection.COLOR, info.color ?: Constants.DAVDROID_GREEN_RGBA)
-                put(JtxContract.JtxCollection.SUPPORTSVEVENT, info.supportsVEVENT)
-                put(JtxContract.JtxCollection.SUPPORTSVJOURNAL, info.supportsVJOURNAL)
-                put(JtxContract.JtxCollection.SUPPORTSVTODO, info.supportsVTODO)
-                put(JtxContract.JtxCollection.ACCOUNT_NAME, account.name)
-                put(JtxContract.JtxCollection.ACCOUNT_TYPE, account.type)
-                put(JtxContract.JtxCollection.READONLY, info.forceReadOnly || !info.privWriteContent)
-            }
-    }
-
-    override val readOnly: Boolean
-        get() = throw NotImplementedError()
-
-    override val tag: String
-        get() =  "jtx-${account.name}-$id"
-    override val title: String
-        get() = displayname ?: id.toString()
-    override var lastSyncState: SyncState?
-        get() = SyncState.fromString(syncstate)
-        set(value) { syncstate = value.toString() }
-
-    fun updateCollection(info: Collection, owner: Principal?, withColor: Boolean) {
-        val values = valuesFromCollection(info, account, owner, withColor)
-        update(values)
-    }
-
-    override fun findDeleted(): List<LocalJtxICalObject> {
-        val values = queryDeletedICalObjects()
-        val localJtxICalObjects = mutableListOf<LocalJtxICalObject>()
-        values.forEach {
-            localJtxICalObjects.add(LocalJtxICalObject.Factory.fromProvider(this, it))
-        }
-        return localJtxICalObjects
-    }
-
-    override fun findDirty(): List<LocalJtxICalObject> {
-        val values = queryDirtyICalObjects()
-        val localJtxICalObjects = mutableListOf<LocalJtxICalObject>()
-        values.forEach {
-            localJtxICalObjects.add(LocalJtxICalObject.Factory.fromProvider(this, it))
-        }
-        return localJtxICalObjects
-    }
-
-    override fun findByName(name: String): LocalJtxICalObject? {
-        val values = queryByFilename(name) ?: return null
-        return LocalJtxICalObject.Factory.fromProvider(this, values)
-    }
-
-    /**
-     * Finds and returns a recurring instance of a [LocalJtxICalObject]
-     */
-    fun findRecurring(uid: String, recurid: String, dtstart: Long): LocalJtxICalObject? {
-        val values = queryRecur(uid, recurid, dtstart) ?: return null
-        return LocalJtxICalObject.Factory.fromProvider(this, values)
-    }
-
-    override fun markNotDirty(flags: Int)= updateSetFlags(flags)
-
-    override fun removeNotDirtyMarked(flags: Int) = deleteByFlags(flags)
-
-    override fun forgetETags() = updateSetETag(null)
-
-
-    object Factory: JtxCollectionFactory<LocalJtxCollection> {
-        override fun newInstance(account: Account, client: ContentProviderClient, id: Long) = LocalJtxCollection(account, client, id)
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalResource.kt

@@ -1,98 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.net.Uri
-
-interface LocalResource<in TData: Any> {
-
-    companion object {
-        /**
-         * Resource is present on remote server. This flag is used to identify resources
-         * which are not present on the remote server anymore and can be deleted at the end
-         * of the synchronization.
-         */
-        const val FLAG_REMOTELY_PRESENT = 1
-    }
-
-
-    /**
-     * Unique ID which identifies the resource in the local storage. May be null if the
-     * resource has not been saved yet.
-     */
-    val id: Long?
-
-    /**
-     * Remote file name for the resource, for instance `mycontact.vcf`. Also used to determine whether
-     * a dirty record has just been created (in this case, [fileName] is *null*) or modified
-     * (in this case, [fileName] is the remote file name).
-     */
-    val fileName: String?
-
-    /** remote ETag for the resource */
-    var eTag: String?
-
-    /** remote Schedule-Tag for the resource */
-    var scheduleTag: String?
-
-    /** bitfield of flags; currently either [FLAG_REMOTELY_PRESENT] or 0 */
-    val flags: Int
-
-    /**
-     * Prepares the resource for uploading:
-     *
-     *   1. If the resource doesn't have an UID yet, this method generates one and writes it to the content provider.
-     *   2. The new file name which can be used for the upload is derived from the UID and returned, but not
-     *   saved to the content provider. The sync manager is responsible for saving the file name that
-     *   was actually used.
-     *
-     * @return new file name of the resource (like "<uid>.vcf")
-     */
-    fun prepareForUpload(): String
-
-    /**
-     * Unsets the /dirty/ field of the resource. Typically used after successfully uploading a
-     * locally modified resource.
-     *
-     * @param fileName If this argument is not *null*, [LocalResource.fileName] will be set to its value.
-     * @param eTag ETag of the uploaded resource as returned by the server (null if the server didn't return one)
-     * @param scheduleTag CalDAV Schedule-Tag of the uploaded resource as returned by the server (null if not applicable or if the server didn't return one)
-     */
-    fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String? = null)
-
-    /**
-     * Sets (local) flags of the resource. At the moment, the only allowed values are
-     * 0 and [FLAG_REMOTELY_PRESENT].
-     */
-    fun updateFlags(flags: Int)
-
-
-    /**
-     * Adds the data object to the content provider and ensures that the dirty flag is clear.
-     *
-     * @return content URI of the created row (e.g. event URI)
-     */
-    fun add(): Uri
-
-    /**
-     * Updates the data object in the content provider and ensures that the dirty flag is clear.
-     *
-     * @return content URI of the updated row (e.g. event URI)
-     */
-    fun update(data: TData): Uri
-
-    /**
-     * Deletes the data object from the content provider.
-     *
-     * @return number of affected rows
-     */
-    fun delete(): Int
-
-    /**
-     * Undoes deletion of the data object from the content provider.
-     */
-    fun resetDeleted()
-
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalTask.kt

@@ -1,116 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.content.ContentValues
-import at.bitfire.ical4android.BatchOperation
-import at.bitfire.ical4android.DmfsTask
-import at.bitfire.ical4android.DmfsTaskFactory
-import at.bitfire.ical4android.DmfsTaskList
-import at.bitfire.ical4android.Ical4Android
-import at.bitfire.ical4android.Task
-import org.dmfs.tasks.contract.TaskContract.Tasks
-import java.util.UUID
-
-class LocalTask: DmfsTask, LocalResource<Task> {
-
-    companion object {
-        const val COLUMN_ETAG = Tasks.SYNC1
-        const val COLUMN_FLAGS = Tasks.SYNC2
-    }
-
-    override var fileName: String? = null
-
-    override var scheduleTag: String? = null
-    override var eTag: String? = null
-
-    override var flags = 0
-        private set
-
-
-    constructor(taskList: DmfsTaskList<*>, task: Task, fileName: String?, eTag: String?, flags: Int)
-            : super(taskList, task) {
-        this.fileName = fileName
-        this.eTag = eTag
-        this.flags = flags
-    }
-
-    private constructor(taskList: DmfsTaskList<*>, values: ContentValues): super(taskList) {
-        id = values.getAsLong(Tasks._ID)
-        fileName = values.getAsString(Tasks._SYNC_ID)
-        eTag = values.getAsString(COLUMN_ETAG)
-        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
-    }
-
-
-    /* process LocalTask-specific fields */
-
-    override fun buildTask(builder: BatchOperation.CpoBuilder, update: Boolean) {
-        super.buildTask(builder, update)
-
-        builder .withValue(Tasks._SYNC_ID, fileName)
-                .withValue(COLUMN_ETAG, eTag)
-                .withValue(COLUMN_FLAGS, flags)
-    }
-
-
-    /* custom queries */
-
-    override fun prepareForUpload(): String {
-        val uid: String = task!!.uid ?: run {
-            // generate new UID
-            val newUid = UUID.randomUUID().toString()
-
-            // update in tasks provider
-            val values = ContentValues(1)
-            values.put(Tasks._UID, newUid)
-            taskList.provider.client.update(taskSyncURI(), values, null, null)
-
-            // update this task
-            task!!.uid = newUid
-
-            newUid
-        }
-
-        return "$uid.ics"
-    }
-
-    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
-        if (scheduleTag != null)
-            Ical4Android.log.fine("Schedule-Tag for tasks not supported yet, won't save")
-
-        val values = ContentValues(4)
-        if (fileName != null)
-            values.put(Tasks._SYNC_ID, fileName)
-        values.put(COLUMN_ETAG, eTag)
-        values.put(Tasks.SYNC_VERSION, task!!.sequence)
-        values.put(Tasks._DIRTY, 0)
-        taskList.provider.client.update(taskSyncURI(), values, null, null)
-
-        if (fileName != null)
-            this.fileName = fileName
-        this.eTag = eTag
-    }
-
-    override fun updateFlags(flags: Int) {
-        if (id != null) {
-            val values = ContentValues(1)
-            values.put(COLUMN_FLAGS, flags)
-            taskList.provider.client.update(taskSyncURI(), values, null, null)
-        }
-
-        this.flags = flags
-    }
-
-    override fun resetDeleted() {
-        throw NotImplementedError()
-    }
-
-
-    object Factory: DmfsTaskFactory<LocalTask> {
-        override fun fromProvider(taskList: DmfsTaskList<*>, values: ContentValues) =
-                LocalTask(taskList, values)
-    }
-}

app/src/main/kotlin/at/bitfire/davdroid/resource/LocalTaskList.kt

@@ -1,166 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.annotation.SuppressLint
-import android.content.ContentValues
-import android.content.Context
-import android.net.Uri
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.SyncState
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.util.lastSegment
-import at.bitfire.ical4android.DmfsTaskList
-import at.bitfire.ical4android.DmfsTaskListFactory
-import at.bitfire.ical4android.TaskProvider
-import org.dmfs.tasks.contract.TaskContract.*
-import java.util.logging.Level
-
-class LocalTaskList private constructor(
-        account: Account,
-        provider: TaskProvider,
-        id: Long
-): DmfsTaskList<LocalTask>(account, provider, LocalTask.Factory, id), LocalCollection<LocalTask> {
-
-    companion object {
-
-        fun create(account: Account, provider: TaskProvider, info: Collection): Uri {
-            val values = valuesFromCollectionInfo(info, true)
-            values.put(TaskLists.OWNER, account.name)
-            values.put(TaskLists.SYNC_ENABLED, 1)
-            values.put(TaskLists.VISIBLE, 1)
-            return create(account, provider, values)
-        }
-
-        @SuppressLint("Recycle")
-        @Throws(Exception::class)
-        fun onRenameAccount(context: Context, oldName: String, newName: String) {
-            TaskProvider.acquire(context)?.use { provider ->
-                val values = ContentValues(1)
-                values.put(Tasks.ACCOUNT_NAME, newName)
-                provider.client.update(
-                        Tasks.getContentUri(provider.name.authority),
-                        values,
-                        "${Tasks.ACCOUNT_NAME}=?", arrayOf(oldName)
-                )
-            }
-        }
-
-        private fun valuesFromCollectionInfo(info: Collection, withColor: Boolean): ContentValues {
-            val values = ContentValues(3)
-            values.put(TaskLists._SYNC_ID, info.url.toString())
-            values.put(TaskLists.LIST_NAME,
-                if (info.displayName.isNullOrBlank()) info.url.lastSegment else info.displayName)
-
-            if (withColor)
-                values.put(TaskLists.LIST_COLOR, info.color ?: Constants.DAVDROID_GREEN_RGBA)
-
-            if (info.privWriteContent && !info.forceReadOnly)
-                values.put(TaskListColumns.ACCESS_LEVEL, TaskListColumns.ACCESS_LEVEL_OWNER)
-            else
-                values.put(TaskListColumns.ACCESS_LEVEL, TaskListColumns.ACCESS_LEVEL_READ)
-
-            return values
-        }
-
-    }
-
-    private var accessLevel: Int = TaskListColumns.ACCESS_LEVEL_UNDEFINED
-    override val readOnly
-        get() =
-            accessLevel != TaskListColumns.ACCESS_LEVEL_UNDEFINED &&
-            accessLevel <= TaskListColumns.ACCESS_LEVEL_READ
-
-    override val tag: String
-        get() = "tasks-${account.name}-$id"
-
-    override val title: String
-        get() = name ?: id.toString()
-
-    override var lastSyncState: SyncState?
-        get() {
-            try {
-                provider.client.query(taskListSyncUri(), arrayOf(TaskLists.SYNC_VERSION),
-                        null, null, null)?.use { cursor ->
-                    if (cursor.moveToNext())
-                        cursor.getString(0)?.let {
-                            return SyncState.fromString(it)
-                        }
-                }
-            } catch (e: Exception) {
-                Logger.log.log(Level.WARNING, "Couldn't read sync state", e)
-            }
-            return null
-        }
-        set(state) {
-            val values = ContentValues(1)
-            values.put(TaskLists.SYNC_VERSION, state?.toString())
-            provider.client.update(taskListSyncUri(), values, null, null)
-        }
-
-
-    override fun populate(values: ContentValues) {
-        super.populate(values)
-        accessLevel = values.getAsInteger(TaskListColumns.ACCESS_LEVEL)
-    }
-
-    fun update(info: Collection, updateColor: Boolean) =
-        update(valuesFromCollectionInfo(info, updateColor))
-
-
-    override fun findDeleted() = queryTasks(Tasks._DELETED, null)
-
-    override fun findDirty(): List<LocalTask> {
-        val tasks = queryTasks(Tasks._DIRTY, null)
-        for (localTask in tasks) {
-            try {
-                val task = requireNotNull(localTask.task)
-                val sequence = task.sequence
-                if (sequence == null)   // sequence has not been assigned yet (i.e. this task was just locally created)
-                    task.sequence = 0
-                else                    // task was modified, increase sequence
-                    task.sequence = sequence + 1
-            } catch(e: Exception) {
-                Logger.log.log(Level.WARNING, "Couldn't check/increase sequence", e)
-            }
-        }
-        return tasks
-    }
-
-    override fun findByName(name: String) =
-            queryTasks("${Tasks._SYNC_ID}=?", arrayOf(name)).firstOrNull()
-
-
-    override fun markNotDirty(flags: Int): Int {
-        val values = ContentValues(1)
-        values.put(LocalTask.COLUMN_FLAGS, flags)
-        return provider.client.update(tasksSyncUri(), values,
-                "${Tasks.LIST_ID}=? AND ${Tasks._DIRTY}=0",
-                arrayOf(id.toString()))
-    }
-
-    override fun removeNotDirtyMarked(flags: Int) =
-            provider.client.delete(tasksSyncUri(),
-                    "${Tasks.LIST_ID}=? AND NOT ${Tasks._DIRTY} AND ${LocalTask.COLUMN_FLAGS}=?",
-                    arrayOf(id.toString(), flags.toString()))
-
-    override fun forgetETags() {
-        val values = ContentValues(1)
-        values.putNull(LocalEvent.COLUMN_ETAG)
-        provider.client.update(tasksSyncUri(), values, "${Tasks.LIST_ID}=?",
-                arrayOf(id.toString()))
-    }
-
-
-    object Factory: DmfsTaskListFactory<LocalTaskList> {
-
-        override fun newInstance(account: Account, provider: TaskProvider, id: Long) =
-                LocalTaskList(account, provider, id)
-
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/servicedetection/RefreshCollectionsWorker.kt

@@ -1,597 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.servicedetection
-
-import android.accounts.Account
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.hilt.work.HiltWorker
-import androidx.work.CoroutineWorker
-import androidx.work.Data
-import androidx.work.ExistingWorkPolicy
-import androidx.work.ForegroundInfo
-import androidx.work.OneTimeWorkRequestBuilder
-import androidx.work.Operation
-import androidx.work.OutOfQuotaPolicy
-import androidx.work.WorkInfo
-import androidx.work.WorkManager
-import androidx.work.WorkerParameters
-import at.bitfire.dav4jvm.DavResource
-import at.bitfire.dav4jvm.MultiResponseCallback
-import at.bitfire.dav4jvm.Property
-import at.bitfire.dav4jvm.Response
-import at.bitfire.dav4jvm.UrlUtils
-import at.bitfire.dav4jvm.exception.HttpException
-import at.bitfire.dav4jvm.exception.UnauthorizedException
-import at.bitfire.dav4jvm.property.caldav.CalendarColor
-import at.bitfire.dav4jvm.property.caldav.CalendarDescription
-import at.bitfire.dav4jvm.property.caldav.CalendarHomeSet
-import at.bitfire.dav4jvm.property.caldav.CalendarProxyReadFor
-import at.bitfire.dav4jvm.property.caldav.CalendarProxyWriteFor
-import at.bitfire.dav4jvm.property.caldav.Source
-import at.bitfire.dav4jvm.property.caldav.SupportedCalendarComponentSet
-import at.bitfire.dav4jvm.property.carddav.AddressbookDescription
-import at.bitfire.dav4jvm.property.carddav.AddressbookHomeSet
-import at.bitfire.dav4jvm.property.carddav.SupportedAddressData
-import at.bitfire.dav4jvm.property.push.PushTransports
-import at.bitfire.dav4jvm.property.push.Topic
-import at.bitfire.dav4jvm.property.webdav.CurrentUserPrivilegeSet
-import at.bitfire.dav4jvm.property.webdav.DisplayName
-import at.bitfire.dav4jvm.property.webdav.GroupMembership
-import at.bitfire.dav4jvm.property.webdav.HrefListProperty
-import at.bitfire.dav4jvm.property.webdav.Owner
-import at.bitfire.dav4jvm.property.webdav.ResourceType
-import at.bitfire.davdroid.InvalidAccountException
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.HomeSet
-import at.bitfire.davdroid.db.Principal
-import at.bitfire.davdroid.db.Service
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.servicedetection.RefreshCollectionsWorker.Companion.ARG_SERVICE_ID
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.NotificationUtils.notifyIfPossible
-import at.bitfire.davdroid.ui.account.AccountSettingsActivity
-import at.bitfire.davdroid.util.DavUtils.parent
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedInject
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.runInterruptible
-import okhttp3.HttpUrl
-import okhttp3.OkHttpClient
-import java.util.logging.Level
-import kotlin.collections.*
-
-/**
- * Refreshes list of home sets and their respective collections of a service type (CardDAV or CalDAV).
- * Called from UI, when user wants to refresh all collections of a service.
- *
- * Input data:
- *
- *  - [ARG_SERVICE_ID]: service ID
- *
- * It queries all existing homesets and/or collections and then:
- *  - updates resources with found properties (overwrites without comparing)
- *  - adds resources if new ones are detected
- *  - removes resources if not found 40x (delete locally)
- *
- * Expedited: yes (always initiated by user)
- *
- * Long-running: no
- *
- * @throws IllegalArgumentException when there's no service with the given service ID
- */
-@HiltWorker
-class RefreshCollectionsWorker @AssistedInject constructor(
-    @Assisted appContext: Context,
-    @Assisted workerParams: WorkerParameters,
-    var db: AppDatabase,
-    var settings: SettingsManager
-): CoroutineWorker(appContext, workerParams) {
-
-    companion object {
-
-        const val ARG_SERVICE_ID = "serviceId"
-        const val WORKER_TAG = "refreshCollectionsWorker"
-
-        // Collection properties to ask for in a propfind request to the Cal- or CardDAV server
-        val DAV_COLLECTION_PROPERTIES = arrayOf(
-            ResourceType.NAME,
-            CurrentUserPrivilegeSet.NAME,
-            DisplayName.NAME,
-            Owner.NAME,
-            AddressbookDescription.NAME, SupportedAddressData.NAME,
-            CalendarDescription.NAME, CalendarColor.NAME, SupportedCalendarComponentSet.NAME,
-            Source.NAME,
-            // WebDAV Push
-            PushTransports.NAME,
-            Topic.NAME
-        )
-
-        // Principal properties to ask the server
-        val DAV_PRINCIPAL_PROPERTIES = arrayOf(
-            DisplayName.NAME,
-            ResourceType.NAME
-        )
-
-        /**
-         * Uniquely identifies a refresh worker. Useful for stopping work, or querying its state.
-         *
-         * @param serviceId     what service (CalDAV/CardDAV) the worker is running for
-         */
-        fun workerName(serviceId: Long): String = "$WORKER_TAG-$serviceId"
-
-        /**
-         * Requests immediate refresh of a given service. If not running already. this will enqueue
-         * a [RefreshCollectionsWorker].
-         *
-         * @param serviceId     serviceId which is to be refreshed
-         * @return Pair with
-         *
-         * 1. worker name,
-         * 2. operation of [WorkManager.enqueueUniqueWork] (can be used to wait for completion)
-         *
-         * @throws IllegalArgumentException when there's no service with this ID
-         */
-        fun enqueue(context: Context, serviceId: Long): Pair<String, Operation> {
-            val name = workerName(serviceId)
-            val arguments = Data.Builder()
-                .putLong(ARG_SERVICE_ID, serviceId)
-                .build()
-            val workRequest = OneTimeWorkRequestBuilder<RefreshCollectionsWorker>()
-                .addTag(name)
-                .setInputData(arguments)
-                .setExpedited(OutOfQuotaPolicy.RUN_AS_NON_EXPEDITED_WORK_REQUEST)
-                .build()
-
-            return Pair(
-                name,
-                WorkManager.getInstance(context).enqueueUniqueWork(
-                    name,
-                    ExistingWorkPolicy.KEEP,    // if refresh is already running, just continue that one
-                    workRequest
-                )
-            )
-        }
-
-        /**
-         * Observes whether a refresh worker with given service id and state exists.
-         *
-         * @param workerName    name of worker to find
-         * @param workState     state of worker to match
-         *
-         * @return flow that emits `true` if worker with matching state was found (otherwise `false`)
-         */
-        fun existsFlow(context: Context, workerName: String, workState: WorkInfo.State = WorkInfo.State.RUNNING) =
-            WorkManager.getInstance(context).getWorkInfosForUniqueWorkFlow(workerName).map { workInfoList ->
-                workInfoList.any { workInfo -> workInfo.state == workState }
-            }
-
-    }
-
-    val serviceId: Long = inputData.getLong(ARG_SERVICE_ID, -1)
-    val service = db.serviceDao().get(serviceId)
-    val account = service?.let { service ->
-        Account(service.accountName, applicationContext.getString(R.string.account_type))
-    }
-
-    override suspend fun doWork(): Result {
-        if (service == null || account == null) {
-            Logger.log.warning("Missing service or account with service ID: $serviceId")
-            return Result.failure()
-        }
-
-        try {
-            Logger.log.info("Refreshing ${service.type} collections of service #$service")
-
-            // cancel previous notification
-            NotificationManagerCompat.from(applicationContext)
-                .cancel(serviceId.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS)
-
-            // create authenticating OkHttpClient (credentials taken from account settings)
-            runInterruptible {
-                HttpClient.Builder(applicationContext, AccountSettings(applicationContext, account))
-                    .setForeground(true)
-                    .build().use { client ->
-                        val httpClient = client.okHttpClient
-                        val refresher = Refresher(db, service, settings, httpClient)
-
-                        // refresh home set list (from principal url)
-                        service.principal?.let { principalUrl ->
-                            Logger.log.fine("Querying principal $principalUrl for home sets")
-                            refresher.discoverHomesets(principalUrl)
-                        }
-
-                        // refresh home sets and their member collections
-                        refresher.refreshHomesetsAndTheirCollections()
-
-                        // also refresh collections without a home set
-                        refresher.refreshHomelessCollections()
-
-                        // Lastly, refresh the principals (collection owners)
-                        refresher.refreshPrincipals()
-                    }
-            }
-
-        } catch(e: InvalidAccountException) {
-            Logger.log.log(Level.SEVERE, "Invalid account", e)
-            return Result.failure()
-        } catch (e: UnauthorizedException) {
-            Logger.log.log(Level.SEVERE, "Not authorized (anymore)", e)
-            // notify that we need to re-authenticate in the account settings
-            val settingsIntent = Intent(applicationContext, AccountSettingsActivity::class.java)
-                .putExtra(AccountSettingsActivity.EXTRA_ACCOUNT, account)
-            notifyRefreshError(
-                applicationContext.getString(R.string.sync_error_authentication_failed),
-                settingsIntent
-            )
-            return Result.failure()
-        } catch(e: Exception) {
-            Logger.log.log(Level.SEVERE, "Couldn't refresh collection list", e)
-
-            val debugIntent = DebugInfoActivity.IntentBuilder(applicationContext)
-                .withCause(e)
-                .withAccount(account)
-                .build()
-            notifyRefreshError(
-                applicationContext.getString(R.string.refresh_collections_worker_refresh_couldnt_refresh),
-                debugIntent
-            )
-            return Result.failure()
-        }
-
-        // Success
-        return Result.success()
-    }
-
-    /**
-     * Used by WorkManager to show a foreground service notification for expedited jobs on Android <12.
-     */
-    override suspend fun getForegroundInfo(): ForegroundInfo {
-        val notification = NotificationUtils.newBuilder(applicationContext, NotificationUtils.CHANNEL_STATUS)
-            .setSmallIcon(R.drawable.ic_foreground_notify)
-            .setContentTitle(applicationContext.getString(R.string.foreground_service_notify_title))
-            .setContentText(applicationContext.getString(R.string.foreground_service_notify_text))
-            .setStyle(NotificationCompat.BigTextStyle())
-            .setCategory(NotificationCompat.CATEGORY_STATUS)
-            .setOngoing(true)
-            .setPriority(NotificationCompat.PRIORITY_LOW)
-            .build()
-        return ForegroundInfo(NotificationUtils.NOTIFY_SYNC_EXPEDITED, notification)
-    }
-
-    private fun notifyRefreshError(contentText: String, contentIntent: Intent) {
-        val notify = NotificationUtils.newBuilder(applicationContext, NotificationUtils.CHANNEL_GENERAL)
-            .setSmallIcon(R.drawable.ic_sync_problem_notify)
-            .setContentTitle(applicationContext.getString(R.string.refresh_collections_worker_refresh_failed))
-            .setContentText(contentText)
-            .setContentIntent(PendingIntent.getActivity(applicationContext, 0, contentIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE))
-            .setSubText(account?.name)
-            .setCategory(NotificationCompat.CATEGORY_ERROR)
-            .build()
-        NotificationManagerCompat.from(applicationContext)
-            .notifyIfPossible(serviceId.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS, notify)
-    }
-
-    /**
-     * Contains the methods, which do the actual refreshing work. Collected here for testability
-     */
-    class Refresher(
-        val db: AppDatabase,
-        val service: Service,
-        val settings: SettingsManager,
-        val httpClient: OkHttpClient
-    ) {
-
-        val alreadyQueried = mutableSetOf<HttpUrl>()
-
-        /**
-         * Starting at current-user-principal URL, tries to recursively find and save all user relevant home sets.
-         *
-         *
-         * @param principalUrl  URL of principal to query (user-provided principal or current-user-principal)
-         * @param level         Current recursion level (limited to 0, 1 or 2):
-         *
-         * - 0: We assume found home sets belong to the current-user-principal
-         * - 1 or 2: We assume found home sets don't directly belong to the current-user-principal
-         *
-         * @throws java.io.IOException
-         * @throws HttpException
-         * @throws at.bitfire.dav4jvm.exception.DavException
-         */
-        internal fun discoverHomesets(principalUrl: HttpUrl, level: Int = 0) {
-            Logger.log.fine("Discovering homesets of $principalUrl")
-            val relatedResources = mutableSetOf<HttpUrl>()
-
-            // Define homeset class and properties to look for
-            val homeSetClass: Class<out HrefListProperty>
-            val properties: Array<Property.Name>
-            when (service.type) {
-                Service.TYPE_CARDDAV -> {
-                    homeSetClass = AddressbookHomeSet::class.java
-                    properties = arrayOf(DisplayName.NAME, AddressbookHomeSet.NAME, GroupMembership.NAME, ResourceType.NAME)
-                }
-                Service.TYPE_CALDAV -> {
-                    homeSetClass = CalendarHomeSet::class.java
-                    properties = arrayOf(DisplayName.NAME, CalendarHomeSet.NAME, CalendarProxyReadFor.NAME, CalendarProxyWriteFor.NAME, GroupMembership.NAME, ResourceType.NAME)
-                }
-                else -> throw IllegalArgumentException()
-            }
-
-            // Query the URL
-            val principal = DavResource(httpClient, principalUrl)
-            val personal = level == 0
-            try {
-                principal.propfind(0, *properties) { davResponse, _ ->
-                    alreadyQueried += davResponse.href
-
-                    // If response holds home sets, save them
-                    davResponse[homeSetClass]?.let { homeSets ->
-                        for (homeSetHref in homeSets.hrefs)
-                            principal.location.resolve(homeSetHref)?.let { homesetUrl ->
-                                val resolvedHomeSetUrl = UrlUtils.withTrailingSlash(homesetUrl)
-                                // Homeset is considered personal if this is the outer recursion call,
-                                // This is because we assume the first call to query the current-user-principal
-                                // Note: This is not be be confused with the DAV:owner attribute. Home sets can be owned by
-                                // other principals and still be considered "personal" (belonging to the current-user-principal).
-                                db.homeSetDao().insertOrUpdateByUrl(
-                                    HomeSet(0, service.id, personal, resolvedHomeSetUrl)
-                                )
-                            }
-                    }
-
-                    // Add related principals to be queried afterwards
-                    if (personal) {
-                        val relatedResourcesTypes = listOf(
-                            // current resource is a read/write-proxy for other principals
-                            CalendarProxyReadFor::class.java,
-                            CalendarProxyWriteFor::class.java,
-                            // current resource is a member of a group (principal that can also have proxies)
-                            GroupMembership::class.java)
-                        for (type in relatedResourcesTypes)
-                            davResponse[type]?.let {
-                                for (href in it.hrefs)
-                                    principal.location.resolve(href)?.let { url ->
-                                        relatedResources += url
-                                    }
-                            }
-                    }
-
-                    // If current resource is a calendar-proxy-read/write, it's likely that its parent is a principal, too.
-                    davResponse[ResourceType::class.java]?.let { resourceType ->
-                        val proxyProperties = arrayOf(
-                            ResourceType.CALENDAR_PROXY_READ,
-                            ResourceType.CALENDAR_PROXY_WRITE,
-                        )
-                        if (proxyProperties.any { resourceType.types.contains(it) })
-                            relatedResources += davResponse.href.parent()
-                    }
-                }
-            } catch (e: HttpException) {
-                if (e.code/100 == 4)
-                    Logger.log.log(Level.INFO, "Ignoring Client Error 4xx while looking for ${service.type} home sets", e)
-                else
-                    throw e
-            }
-
-            // query related resources
-            if (level <= 1)
-                for (resource in relatedResources)
-                    if (alreadyQueried.contains(resource))
-                        Logger.log.warning("$resource already queried, skipping")
-                    else
-                        discoverHomesets(resource, level + 1)
-        }
-
-        /**
-         * Refreshes homesets and their collections.
-         *
-         * Each stored homeset URL is queried (propfind) and it's collections ([MultiResponseCallback]) either saved, updated
-         * or marked as homeless - in case a collection was removed from its homeset.
-         *
-         * If a homeset URL in fact points to a collection directly, the collection will be saved with this URL,
-         * and a null value for it's homeset. Refreshing of collections without homesets is then handled by [refreshHomelessCollections].
-         */
-        internal fun refreshHomesetsAndTheirCollections() {
-            val homesets = db.homeSetDao().getByService(service.id).associateBy { it.url }.toMutableMap()
-            for((homeSetUrl, localHomeset) in homesets) {
-                Logger.log.fine("Listing home set $homeSetUrl")
-
-                // To find removed collections in this homeset: create a queue from existing collections and remove every collection that
-                // is successfully rediscovered. If there are collections left, after processing is done, these are marked homeless.
-                val localHomesetCollections = db.collectionDao()
-                    .getByServiceAndHomeset(service.id, localHomeset.id)
-                    .associateBy { it.url }
-                    .toMutableMap()
-
-                try {
-                    DavResource(httpClient, homeSetUrl).propfind(1, *DAV_COLLECTION_PROPERTIES) { response, relation ->
-                        // Note: This callback may be called multiple times ([MultiResponseCallback])
-                        if (!response.isSuccess())
-                            return@propfind
-
-                        if (relation == Response.HrefRelation.SELF) {
-                            // this response is about the homeset itself
-                            localHomeset.displayName = response[DisplayName::class.java]?.displayName
-                            localHomeset.privBind = response[CurrentUserPrivilegeSet::class.java]?.mayBind ?: true
-                            db.homeSetDao().insertOrUpdateByUrl(localHomeset)
-                        }
-
-                        // in any case, check whether the response is about a usable collection
-                        val collection = Collection.fromDavResponse(response) ?: return@propfind
-
-                        collection.serviceId = service.id
-                        collection.homeSetId = localHomeset.id
-                        collection.sync = shouldPreselect(collection, homesets.values)
-
-                        // .. and save the principal url (collection owner)
-                        response[Owner::class.java]?.href
-                            ?.let { response.href.resolve(it) }
-                            ?.let { principalUrl ->
-                                val principal = Principal.fromServiceAndUrl(service, principalUrl)
-                                val id = db.principalDao().insertOrUpdate(service.id, principal)
-                                collection.ownerId = id
-                            }
-
-                        Logger.log.log(Level.FINE, "Found collection", collection)
-
-                        // save or update collection if usable (ignore it otherwise)
-                        if (isUsableCollection(collection))
-                            db.collectionDao().insertOrUpdateByUrlAndRememberFlags(collection)
-
-                        // Remove this collection from queue - because it was found in the home set
-                        localHomesetCollections.remove(collection.url)
-                    }
-                } catch (e: HttpException) {
-                    // delete home set locally if it was not accessible (40x)
-                    if (e.code in arrayOf(403, 404, 410))
-                        db.homeSetDao().delete(localHomeset)
-                }
-
-                // Mark leftover (not rediscovered) collections from queue as homeless (remove association)
-                for ((_, homelessCollection) in localHomesetCollections) {
-                    homelessCollection.homeSetId = null
-                    db.collectionDao().insertOrUpdateByUrlAndRememberFlags(homelessCollection)
-                }
-
-            }
-        }
-
-        /**
-         * Refreshes collections which don't have a homeset.
-         *
-         * It queries each stored collection with a homeSetId of "null" and either updates or deletes (if inaccessible or unusable) them.
-         */
-        internal fun refreshHomelessCollections() {
-            val homelessCollections = db.collectionDao().getByServiceAndHomeset(service.id, null).associateBy { it.url }.toMutableMap()
-            for((url, localCollection) in homelessCollections) try {
-                DavResource(httpClient, url).propfind(0, *DAV_COLLECTION_PROPERTIES) { response, _ ->
-                    if (!response.isSuccess()) {
-                        db.collectionDao().delete(localCollection)
-                        return@propfind
-                    }
-
-                    // Save or update the collection, if usable, otherwise delete it
-                    Collection.fromDavResponse(response)?.let { collection ->
-                        if (!isUsableCollection(collection))
-                            return@let
-                        collection.serviceId = localCollection.serviceId       // use same service ID as previous entry
-
-                        // .. and save the principal url (collection owner)
-                        response[Owner::class.java]?.href
-                            ?.let { response.href.resolve(it) }
-                            ?.let { principalUrl ->
-                                val principal = Principal.fromServiceAndUrl(service, principalUrl)
-                                val principalId = db.principalDao().insertOrUpdate(service.id, principal)
-                                collection.ownerId = principalId
-                            }
-
-                        db.collectionDao().insertOrUpdateByUrlAndRememberFlags(collection)
-                    } ?: db.collectionDao().delete(localCollection)
-                }
-            } catch (e: HttpException) {
-                // delete collection locally if it was not accessible (40x)
-                if (e.code in arrayOf(403, 404, 410))
-                    db.collectionDao().delete(localCollection)
-                else
-                    throw e
-            }
-
-        }
-
-        /**
-         * Refreshes the principals (get their current display names).
-         * Also removes principals which do not own any collections anymore.
-         */
-        internal fun refreshPrincipals() {
-            // Refresh principals (collection owner urls)
-            val principals = db.principalDao().getByService(service.id)
-            for (oldPrincipal in principals) {
-                val principalUrl = oldPrincipal.url
-                Logger.log.fine("Querying principal $principalUrl")
-                try {
-                    DavResource(httpClient, principalUrl).propfind(0, *DAV_PRINCIPAL_PROPERTIES) { response, _ ->
-                        if (!response.isSuccess())
-                            return@propfind
-                        Principal.fromDavResponse(service.id, response)?.let { principal ->
-                            Logger.log.fine("Got principal: $principal")
-                            db.principalDao().insertOrUpdate(service.id, principal)
-                        }
-                    }
-                } catch (e: HttpException) {
-                    Logger.log.info("Principal update failed with response code ${e.code}. principalUrl=$principalUrl")
-                }
-            }
-
-            // Delete principals which don't own any collections
-            db.principalDao().getAllWithoutCollections().forEach {principal ->
-                db.principalDao().delete(principal)
-            }
-        }
-
-        /**
-         * Finds out whether given collection is usable, by checking that either
-         *  - CalDAV/CardDAV: service and collection type match, or
-         *  - WebCal: subscription source URL is not empty
-         */
-        private fun isUsableCollection(collection: Collection) =
-            (service.type == Service.TYPE_CARDDAV && collection.type == Collection.TYPE_ADDRESSBOOK) ||
-                    (service.type == Service.TYPE_CALDAV && arrayOf(Collection.TYPE_CALENDAR, Collection.TYPE_WEBCAL).contains(collection.type)) ||
-                    (collection.type == Collection.TYPE_WEBCAL && collection.source != null)
-
-        /**
-         * Whether to preselect the given collection for synchronisation, according to the
-         * settings [Settings.PRESELECT_COLLECTIONS] (see there for allowed values) and
-         * [Settings.PRESELECT_COLLECTIONS_EXCLUDED].
-         *
-         * A collection is considered _personal_ if it is found in one of the current-user-principal's home-sets.
-         *
-         * Before a collection is pre-selected, we check whether its URL matches the regexp in
-         * [Settings.PRESELECT_COLLECTIONS_EXCLUDED], in which case *false* is returned.
-         *
-         * @param collection the collection to check
-         * @param homesets list of home-sets (to check whether collection is in a personal home-set)
-         * @return *true* if the collection should be preselected for synchronization; *false* otherwise
-         */
-        internal fun shouldPreselect(collection: Collection, homesets: Iterable<HomeSet>): Boolean {
-            val shouldPreselect = settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS)
-
-            val excluded by lazy {
-                val excludedRegex = settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED)
-                if (!excludedRegex.isNullOrEmpty())
-                    Regex(excludedRegex).containsMatchIn(collection.url.toString())
-                else
-                    false
-            }
-
-            return when (shouldPreselect) {
-                Settings.PRESELECT_COLLECTIONS_ALL ->
-                    // preselect if collection url is not excluded
-                    !excluded
-
-                Settings.PRESELECT_COLLECTIONS_PERSONAL ->
-                    // preselect if is personal (in a personal home-set), but not excluded
-                    homesets
-                        .filter { homeset -> homeset.personal }
-                        .map { homeset -> homeset.id }
-                        .contains(collection.homeSetId)
-                        && !excluded
-
-                else -> // don't preselect
-                    false
-            }
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/settings/AccountSettings.kt

@@ -1,519 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-package at.bitfire.davdroid.settings
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.ContentResolver
-import android.content.Context
-import android.os.Bundle
-import android.provider.CalendarContract
-import androidx.annotation.WorkerThread
-import at.bitfire.davdroid.InvalidAccountException
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.syncadapter.PeriodicSyncWorker
-import at.bitfire.davdroid.syncadapter.SyncUtils
-import at.bitfire.davdroid.util.setAndVerifyUserData
-import at.bitfire.ical4android.TaskProvider
-import at.bitfire.vcard4android.GroupMethod
-import dagger.hilt.EntryPoint
-import dagger.hilt.InstallIn
-import dagger.hilt.android.EntryPointAccessors
-import dagger.hilt.components.SingletonComponent
-import net.openid.appauth.AuthState
-import org.apache.commons.lang3.StringUtils
-import java.util.logging.Level
-
-/**
- * Manages settings of an account.
- *
- * @param context       Required to access account settings
- * @param argAccount    Account to take settings from. If this account is an address book account,
- * settings will be taken from the corresponding main account instead.
- *
- * @throws InvalidAccountException on construction when the account doesn't exist (anymore)
- * @throws IllegalArgumentException when the account type is not _DAVx5_ or _DAVx5 address book_
- */
-class AccountSettings(
-    val context: Context,
-    argAccount: Account
-) {
-
-    @EntryPoint
-    @InstallIn(SingletonComponent::class)
-    interface AccountSettingsEntryPoint {
-        fun migrationsFactory(): AccountSettingsMigrations.Factory
-        fun settingsManager(): SettingsManager
-    }
-
-    companion object {
-
-        const val CURRENT_VERSION = 15
-        const val KEY_SETTINGS_VERSION = "version"
-
-        const val KEY_SYNC_INTERVAL_ADDRESSBOOKS = "sync_interval_addressbooks"
-        const val KEY_SYNC_INTERVAL_CALENDARS = "sync_interval_calendars"
-
-        /** Stores the tasks sync interval (in seconds) so that it can be set again when the provider is switched */
-        const val KEY_SYNC_INTERVAL_TASKS = "sync_interval_tasks"
-
-        const val KEY_USERNAME = "user_name"
-        const val KEY_CERTIFICATE_ALIAS = "certificate_alias"
-
-        /** OAuth [AuthState] (serialized as JSON) */
-        const val KEY_AUTH_STATE = "auth_state"
-
-        const val KEY_WIFI_ONLY = "wifi_only"               // sync on WiFi only (default: false)
-        const val KEY_WIFI_ONLY_SSIDS = "wifi_only_ssids"   // restrict sync to specific WiFi SSIDs
-        const val KEY_IGNORE_VPNS = "ignore_vpns"           // ignore vpns at connection detection
-
-        /** Time range limitation to the past [in days]. Values:
-         *
-         * - null: default value (DEFAULT_TIME_RANGE_PAST_DAYS)
-         * - <0 (typically -1): no limit
-         * - n>0: entries more than n days in the past won't be synchronized
-         */
-        const val KEY_TIME_RANGE_PAST_DAYS = "time_range_past_days"
-        const val DEFAULT_TIME_RANGE_PAST_DAYS = 90
-
-        /**
-         * Whether a default alarm shall be assigned to received events/tasks which don't have an alarm.
-         * Value can be null (no default alarm) or an integer (default alarm shall be created this
-         * number of minutes before the event/task).
-         */
-        const val KEY_DEFAULT_ALARM = "default_alarm"
-
-        /** Whether DAVx5 sets the local calendar color to the value from service DB at every sync
-         value = *null* (not existing): true (default);
-                 "0"                    false */
-        const val KEY_MANAGE_CALENDAR_COLORS = "manage_calendar_colors"
-
-        /** Whether DAVx5 populates and uses CalendarContract.Colors
-         value = *null* (not existing)   false (default);
-                 "1"                     true */
-        const val KEY_EVENT_COLORS = "event_colors"
-
-        /** Contact group method:
-         *null (not existing)*     groups as separate vCards (default);
-         "CATEGORIES"              groups are per-contact CATEGORIES
-         */
-        const val KEY_CONTACT_GROUP_METHOD = "contact_group_method"
-
-        /** UI preference: Show only personal collections
-         value = *null* (not existing)   show all collections (default);
-         "1"                             show only personal collections */
-        const val KEY_SHOW_ONLY_PERSONAL = "show_only_personal"
-
-        const val SYNC_INTERVAL_MANUALLY = -1L
-
-        /** Static property to indicate whether AccountSettings migration is currently running.
-         * **Access must be `synchronized` with `AccountSettings::class.java`.** */
-        @Volatile
-        var currentlyUpdating = false
-
-        fun initialUserData(credentials: Credentials?): Bundle {
-            val bundle = Bundle()
-            bundle.putString(KEY_SETTINGS_VERSION, CURRENT_VERSION.toString())
-
-            if (credentials != null) {
-                if (credentials.username != null)
-                    bundle.putString(KEY_USERNAME, credentials.username)
-
-                if (credentials.certificateAlias != null)
-                    bundle.putString(KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
-
-                if (credentials.authState != null)
-                    bundle.putString(KEY_AUTH_STATE, credentials.authState.jsonSerializeString())
-            }
-
-            return bundle
-        }
-
-    }
-
-
-    private val entryPoint = EntryPointAccessors.fromApplication<AccountSettingsEntryPoint>(context)
-    private val settings = entryPoint.settingsManager()
-
-    val accountManager: AccountManager = AccountManager.get(context)
-    val account: Account
-
-    init {
-        account = when (argAccount.type) {
-            context.getString(R.string.account_type_address_book) -> {
-                /* argAccount is an address book account, which is not a main account. However settings are
-                       stored in the main account, so resolve and use the main account instead. */
-                LocalAddressBook.mainAccount(context, argAccount) ?: throw IllegalArgumentException("Main account of $argAccount not found")
-            }
-
-            context.getString(R.string.account_type) ->
-                argAccount
-
-            else ->
-                throw IllegalArgumentException("Account type ${argAccount.type} not supported")
-        }
-
-        // synchronize because account migration must only be run one time
-        synchronized(AccountSettings::class.java) {
-            val versionStr = accountManager.getUserData(account, KEY_SETTINGS_VERSION) ?: throw InvalidAccountException(account)
-            var version = 0
-            try {
-                version = Integer.parseInt(versionStr)
-            } catch (e: NumberFormatException) {
-                Logger.log.log(Level.SEVERE, "Invalid account version: $versionStr", e)
-            }
-            Logger.log.fine("Account ${account.name} has version $version, current version: $CURRENT_VERSION")
-
-            if (version < CURRENT_VERSION) {
-                if (currentlyUpdating) {
-                    Logger.log.severe("Redundant call: migration created AccountSettings(). This must never happen.")
-                    throw IllegalStateException("Redundant call: migration created AccountSettings()")
-                } else {
-                    currentlyUpdating = true
-                    update(version)
-                    currentlyUpdating = false
-                }
-            }
-        }
-    }
-
-
-    // authentication settings
-
-    fun credentials() = Credentials(
-        accountManager.getUserData(account, KEY_USERNAME),
-        accountManager.getPassword(account),
-
-        accountManager.getUserData(account, KEY_CERTIFICATE_ALIAS),
-
-        accountManager.getUserData(account, KEY_AUTH_STATE)?.let { json ->
-            AuthState.jsonDeserialize(json)
-        }
-    )
-
-    fun credentials(credentials: Credentials) {
-        // Basic/Digest auth
-        accountManager.setAndVerifyUserData(account, KEY_USERNAME, credentials.username)
-        accountManager.setPassword(account, credentials.password)
-
-        // client certificate
-        accountManager.setAndVerifyUserData(account, KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
-
-        // OAuth
-        accountManager.setAndVerifyUserData(account, KEY_AUTH_STATE, credentials.authState?.jsonSerializeString())
-    }
-
-
-    // sync. settings
-
-    /**
-     * Gets the currently set sync interval for this account in seconds.
-     *
-     * @param authority authority to check (for instance: [CalendarContract.AUTHORITY]])
-     * @return sync interval in seconds; *[SYNC_INTERVAL_MANUALLY]* if manual sync; *null* if not set
-     */
-    fun getSyncInterval(authority: String): Long? {
-        if (ContentResolver.getIsSyncable(account, authority) <= 0)
-            return null
-
-        val key = when {
-            authority == context.getString(R.string.address_books_authority) ->
-                KEY_SYNC_INTERVAL_ADDRESSBOOKS
-            authority == CalendarContract.AUTHORITY ->
-                KEY_SYNC_INTERVAL_CALENDARS
-            TaskProvider.ProviderName.entries.any { it.authority == authority } ->
-                KEY_SYNC_INTERVAL_TASKS
-            else -> return null
-        }
-        return accountManager.getUserData(account, key)?.toLong()
-    }
-
-    fun getTasksSyncInterval() = accountManager.getUserData(account, KEY_SYNC_INTERVAL_TASKS)?.toLong()
-
-    /**
-     * Sets the sync interval and en- or disables periodic sync for the given account and authority.
-     * Does *not* call [ContentResolver.setIsSyncable].
-     *
-     * This method blocks until a worker as been created and enqueued (sync active) or removed
-     * (sync disabled), so it should not be called from the UI thread.
-     *
-     * @param authority sync authority (like [CalendarContract.AUTHORITY])
-     * @param _seconds if [SYNC_INTERVAL_MANUALLY]: automatic sync will be disabled;
-     * otherwise (must be ≥ 15 min): automatic sync will be enabled and set to the given number of seconds
-     */
-    @WorkerThread
-    fun setSyncInterval(authority: String, _seconds: Long) {
-        val seconds =
-            if (_seconds != SYNC_INTERVAL_MANUALLY && _seconds < 60*15)
-                60*15
-            else
-                _seconds
-
-        // Store (user defined) sync interval in account settings
-        val key = when {
-            authority == context.getString(R.string.address_books_authority) ->
-                KEY_SYNC_INTERVAL_ADDRESSBOOKS
-            authority == CalendarContract.AUTHORITY ->
-                KEY_SYNC_INTERVAL_CALENDARS
-            TaskProvider.ProviderName.entries.any { it.authority == authority } ->
-                KEY_SYNC_INTERVAL_TASKS
-            else -> {
-                Logger.log.warning("Sync interval not applicable to authority $authority")
-                return
-            }
-        }
-        accountManager.setAndVerifyUserData(account, key, seconds.toString())
-
-        // update sync workers (needs already updated sync interval in AccountSettings)
-        updatePeriodicSyncWorker(authority, seconds, getSyncWifiOnly())
-
-        // Also enable/disable content change triggered syncs (SyncFramework automatic sync).
-        // We could make this a separate user adjustable setting later on.
-        setSyncOnContentChange(authority, seconds != SYNC_INTERVAL_MANUALLY)
-    }
-
-    /**
-     * Enables/disables sync adapter automatic sync (content triggered sync) for the given
-     * account and authority. Does *not* call [ContentResolver.setIsSyncable].
-     *
-     * We use the sync adapter framework only for the trigger, actual syncing is implemented
-     * with WorkManager. The trigger comes in through SyncAdapterService.
-     *
-     * This method blocks until the sync-on-content-change has been enabled or disabled, so it
-     * should not be called from the UI thread.
-     *
-     * @param enable    *true* enables automatic sync; *false* disables it
-     * @param authority sync authority (like [CalendarContract.AUTHORITY])
-     * @return whether the content triggered sync was enabled successfully
-     */
-    @WorkerThread
-    fun setSyncOnContentChange(authority: String, enable: Boolean): Boolean {
-        // Enable content change triggers (sync adapter framework)
-        val setContentTrigger: () -> Boolean =
-            /* Ugly hack: because there is no callback for when the sync status/interval has been
-            updated, we need to make this call blocking. */
-            if (enable) {{
-                Logger.log.fine("Enabling content-triggered sync of $account/$authority")
-                ContentResolver.setSyncAutomatically(account, authority, true) // enables content triggers
-                // Remove unwanted sync framework periodic syncs created by setSyncAutomatically
-                for (periodicSync in ContentResolver.getPeriodicSyncs(account, authority))
-                    ContentResolver.removePeriodicSync(periodicSync.account, periodicSync.authority, periodicSync.extras)
-                /* return */ ContentResolver.getSyncAutomatically(account, authority)
-            }} else {{
-                Logger.log.fine("Disabling content-triggered sync of $account/$authority")
-                ContentResolver.setSyncAutomatically(account, authority, false) // disables content triggers
-                /* return */ !ContentResolver.getSyncAutomatically(account, authority)
-            }}
-
-        // try up to 10 times with 100 ms pause
-        for (idxTry in 0 until 10) {
-            if (setContentTrigger())
-                // successfully set
-                return true
-            Thread.sleep(100)
-        }
-        return false
-    }
-
-    fun getSyncWifiOnly() =
-        if (settings.containsKey(KEY_WIFI_ONLY))
-            settings.getBoolean(KEY_WIFI_ONLY)
-        else
-            accountManager.getUserData(account, KEY_WIFI_ONLY) != null
-
-    fun setSyncWiFiOnly(wiFiOnly: Boolean) {
-        accountManager.setAndVerifyUserData(account, KEY_WIFI_ONLY, if (wiFiOnly) "1" else null)
-
-        // update sync workers (needs already updated wifi-only flag in AccountSettings)
-        for (authority in SyncUtils.syncAuthorities(context))
-            updatePeriodicSyncWorker(authority, getSyncInterval(authority), wiFiOnly)
-    }
-
-    fun getSyncWifiOnlySSIDs(): List<String>? =
-        if (getSyncWifiOnly()) {
-            val strSsids = if (settings.containsKey(KEY_WIFI_ONLY_SSIDS))
-                settings.getString(KEY_WIFI_ONLY_SSIDS)
-            else
-                accountManager.getUserData(account, KEY_WIFI_ONLY_SSIDS)
-            strSsids?.split(',')
-        } else
-            null
-    fun setSyncWifiOnlySSIDs(ssids: List<String>?) =
-        accountManager.setAndVerifyUserData(account, KEY_WIFI_ONLY_SSIDS, StringUtils.trimToNull(ssids?.joinToString(",")))
-
-    fun getIgnoreVpns(): Boolean =
-        when (accountManager.getUserData(account, KEY_IGNORE_VPNS)) {
-            null -> settings.getBoolean(KEY_IGNORE_VPNS)
-            "0" -> false
-            else -> true
-        }
-
-    fun setIgnoreVpns(ignoreVpns: Boolean) =
-        accountManager.setAndVerifyUserData(account, KEY_IGNORE_VPNS, if (ignoreVpns) "1" else "0")
-
-    /**
-     * Updates the periodic sync worker of an authority according to
-     *
-     * - the sync interval and
-     * - the _Sync WiFi only_ flag.
-     *
-     * @param authority   periodic sync workers for this authority will be updated
-     * @param seconds     sync interval in seconds (`null` or [SYNC_INTERVAL_MANUALLY] disables periodic sync)
-     * @param wiFiOnly    sync Wifi only flag
-     */
-    fun updatePeriodicSyncWorker(authority: String, seconds: Long?, wiFiOnly: Boolean) {
-        try {
-            if (seconds == null || seconds == SYNC_INTERVAL_MANUALLY) {
-                Logger.log.fine("Disabling periodic sync of $account/$authority")
-                PeriodicSyncWorker.disable(context, account, authority)
-            } else {
-                Logger.log.fine("Setting periodic sync of $account/$authority to $seconds seconds (wifiOnly=$wiFiOnly)")
-                PeriodicSyncWorker.enable(context, account, authority, seconds, wiFiOnly)
-            }.result.get() // On operation (enable/disable) failure exception is thrown
-        } catch (e: Exception) {
-            Logger.log.log(Level.SEVERE, "Failed to set sync interval of $account/$authority to $seconds seconds", e)
-        }
-    }
-
-
-    // CalDAV settings
-
-    fun getTimeRangePastDays(): Int? {
-        val strDays = accountManager.getUserData(account, KEY_TIME_RANGE_PAST_DAYS)
-        return if (strDays != null) {
-            val days = strDays.toInt()
-            if (days < 0)
-                null
-            else
-                days
-        } else
-            DEFAULT_TIME_RANGE_PAST_DAYS
-    }
-
-    fun setTimeRangePastDays(days: Int?) =
-            accountManager.setAndVerifyUserData(account, KEY_TIME_RANGE_PAST_DAYS, (days ?: -1).toString())
-
-    /**
-     * Takes the default alarm setting (in this order) from
-     *
-     * 1. the local account settings
-     * 2. the settings provider (unless the value is -1 there).
-     *
-     * @return A default reminder shall be created this number of minutes before the start of every
-     * non-full-day event without reminder. *null*: No default reminders shall be created.
-     */
-    fun getDefaultAlarm() =
-            accountManager.getUserData(account, KEY_DEFAULT_ALARM)?.toInt() ?:
-            settings.getIntOrNull(KEY_DEFAULT_ALARM)?.takeIf { it != -1 }
-
-    /**
-     * Sets the default alarm value in the local account settings, if the new value differs
-     * from the value of the settings provider. If the new value is the same as the value of
-     * the settings provider, the local setting will be deleted, so that the settings provider
-     * value applies.
-     *
-     * @param minBefore The number of minutes a default reminder shall be created before the
-     * start of every non-full-day event without reminder. *null*: No default reminders shall be created.
-     */
-    fun setDefaultAlarm(minBefore: Int?) =
-            accountManager.setAndVerifyUserData(account, KEY_DEFAULT_ALARM,
-                    if (minBefore == settings.getIntOrNull(KEY_DEFAULT_ALARM)?.takeIf { it != -1 })
-                        null
-                    else
-                        minBefore?.toString())
-
-    fun getManageCalendarColors() = if (settings.containsKey(KEY_MANAGE_CALENDAR_COLORS))
-        settings.getBoolean(KEY_MANAGE_CALENDAR_COLORS)
-    else
-        accountManager.getUserData(account, KEY_MANAGE_CALENDAR_COLORS) == null
-    fun setManageCalendarColors(manage: Boolean) =
-            accountManager.setAndVerifyUserData(account, KEY_MANAGE_CALENDAR_COLORS, if (manage) null else "0")
-
-    fun getEventColors() = if (settings.containsKey(KEY_EVENT_COLORS))
-            settings.getBoolean(KEY_EVENT_COLORS)
-                else
-            accountManager.getUserData(account, KEY_EVENT_COLORS) != null
-    fun setEventColors(useColors: Boolean) =
-            accountManager.setAndVerifyUserData(account, KEY_EVENT_COLORS, if (useColors) "1" else null)
-
-    // CardDAV settings
-
-    fun getGroupMethod(): GroupMethod {
-        val name = settings.getString(KEY_CONTACT_GROUP_METHOD) ?:
-                accountManager.getUserData(account, KEY_CONTACT_GROUP_METHOD)
-        if (name != null)
-            try {
-                return GroupMethod.valueOf(name)
-            }
-            catch (_: IllegalArgumentException) {
-            }
-        return GroupMethod.GROUP_VCARDS
-    }
-
-    fun setGroupMethod(method: GroupMethod) {
-        accountManager.setAndVerifyUserData(account, KEY_CONTACT_GROUP_METHOD, method.name)
-    }
-
-
-    // UI settings
-
-    data class ShowOnlyPersonal(
-        val onlyPersonal: Boolean,
-        val locked: Boolean
-    )
-
-    fun getShowOnlyPersonal(): ShowOnlyPersonal {
-        @Suppress("DEPRECATION")
-        val pair = getShowOnlyPersonalPair()
-        return ShowOnlyPersonal(onlyPersonal = pair.first, locked = !pair.second)
-    }
-
-    /**
-     * Whether only personal collections should be shown.
-     *
-     * @return [Pair] of values:
-     *
-     *   1. (first) whether only personal collections should be shown
-     *   2. (second) whether the user shall be able to change the setting (= setting not locked)
-     */
-    @Deprecated("Use getShowOnlyPersonal() instead", replaceWith = ReplaceWith("getShowOnlyPersonal()"))
-    fun getShowOnlyPersonalPair(): Pair<Boolean, Boolean> =
-            when (settings.getIntOrNull(KEY_SHOW_ONLY_PERSONAL)) {
-                0 -> Pair(false, false)
-                1 -> Pair(true, false)
-                else /* including -1 */ -> Pair(accountManager.getUserData(account, KEY_SHOW_ONLY_PERSONAL) != null, true)
-            }
-
-    fun setShowOnlyPersonal(showOnlyPersonal: Boolean) {
-        accountManager.setAndVerifyUserData(account, KEY_SHOW_ONLY_PERSONAL, if (showOnlyPersonal) "1" else null)
-    }
-
-
-    // update from previous account settings
-
-    private fun update(baseVersion: Int) {
-        for (toVersion in baseVersion+1 ..CURRENT_VERSION) {
-            val fromVersion = toVersion-1
-            Logger.log.info("Updating account ${account.name} from version $fromVersion to $toVersion")
-            try {
-                val migrationsFactory = entryPoint.migrationsFactory()
-                val migrations = migrationsFactory.create(
-                    account = account,
-                    accountSettings = this
-                )
-                val updateProc = AccountSettingsMigrations::class.java.getDeclaredMethod("update_${fromVersion}_$toVersion")
-                updateProc.invoke(migrations)
-
-                Logger.log.info("Account version update successful")
-                accountManager.setAndVerifyUserData(account, KEY_SETTINGS_VERSION, toVersion.toString())
-            } catch (e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't update account settings", e)
-            }
-        }
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/settings/AccountSettingsMigrations.kt

@@ -1,431 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.settings
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.annotation.SuppressLint
-import android.app.Application
-import android.content.ContentResolver
-import android.content.ContentUris
-import android.content.ContentValues
-import android.content.pm.PackageManager
-import android.os.Parcel
-import android.os.RemoteException
-import android.provider.CalendarContract
-import android.provider.ContactsContract
-import android.util.Base64
-import androidx.core.content.ContextCompat
-import androidx.preference.PreferenceManager
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.Service
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.resource.LocalTask
-import at.bitfire.davdroid.syncadapter.BaseSyncWorker
-import at.bitfire.davdroid.syncadapter.SyncUtils
-import at.bitfire.davdroid.util.TaskUtils
-import at.bitfire.davdroid.util.setAndVerifyUserData
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.AndroidEvent
-import at.bitfire.ical4android.TaskProvider
-import at.bitfire.ical4android.UnknownProperty
-import at.bitfire.vcard4android.ContactsStorageException
-import at.bitfire.vcard4android.GroupMethod
-import at.techbee.jtx.JtxContract.asSyncAdapter
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedFactory
-import dagger.assisted.AssistedInject
-import net.fortuna.ical4j.model.Property
-import net.fortuna.ical4j.model.property.Url
-import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
-import org.dmfs.tasks.contract.TaskContract
-import java.io.ByteArrayInputStream
-import java.io.ObjectInputStream
-import java.util.logging.Level
-
-class AccountSettingsMigrations @AssistedInject constructor(
-    @Assisted val account: Account,
-    @Assisted val accountSettings: AccountSettings,
-    val context: Application,
-    val db: AppDatabase,
-    val settings: SettingsManager
-) {
-
-    @AssistedFactory
-    interface Factory {
-        fun create(account: Account, accountSettings: AccountSettings): AccountSettingsMigrations
-    }
-
-
-    val accountManager: AccountManager = AccountManager.get(context)
-
-
-    /**
-     * Updates the periodic sync workers by re-setting the same sync interval.
-     *
-     * The goal is to add the [BaseSyncWorker.commonTag] to all existing periodic sync workers so that they can be detected by
-     * the new [BaseSyncWorker.exists] and [at.bitfire.davdroid.ui.AccountsActivity.Model].
-     */
-    @Suppress("unused","FunctionName")
-    fun update_14_15() {
-        for (authority in SyncUtils.syncAuthorities(context)) {
-            val interval = accountSettings.getSyncInterval(authority)
-            accountSettings.setSyncInterval(authority, interval ?: AccountSettings.SYNC_INTERVAL_MANUALLY)
-        }
-    }
-
-    /**
-     * Disables all sync adapter periodic syncs for every authority. Then enables
-     * corresponding PeriodicSyncWorkers
-     */
-    @Suppress("unused","FunctionName")
-    fun update_13_14() {
-        // Cancel any potentially running syncs for this account (sync framework)
-        ContentResolver.cancelSync(account, null)
-
-        val authorities = listOf(
-            context.getString(R.string.address_books_authority),
-            CalendarContract.AUTHORITY,
-            TaskProvider.ProviderName.JtxBoard.authority,
-            TaskProvider.ProviderName.OpenTasks.authority,
-            TaskProvider.ProviderName.TasksOrg.authority
-        )
-
-        for (authority in authorities) {
-            // Enable PeriodicSyncWorker (WorkManager), with known intervals
-            v14_enableWorkManager(authority)
-            // Disable periodic syncs (sync adapter framework)
-            v14_disableSyncFramework(authority)
-        }
-    }
-    private fun v14_enableWorkManager(authority: String) {
-        val enabled = accountSettings.getSyncInterval(authority)?.let { syncInterval ->
-            accountSettings.setSyncInterval(authority, syncInterval)
-        } ?: false
-        Logger.log.info("PeriodicSyncWorker for $account/$authority enabled=$enabled")
-    }
-    private fun v14_disableSyncFramework(authority: String) {
-        // Disable periodic syncs (sync adapter framework)
-        val disable: () -> Boolean = {
-            /* Ugly hack: because there is no callback for when the sync status/interval has been
-            updated, we need to make this call blocking. */
-            for (sync in ContentResolver.getPeriodicSyncs(account, authority))
-                ContentResolver.removePeriodicSync(sync.account, sync.authority, sync.extras)
-
-            // check whether syncs are really disabled
-            var result = true
-            for (sync in ContentResolver.getPeriodicSyncs(account, authority)) {
-                Logger.log.info("Sync framework still has a periodic sync for $account/$authority: $sync")
-                result = false
-            }
-            result
-        }
-        // try up to 10 times with 100 ms pause
-        var success = false
-        for (idxTry in 0 until 10) {
-            success = disable()
-            if (success)
-                break
-            Thread.sleep(200)
-        }
-        Logger.log.info("Sync framework periodic syncs for $account/$authority disabled=$success")
-    }
-
-    @Suppress("unused","FunctionName")
-    /**
-     * Not a per-account migration, but not a database migration, too, so it fits best there.
-     * Best future solution would be that SettingsManager manages versions and migrations.
-     *
-     * Updates proxy settings from override_proxy_* to proxy_type, proxy_host, proxy_port.
-     */
-    private fun update_12_13() {
-        // proxy settings are managed by SharedPreferencesProvider
-        val preferences = PreferenceManager.getDefaultSharedPreferences(context)
-
-        // old setting names
-        val overrideProxy = "override_proxy"
-        val overrideProxyHost = "override_proxy_host"
-        val overrideProxyPort = "override_proxy_port"
-
-        val edit = preferences.edit()
-        if (preferences.contains(overrideProxy)) {
-            if (preferences.getBoolean(overrideProxy, false))
-            // override_proxy set, migrate to proxy_type = HTTP
-                edit.putInt(Settings.PROXY_TYPE, Settings.PROXY_TYPE_HTTP)
-            edit.remove(overrideProxy)
-        }
-        if (preferences.contains(overrideProxyHost)) {
-            preferences.getString(overrideProxyHost, null)?.let { host ->
-                edit.putString(Settings.PROXY_HOST, host)
-            }
-            edit.remove(overrideProxyHost)
-        }
-        if (preferences.contains(overrideProxyPort)) {
-            val port = preferences.getInt(overrideProxyPort, 0)
-            if (port != 0)
-                edit.putInt(Settings.PROXY_PORT, port)
-            edit.remove(overrideProxyPort)
-        }
-        edit.apply()
-    }
-
-
-    @Suppress("unused","FunctionName")
-    /**
-     * Store event URLs as URL (extended property) instead of unknown property. At the same time,
-     * convert legacy unknown properties to the current format.
-     */
-    private fun update_11_12() {
-        if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED) {
-            context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.use { provider ->
-                // Attention: CalendarProvider does NOT limit the results of the ExtendedProperties query
-                // to the given account! So all extended properties will be processed number-of-accounts times.
-                val extUri = CalendarContract.ExtendedProperties.CONTENT_URI.asSyncAdapter(account)
-
-                provider.query(
-                    extUri, arrayOf(
-                        CalendarContract.ExtendedProperties._ID,     // idx 0
-                        CalendarContract.ExtendedProperties.NAME,    // idx 1
-                        CalendarContract.ExtendedProperties.VALUE    // idx 2
-                    ), null, null, null
-                )?.use { cursor ->
-                    while (cursor.moveToNext()) {
-                        val id = cursor.getLong(0)
-                        val rawValue = cursor.getString(2)
-
-                        val uri by lazy {
-                            ContentUris.withAppendedId(CalendarContract.ExtendedProperties.CONTENT_URI, id).asSyncAdapter(account)
-                        }
-
-                        when (cursor.getString(1)) {
-                            UnknownProperty.CONTENT_ITEM_TYPE -> {
-                                // unknown property; check whether it's a URL
-                                try {
-                                    val property = UnknownProperty.fromJsonString(rawValue)
-                                    if (property is Url) {  // rewrite to MIMETYPE_URL
-                                        val newValues = ContentValues(2)
-                                        newValues.put(CalendarContract.ExtendedProperties.NAME, AndroidEvent.EXTNAME_URL)
-                                        newValues.put(CalendarContract.ExtendedProperties.VALUE, property.value)
-                                        provider.update(uri, newValues, null, null)
-                                    }
-                                } catch (e: Exception) {
-                                    Logger.log.log(
-                                        Level.WARNING,
-                                        "Couldn't rewrite URL from unknown property to ${AndroidEvent.EXTNAME_URL}",
-                                        e
-                                    )
-                                }
-                            }
-
-                            "unknown-property" -> {
-                                // unknown property (deprecated format); convert to current format
-                                try {
-                                    val stream = ByteArrayInputStream(Base64.decode(rawValue, Base64.NO_WRAP))
-                                    ObjectInputStream(stream).use {
-                                        (it.readObject() as? Property)?.let { property ->
-                                            // rewrite to current format
-                                            val newValues = ContentValues(2)
-                                            newValues.put(CalendarContract.ExtendedProperties.NAME, UnknownProperty.CONTENT_ITEM_TYPE)
-                                            newValues.put(CalendarContract.ExtendedProperties.VALUE, UnknownProperty.toJsonString(property))
-                                            provider.update(uri, newValues, null, null)
-                                        }
-                                    }
-                                } catch (e: Exception) {
-                                    Logger.log.log(Level.WARNING, "Couldn't rewrite deprecated unknown property to current format", e)
-                                }
-                            }
-
-                            "unknown-property.v2" -> {
-                                // unknown property (deprecated MIME type); rewrite to current MIME type
-                                val newValues = ContentValues(1)
-                                newValues.put(CalendarContract.ExtendedProperties.NAME, UnknownProperty.CONTENT_ITEM_TYPE)
-                                provider.update(uri, newValues, null, null)
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    @Suppress("unused","FunctionName")
-    /**
-     * The tasks sync interval should be stored in account settings. It's used to set the sync interval
-     * again when the tasks provider is switched.
-     */
-    private fun update_10_11() {
-        TaskUtils.currentProvider(context)?.let { provider ->
-            val interval = accountSettings.getSyncInterval(provider.authority)
-            if (interval != null)
-                accountManager.setAndVerifyUserData(account,
-                    AccountSettings.KEY_SYNC_INTERVAL_TASKS, interval.toString())
-        }
-    }
-
-    @Suppress("unused","FunctionName")
-    /**
-     * Task synchronization now handles alarms, categories, relations and unknown properties.
-     * Setting task ETags to null will cause them to be downloaded (and parsed) again.
-     *
-     * Also update the allowed reminder types for calendars.
-     **/
-    private fun update_9_10() {
-        TaskProvider.acquire(context, TaskProvider.ProviderName.OpenTasks)?.use { provider ->
-            val tasksUri = provider.tasksUri().asSyncAdapter(account)
-            val emptyETag = ContentValues(1)
-            emptyETag.putNull(LocalTask.COLUMN_ETAG)
-            provider.client.update(tasksUri, emptyETag, "${TaskContract.Tasks._DIRTY}=0 AND ${TaskContract.Tasks._DELETED}=0", null)
-        }
-
-        if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED)
-            context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.use { provider ->
-                provider.update(
-                    CalendarContract.Calendars.CONTENT_URI.asSyncAdapter(account),
-                    AndroidCalendar.calendarBaseValues, null, null)
-            }
-    }
-
-    @Suppress("unused","FunctionName")
-    /**
-     * It seems that somehow some non-CalDAV accounts got OpenTasks syncable, which caused battery problems.
-     * Disable it on those accounts for the future.
-     */
-    private fun update_8_9() {
-        val hasCalDAV = db.serviceDao().getByAccountAndType(account.name, Service.TYPE_CALDAV) != null
-        if (!hasCalDAV && ContentResolver.getIsSyncable(account, TaskProvider.ProviderName.OpenTasks.authority) != 0) {
-            Logger.log.info("Disabling OpenTasks sync for $account")
-            ContentResolver.setIsSyncable(account, TaskProvider.ProviderName.OpenTasks.authority, 0)
-        }
-    }
-
-    @Suppress("unused","FunctionName")
-    @SuppressLint("Recycle")
-    /**
-     * There is a mistake in this method. [TaskContract.Tasks.SYNC_VERSION] is used to store the
-     * SEQUENCE and should not be used for the eTag.
-     */
-    private fun update_7_8() {
-        TaskProvider.acquire(context, TaskProvider.ProviderName.OpenTasks)?.use { provider ->
-            // ETag is now in sync_version instead of sync1
-            // UID  is now in _uid         instead of sync2
-            provider.client.query(provider.tasksUri().asSyncAdapter(account),
-                arrayOf(TaskContract.Tasks._ID, TaskContract.Tasks.SYNC1, TaskContract.Tasks.SYNC2),
-                "${TaskContract.Tasks.ACCOUNT_TYPE}=? AND ${TaskContract.Tasks.ACCOUNT_NAME}=?",
-                arrayOf(account.type, account.name), null)!!.use { cursor ->
-                while (cursor.moveToNext()) {
-                    val id = cursor.getLong(0)
-                    val eTag = cursor.getString(1)
-                    val uid = cursor.getString(2)
-                    val values = ContentValues(4)
-                    values.put(TaskContract.Tasks._UID, uid)
-                    values.put(TaskContract.Tasks.SYNC_VERSION, eTag)
-                    values.putNull(TaskContract.Tasks.SYNC1)
-                    values.putNull(TaskContract.Tasks.SYNC2)
-                    Logger.log.log(Level.FINER, "Updating task $id", values)
-                    provider.client.update(
-                        ContentUris.withAppendedId(provider.tasksUri(), id).asSyncAdapter(account),
-                        values, null, null)
-                }
-            }
-        }
-    }
-
-    @Suppress("unused")
-    @SuppressLint("Recycle")
-    private fun update_6_7() {
-        // add calendar colors
-        context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.use { provider ->
-            AndroidCalendar.insertColors(provider, account)
-        }
-
-        // update allowed WiFi settings key
-        val onlySSID = accountManager.getUserData(account, "wifi_only_ssid")
-        accountManager.setAndVerifyUserData(account, AccountSettings.KEY_WIFI_ONLY_SSIDS, onlySSID)
-        accountManager.setAndVerifyUserData(account, "wifi_only_ssid", null)
-    }
-
-    @Suppress("unused")
-    @SuppressLint("ParcelClassLoader")
-    private fun update_5_6() {
-        context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.use { provider ->
-            val parcel = Parcel.obtain()
-            try {
-                // don't run syncs during the migration
-                ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 0)
-                ContentResolver.setIsSyncable(account, context.getString(R.string.address_books_authority), 0)
-                ContentResolver.cancelSync(account, null)
-
-                // get previous address book settings (including URL)
-                val raw = ContactsContract.SyncState.get(provider, account)
-                if (raw == null)
-                    Logger.log.info("No contacts sync state, ignoring account")
-                else {
-                    parcel.unmarshall(raw, 0, raw.size)
-                    parcel.setDataPosition(0)
-                    val params = parcel.readBundle()!!
-                    val url = params.getString("url")?.toHttpUrlOrNull()
-                    if (url == null)
-                        Logger.log.info("No address book URL, ignoring account")
-                    else {
-                        // create new address book
-                        val info = Collection(url = url, type = Collection.TYPE_ADDRESSBOOK, displayName = account.name)
-                        Logger.log.log(Level.INFO, "Creating new address book account", url)
-                        val addressBookAccount = Account(
-                            LocalAddressBook.accountName(account, info), context.getString(
-                                R.string.account_type_address_book))
-                        if (!accountManager.addAccountExplicitly(addressBookAccount, null, LocalAddressBook.initialUserData(account, info.url.toString())))
-                            throw ContactsStorageException("Couldn't create address book account")
-
-                        // move contacts to new address book
-                        Logger.log.info("Moving contacts from $account to $addressBookAccount")
-                        val newAccount = ContentValues(2)
-                        newAccount.put(ContactsContract.RawContacts.ACCOUNT_NAME, addressBookAccount.name)
-                        newAccount.put(ContactsContract.RawContacts.ACCOUNT_TYPE, addressBookAccount.type)
-                        val affected = provider.update(
-                            ContactsContract.RawContacts.CONTENT_URI.buildUpon()
-                            .appendQueryParameter(ContactsContract.RawContacts.ACCOUNT_NAME, account.name)
-                            .appendQueryParameter(ContactsContract.RawContacts.ACCOUNT_TYPE, account.type)
-                            .appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true").build(),
-                            newAccount,
-                            "${ContactsContract.RawContacts.ACCOUNT_NAME}=? AND ${ContactsContract.RawContacts.ACCOUNT_TYPE}=?",
-                            arrayOf(account.name, account.type))
-                        Logger.log.info("$affected contacts moved to new address book")
-                    }
-
-                    ContactsContract.SyncState.set(provider, account, null)
-                }
-            } catch(e: RemoteException) {
-                throw ContactsStorageException("Couldn't migrate contacts to new address book", e)
-            } finally {
-                parcel.recycle()
-            }
-        }
-
-        // update version number so that further syncs don't repeat the migration
-        accountManager.setAndVerifyUserData(account, AccountSettings.KEY_SETTINGS_VERSION, "6")
-
-        // request sync of new address book account
-        ContentResolver.setIsSyncable(account, context.getString(R.string.address_books_authority), 1)
-        accountSettings.setSyncInterval(context.getString(R.string.address_books_authority), 4*3600)
-    }
-
-    /* Android 7.1.1 OpenTasks fix */
-    @Suppress("unused")
-    private fun update_4_5() {
-        // call PackageChangedReceiver which then enables/disables OpenTasks sync when it's (not) available
-        TaskUtils.selectProvider(context, TaskUtils.currentProvider(context))
-    }
-
-    @Suppress("unused")
-    private fun update_3_4() {
-        accountSettings.setGroupMethod(GroupMethod.CATEGORIES)
-    }
-
-    // updates from AccountSettings version 2 and below are not supported anymore
-
-}

app/src/main/kotlin/at/bitfire/davdroid/settings/DefaultsProvider.kt

@@ -1,55 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.settings
-
-import android.content.Context
-import dagger.Binds
-import dagger.Module
-import dagger.hilt.InstallIn
-import dagger.hilt.components.SingletonComponent
-import dagger.multibindings.IntKey
-import dagger.multibindings.IntoMap
-import javax.inject.Inject
-
-class DefaultsProvider(
-    context: Context,
-    settingsManager: SettingsManager
-): BaseDefaultsProvider(context, settingsManager) {
-
-    override val booleanDefaults = mutableMapOf(
-        Pair(Settings.DISTRUST_SYSTEM_CERTIFICATES, false),
-        Pair(Settings.FORCE_READ_ONLY_ADDRESSBOOKS, false),
-        Pair(Settings.IGNORE_VPN_NETWORK_CAPABILITY, true)
-    )
-
-    override val intDefaults = mapOf(
-        Pair(Settings.PRESELECT_COLLECTIONS, Settings.PRESELECT_COLLECTIONS_NONE),
-        Pair(Settings.PROXY_TYPE, Settings.PROXY_TYPE_SYSTEM),
-        Pair(Settings.PROXY_PORT, 9050)     // Orbot SOCKS
-    )
-
-    override val longDefaults = mapOf<String, Long>(
-        Pair(Settings.DEFAULT_SYNC_INTERVAL, 4*3600)    /* 4 hours */
-    )
-
-    override val stringDefaults = mapOf(
-        Pair(Settings.PROXY_HOST, "localhost"),
-        Pair(Settings.PRESELECT_COLLECTIONS_EXCLUDED, "/z-app-generated--contactsinteraction--recent/") // Nextcloud "Recently Contacted" address book
-    )
-
-    class Factory @Inject constructor(): SettingsProviderFactory {
-        override fun getProviders(context: Context, settingsManager: SettingsManager) =
-            listOf(DefaultsProvider(context, settingsManager))
-    }
-
-    @Module
-    @InstallIn(SingletonComponent::class)
-    abstract class DefaultsProviderFactoryModule {
-        @Binds
-        @IntoMap @IntKey(/* priority */ 0)
-        abstract fun factory(impl: Factory): SettingsProviderFactory
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/settings/SettingsProviderFactory.kt

@@ -1,13 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.settings
-
-import android.content.Context
-
-interface SettingsProviderFactory {
-
-    fun getProviders(context: Context, settingsManager: SettingsManager): Iterable<SettingsProvider>
-
-}

app/src/main/kotlin/at/bitfire/davdroid/syncadapter/AccountUtils.kt

@@ -1,68 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.Context
-import android.os.Bundle
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.util.setAndVerifyUserData
-
-object AccountUtils {
-
-    /**
-     * Creates an account and makes sure the user data are set correctly.
-     *
-     * @param context  operating context
-     * @param account  account to create
-     * @param userData user data to set
-     *
-     * @return whether the account has been created
-     *
-     * @throws IllegalArgumentException when user data contains non-String values
-     * @throws IllegalStateException if user data can't be set
-     */
-    fun createAccount(context: Context, account: Account, userData: Bundle, password: String? = null): Boolean {
-        // validate user data
-        for (key in userData.keySet()) {
-            userData.get(key)?.let { entry ->
-                if (entry !is String)
-                    throw IllegalArgumentException("userData[$key] is ${entry::class.java} (expected: String)")
-            }
-        }
-
-        // create account
-        val manager = AccountManager.get(context)
-        if (!manager.addAccountExplicitly(account, password, userData))
-            return false
-
-        // Android seems to lose the initial user data sometimes, so set it a second time if that happens
-        // https://forums.bitfire.at/post/11644
-        if (!verifyUserData(context, account, userData))
-            for (key in userData.keySet())
-                manager.setAndVerifyUserData(account, key, userData.getString(key))
-
-        if (!verifyUserData(context, account, userData))
-            throw IllegalStateException("Android doesn't store user data in account")
-
-        return true
-    }
-
-    private fun verifyUserData(context: Context, account: Account, userData: Bundle): Boolean {
-        val accountManager = AccountManager.get(context)
-        userData.keySet().forEach { key ->
-            val stored = accountManager.getUserData(account, key)
-            val expected = userData.getString(key)
-            if (stored != expected) {
-                Logger.log.warning("Stored user data \"$stored\" differs from expected data \"$expected\" for $key")
-                return false
-            }
-        }
-        return true
-    }
-
-
-}

app/src/main/kotlin/at/bitfire/davdroid/syncadapter/AccountsCleanupWorker.kt

@@ -1,98 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.Context
-import androidx.hilt.work.HiltWorker
-import androidx.work.ExistingPeriodicWorkPolicy
-import androidx.work.PeriodicWorkRequestBuilder
-import androidx.work.WorkManager
-import androidx.work.Worker
-import androidx.work.WorkerParameters
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalAddressBook
-import dagger.assisted.Assisted
-import dagger.assisted.AssistedInject
-import java.time.Duration
-import java.util.concurrent.Semaphore
-import java.util.logging.Level
-
-@HiltWorker
-class AccountsCleanupWorker @AssistedInject constructor(
-    @Assisted appContext: Context,
-    @Assisted workerParameters: WorkerParameters,
-    val db: AppDatabase
-): Worker(appContext, workerParameters) {
-
-    companion object {
-        const val NAME = "accounts-cleanup"
-
-        private val mutex = Semaphore(1)
-        /**
-         * Prevents account cleanup from being run until `unlockAccountsCleanup` is called.
-         * Can only be active once at the same time globally (blocking).
-         */
-        fun lockAccountsCleanup() = mutex.acquire()
-        /** Must be called exactly one time after calling `lockAccountsCleanup`. */
-        fun unlockAccountsCleanup() = mutex.release()
-
-        /**
-         * Enqueues [AccountsCleanupWorker] to be run regularly (but not necessarily now).
-         */
-        fun enqueue(context: Context) {
-            // run every day
-            val rq = PeriodicWorkRequestBuilder<AccountsCleanupWorker>(Duration.ofDays(1))
-            WorkManager.getInstance(context).enqueueUniquePeriodicWork(NAME, ExistingPeriodicWorkPolicy.UPDATE, rq.build())
-        }
-
-    }
-
-    override fun doWork(): Result {
-        lockAccountsCleanup()
-        try {
-            val accountManager = AccountManager.get(applicationContext)
-            cleanupAccounts(applicationContext, accountManager.accounts)
-        } finally {
-            unlockAccountsCleanup()
-        }
-        return Result.success()
-    }
-
-    private fun cleanupAccounts(context: Context, accounts: Array<out Account>) {
-        Logger.log.log(Level.INFO, "Cleaning up accounts. Current accounts:", accounts)
-
-        val mainAccountType = context.getString(R.string.account_type)
-        val mainAccountNames = accounts
-            .filter { account -> account.type == mainAccountType }
-            .map { it.name }
-
-        val addressBookAccountType = context.getString(R.string.account_type_address_book)
-        val addressBooks = accounts
-            .filter { account -> account.type == addressBookAccountType }
-            .map { addressBookAccount -> LocalAddressBook(context, addressBookAccount, null) }
-        for (addressBook in addressBooks) {
-            try {
-                val mainAccount = addressBook.mainAccount
-                if (mainAccount == null || !mainAccountNames.contains(mainAccount.name))
-                    // the main account for this address book doesn't exist anymore
-                    addressBook.delete()
-            } catch(e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't delete address book account", e)
-            }
-        }
-
-        // delete orphaned services in DB
-        val serviceDao = db.serviceDao()
-        if (mainAccountNames.isEmpty())
-            serviceDao.deleteAll()
-        else
-            serviceDao.deleteExceptAccounts(mainAccountNames.toTypedArray())
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/syncadapter/AddressBookProvider.kt

@@ -1,20 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.content.ContentProvider
-import android.content.ContentValues
-import android.net.Uri
-
-class AddressBookProvider: ContentProvider() {
-
-    override fun onCreate() = false
-    override fun insert(p0: Uri, p1: ContentValues?) = null
-    override fun query(p0: Uri, p1: Array<out String>?, p2: String?, p3: Array<out String>?, p4: String?) = null
-    override fun update(p0: Uri, p1: ContentValues?, p2: String?, p3: Array<out String>?) = 0
-    override fun delete(p0: Uri, p1: String?, p2: Array<out String>?) = 0
-    override fun getType(p0: Uri) = null
-
-}

app/src/main/kotlin/at/bitfire/davdroid/syncadapter/AddressBookSyncer.kt

@@ -1,172 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.Manifest
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.Context
-import android.content.SyncResult
-import android.content.pm.PackageManager
-import android.provider.ContactsContract
-import androidx.core.content.ContextCompat
-import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.Service
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.util.setAndVerifyUserData
-import dagger.hilt.EntryPoint
-import dagger.hilt.InstallIn
-import dagger.hilt.android.EntryPointAccessors
-import dagger.hilt.components.SingletonComponent
-import okhttp3.HttpUrl
-import okhttp3.HttpUrl.Companion.toHttpUrl
-import java.util.logging.Level
-
-/**
- * Sync logic for address books
- */
-class AddressBookSyncer(
-    context: Context
-) : Syncer(context) {
-
-    @EntryPoint
-    @InstallIn(SingletonComponent::class)
-    interface AddressBooksSyncAdapterEntryPoint {
-        fun settingsManager(): SettingsManager
-    }
-
-    companion object {
-        const val PREVIOUS_GROUP_METHOD = "previous_group_method"
-    }
-
-    val entryPoint = EntryPointAccessors.fromApplication(context, AddressBooksSyncAdapterEntryPoint::class.java)
-    val settingsManager = entryPoint.settingsManager()
-
-
-    override fun sync(
-        account: Account,
-        extras: Array<String>,
-        authority: String,                      // address book authority (not contacts authority)
-        httpClient: Lazy<HttpClient>,
-        provider: ContentProviderClient,        // for noop address book provider (not for contacts provider)
-        syncResult: SyncResult
-    ) {
-        if (updateLocalAddressBooks(account, syncResult)) {
-            context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.use { contactsProvider ->
-                for (addressBookAccount in LocalAddressBook.findAll(context, null, account).map { it.account }) {
-                    Logger.log.info("Synchronizing address book $addressBookAccount")
-                    syncAddresBook(
-                        addressBookAccount,
-                        extras,
-                        ContactsContract.AUTHORITY,
-                        httpClient,
-                        contactsProvider,
-                        syncResult
-                    )
-                }
-            }
-        }
-    }
-
-    private fun updateLocalAddressBooks(account: Account, syncResult: SyncResult): Boolean {
-        val service = db.serviceDao().getByAccountAndType(account.name, Service.TYPE_CARDDAV)
-
-        val remoteAddressBooks = mutableMapOf<HttpUrl, Collection>()
-        if (service != null)
-            for (collection in db.collectionDao().getByServiceAndSync(service.id))
-                remoteAddressBooks[collection.url] = collection
-
-        if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
-            if (remoteAddressBooks.isEmpty())
-                Logger.log.info("No contacts permission, but no address book selected for synchronization")
-            else
-                Logger.log.warning("No contacts permission, but address books are selected for synchronization")
-            return false
-        }
-
-        context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY).use { contactsProvider ->
-            if (contactsProvider == null) {
-                Logger.log.severe("Couldn't access contacts provider")
-                syncResult.databaseError = true
-                return false
-            }
-
-            val forceAllReadOnly = settingsManager.getBoolean(Settings.FORCE_READ_ONLY_ADDRESSBOOKS)
-
-            // delete/update local address books
-            for (addressBook in LocalAddressBook.findAll(context, contactsProvider, account)) {
-                val url = addressBook.url.toHttpUrl()
-                val info = remoteAddressBooks[url]
-                if (info == null) {
-                    Logger.log.log(Level.INFO, "Deleting obsolete local address book", url)
-                    addressBook.delete()
-                } else {
-                    // remote CollectionInfo found for this local collection, update data
-                    try {
-                        Logger.log.log(Level.FINE, "Updating local address book $url", info)
-                        addressBook.update(info, forceAllReadOnly)
-                    } catch (e: Exception) {
-                        Logger.log.log(Level.WARNING, "Couldn't rename address book account", e)
-                    }
-                    // we already have a local address book for this remote collection, don't take into consideration anymore
-                    remoteAddressBooks -= url
-                }
-            }
-
-            // create new local address books
-            for ((_, info) in remoteAddressBooks) {
-                Logger.log.log(Level.INFO, "Adding local address book", info)
-                LocalAddressBook.create(context, contactsProvider, account, info, forceAllReadOnly)
-            }
-        }
-
-        return true
-    }
-
-
-    fun syncAddresBook(
-        account: Account,
-        extras: Array<String>,
-        authority: String,
-        httpClient: Lazy<HttpClient>,
-        provider: ContentProviderClient,
-        syncResult: SyncResult
-    ) {
-        try {
-            val accountSettings = AccountSettings(context, account)
-            val addressBook = LocalAddressBook(context, account, provider)
-
-            // handle group method change
-            val groupMethod = accountSettings.getGroupMethod().name
-            accountSettings.accountManager.getUserData(account, PREVIOUS_GROUP_METHOD)?.let { previousGroupMethod ->
-                if (previousGroupMethod != groupMethod) {
-                    Logger.log.info("Group method changed, deleting all local contacts/groups")
-
-                    // delete all local contacts and groups so that they will be downloaded again
-                    provider.delete(addressBook.syncAdapterURI(ContactsContract.RawContacts.CONTENT_URI), null, null)
-                    provider.delete(addressBook.syncAdapterURI(ContactsContract.Groups.CONTENT_URI), null, null)
-
-                    // reset sync state
-                    addressBook.syncState = null
-                }
-            }
-            accountSettings.accountManager.setAndVerifyUserData(account, PREVIOUS_GROUP_METHOD, groupMethod)
-
-            Logger.log.info("Synchronizing address book: ${addressBook.url}")
-            Logger.log.info("Taking settings from: ${addressBook.mainAccount}")
-
-            ContactsSyncManager(context, account, accountSettings, httpClient.value, extras, authority, syncResult, provider, addressBook).performSync()
-        } catch(e: Exception) {
-            Logger.log.log(Level.SEVERE, "Couldn't sync contacts", e)
-        }
-        Logger.log.info("Contacts sync complete")
-    }
-
-}

app/src/main/kotlin/at/bitfire/davdroid/syncadapter/BaseSyncWorker.kt

@@ -1,353 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.content.ContentResolver
-import android.content.Context
-import android.content.Intent
-import android.content.SyncResult
-import android.net.ConnectivityManager
-import android.net.wifi.WifiManager
-import android.provider.CalendarContract
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.core.content.getSystemService
-import androidx.work.CoroutineWorker
-import androidx.work.Data
-import androidx.work.WorkInfo
-import androidx.work.WorkManager
-import androidx.work.WorkQuery
-import androidx.work.WorkerParameters
-import at.bitfire.davdroid.InvalidAccountException
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.network.ConnectionUtils
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.NotificationUtils.notifyIfPossible
-import at.bitfire.davdroid.ui.account.WifiPermissionsActivity
-import at.bitfire.davdroid.util.PermissionUtils
-import at.bitfire.ical4android.TaskProvider
-import kotlinx.coroutines.CoroutineDispatcher
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.flow.Flow
-import kotlinx.coroutines.flow.map
-import kotlinx.coroutines.runInterruptible
-import kotlinx.coroutines.withContext
-import java.util.Collections
-import java.util.logging.Level
-
-abstract class BaseSyncWorker(
-    appContext: Context,
-    private val workerParams: WorkerParameters,
-    private val syncDispatcher: CoroutineDispatcher,
-) : CoroutineWorker(appContext, workerParams) {
-
-    companion object {
-
-        // common worker input parameters
-        const val INPUT_ACCOUNT_NAME = "accountName"
-        const val INPUT_ACCOUNT_TYPE = "accountType"
-        const val INPUT_AUTHORITY = "authority"
-
-        /** set to true for user-initiated sync that skips network checks */
-        const val INPUT_MANUAL = "manual"
-
-        /**
-         * How often this work will be retried to run after soft (network) errors.
-         *
-         * Retry strategy is defined in work request ([enqueue]).
-         */
-        internal const val MAX_RUN_ATTEMPTS = 5
-
-        /**
-         * Set of currently running syncs, identified by their [commonTag].
-         */
-        private val runningSyncs = Collections.synchronizedSet(HashSet<String>())
-
-        /**
-         * Stops running sync workers and removes pending sync workers from queue, for all authorities.
-         */
-        fun cancelAllWork(context: Context, account: Account) {
-            val workManager = WorkManager.getInstance(context)
-            for (authority in SyncUtils.syncAuthorities(context)) {
-                workManager.cancelUniqueWork(OneTimeSyncWorker.workerName(account, authority))
-                workManager.cancelUniqueWork(PeriodicSyncWorker.workerName(account, authority))
-            }
-        }
-
-        /**
-         * This tag shall be added to every worker that is enqueued by a subclass.
-         */
-        fun commonTag(account: Account, authority: String): String =
-            "sync-$authority ${account.type}/${account.name}"
-
-        /**
-         * Observes whether >0 sync workers (both [PeriodicSyncWorker] and [OneTimeSyncWorker])
-         * exist, belonging to given account and authorities, and which are/is in the given worker state.
-         *
-         * @param workStates   list of states of workers to match
-         * @param account      the account which the workers belong to
-         * @param authorities  type of sync work, ie [CalendarContract.AUTHORITY]
-         * @param whichTag     function to generate tag that should be observed for given account and authority
-         *
-         * @return flow that emits `true` if at least one worker with matching query was found; `false` otherwise
-         */
-        fun exists(
-            context: Context,
-            workStates: List<WorkInfo.State>,
-            account: Account? = null,
-            authorities: List<String>? = null,
-            whichTag: (account: Account, authority: String) -> String = { account, authority ->
-                commonTag(account, authority)
-            }
-        ): Flow<Boolean> {
-            val workQuery = WorkQuery.Builder.fromStates(workStates)
-            if (account != null && authorities != null)
-                workQuery.addTags(
-                    authorities.map { authority -> whichTag(account, authority) }
-                )
-            return WorkManager.getInstance(context)
-                .getWorkInfosFlow(workQuery.build())
-                .map { workInfoList ->
-                    workInfoList.isNotEmpty()
-                }
-        }
-
-        /**
-         * Checks whether user imposed sync conditions from settings are met:
-         * - Sync only on WiFi?
-         * - Sync only on specific WiFi (SSID)?
-         *
-         * @param accountSettings Account settings of the account to check (and is to be synced)
-         * @return *true* if conditions are met; *false* if not
-         */
-        fun wifiConditionsMet(context: Context, accountSettings: AccountSettings): Boolean {
-            // May we sync without WiFi?
-            if (!accountSettings.getSyncWifiOnly())
-                return true     // yes, continue
-
-            // WiFi required, is it available?
-            val connectivityManager = context.getSystemService<ConnectivityManager>()!!
-            if (!ConnectionUtils.wifiAvailable(connectivityManager)) {
-                Logger.log.info("Not on connected WiFi, stopping")
-                return false
-            }
-            // If execution reaches this point, we're on a connected WiFi
-
-            // Check whether we are connected to the correct WiFi (in case SSID was provided)
-            return correctWifiSsid(context, accountSettings)
-        }
-
-        /**
-         * Checks whether we are connected to the correct wifi (SSID) defined by user in the
-         * account settings.
-         *
-         * Note: Should be connected to some wifi before calling.
-         *
-         * @param accountSettings Settings of account to check
-         * @return *true* if connected to the correct wifi OR no wifi names were specified in
-         * account settings; *false* otherwise
-         */
-        internal fun correctWifiSsid(context: Context, accountSettings: AccountSettings): Boolean {
-            accountSettings.getSyncWifiOnlySSIDs()?.let { onlySSIDs ->
-                // check required permissions and location status
-                if (!PermissionUtils.canAccessWifiSsid(context)) {
-                    // not all permissions granted; show notification
-                    val intent = Intent(context, WifiPermissionsActivity::class.java)
-                    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                    intent.putExtra(WifiPermissionsActivity.EXTRA_ACCOUNT, accountSettings.account)
-                    PermissionUtils.notifyPermissions(context, intent)
-
-                    Logger.log.warning("Can't access WiFi SSID, aborting sync")
-                    return false
-                }
-
-                val wifi = context.getSystemService<WifiManager>()!!
-                val info = wifi.connectionInfo
-                if (info == null || !onlySSIDs.contains(info.ssid.trim('"'))) {
-                    Logger.log.info("Connected to wrong WiFi network (${info.ssid}), aborting sync")
-                    return false
-                }
-                Logger.log.fine("Connected to WiFi network ${info.ssid}")
-            }
-            return true
-        }
-
-    }
-
-
-    private val notificationManager = NotificationManagerCompat.from(applicationContext)
-
-
-    override suspend fun doWork(): Result {
-        // ensure we got the required arguments
-        val account = Account(
-            inputData.getString(INPUT_ACCOUNT_NAME) ?: throw IllegalArgumentException("$INPUT_ACCOUNT_NAME required"),
-            inputData.getString(INPUT_ACCOUNT_TYPE) ?: throw IllegalArgumentException("$INPUT_ACCOUNT_TYPE required")
-        )
-        val authority = inputData.getString(INPUT_AUTHORITY) ?: throw IllegalArgumentException("$INPUT_AUTHORITY required")
-
-        val syncTag = commonTag(account, authority)
-        Logger.log.info("${javaClass.simpleName} called for $syncTag")
-
-        if (!runningSyncs.add(syncTag)) {
-            Logger.log.info("There's already another worker running for $syncTag, skipping")
-            return Result.success()
-        }
-
-        try {
-            val accountSettings = try {
-                AccountSettings(applicationContext, account)
-            } catch (e: InvalidAccountException) {
-                val workId = workerParams.id
-                Logger.log.warning("Account $account doesn't exist anymore, cancelling worker $workId")
-
-                val workManager = WorkManager.getInstance(applicationContext)
-                workManager.cancelWorkById(workId)
-
-                return Result.failure()
-            }
-
-            if (inputData.getBoolean(INPUT_MANUAL, false))
-                Logger.log.info("Manual sync, skipping network checks")
-            else {
-                // check internet connection
-                val ignoreVpns = accountSettings.getIgnoreVpns()
-                val connectivityManager = applicationContext.getSystemService<ConnectivityManager>()!!
-                if (!ConnectionUtils.internetAvailable(connectivityManager, ignoreVpns)) {
-                    Logger.log.info("WorkManager started SyncWorker without Internet connection. Aborting.")
-                    return Result.success()
-                }
-
-                // check WiFi restriction
-                if (!wifiConditionsMet(applicationContext, accountSettings)) {
-                    Logger.log.info("WiFi conditions not met. Won't run periodic sync.")
-                    return Result.success()
-                }
-            }
-
-            return doSyncWork(account, authority, accountSettings)
-        } finally {
-            Logger.log.info("${javaClass.simpleName} finished for $syncTag")
-            runningSyncs -= syncTag
-        }
-    }
-
-    open suspend fun doSyncWork(
-        account: Account,
-        authority: String,
-        accountSettings: AccountSettings
-    ): Result = withContext(syncDispatcher) {
-        Logger.log.info("Running ${javaClass.name}: account=$account, authority=$authority")
-
-        // What are we going to sync? Select syncer based on authority
-        val syncer: Syncer = when (authority) {
-            applicationContext.getString(R.string.address_books_authority) ->
-                AddressBookSyncer(applicationContext)
-            CalendarContract.AUTHORITY ->
-                CalendarSyncer(applicationContext)
-            TaskProvider.ProviderName.JtxBoard.authority ->
-                JtxSyncer(applicationContext)
-            TaskProvider.ProviderName.OpenTasks.authority,
-            TaskProvider.ProviderName.TasksOrg.authority ->
-                TaskSyncer(applicationContext)
-            else ->
-                throw IllegalArgumentException("Invalid authority $authority")
-        }
-
-        // pass possibly supplied flags to the selected syncer
-        val extras = mutableListOf<String>()
-        when (inputData.getInt(OneTimeSyncWorker.ARG_RESYNC, OneTimeSyncWorker.NO_RESYNC)) {
-            OneTimeSyncWorker.RESYNC ->      extras.add(Syncer.SYNC_EXTRAS_RESYNC)
-            OneTimeSyncWorker.FULL_RESYNC -> extras.add(Syncer.SYNC_EXTRAS_FULL_RESYNC)
-        }
-        if (inputData.getBoolean(OneTimeSyncWorker.ARG_UPLOAD, false))
-            // Comes in through SyncAdapterService and is used only by ContactsSyncManager for an Android 7 workaround.
-            extras.add(ContentResolver.SYNC_EXTRAS_UPLOAD)
-
-        // acquire ContentProviderClient of authority to be synced
-        try {
-            applicationContext.contentResolver.acquireContentProviderClient(authority)
-        } catch (e: SecurityException) {
-            Logger.log.log(Level.WARNING, "Missing permissions to acquire ContentProviderClient for $authority", e)
-            null
-        }.use { provider ->
-            if (provider == null) {
-                Logger.log.warning("Couldn't acquire ContentProviderClient for $authority")
-                return@withContext Result.failure()
-            }
-
-            val result = SyncResult()
-            // Start syncing. We still use the sync adapter framework's SyncResult to pass the sync results, but this
-            // is only for legacy reasons and can be replaced by an own result class in the future.
-            runInterruptible {
-                syncer.onPerformSync(account, extras.toTypedArray(), authority, provider, result)
-            }
-
-            // Check for errors
-            if (result.hasError()) {
-                val syncResult = Data.Builder()
-                    .putString("syncresult", result.toString())
-                    .putString("syncResultStats", result.stats.toString())
-                    .build()
-
-                val softErrorNotificationTag = account.type + "-" + account.name + "-" + authority
-
-                // On soft errors the sync is retried a few times before considered failed
-                if (result.hasSoftError()) {
-                    Logger.log.warning("Soft error while syncing: result=$result, stats=${result.stats}")
-                    if (runAttemptCount < MAX_RUN_ATTEMPTS) {
-                        val blockDuration = result.delayUntil - System.currentTimeMillis() / 1000
-                        Logger.log.warning("Waiting for $blockDuration seconds, before retrying ...")
-
-                        // We block the SyncWorker here so that it won't be started by the sync framework immediately again.
-                        // This should be replaced by proper work scheduling as soon as we don't depend on the sync framework anymore.
-                        if (blockDuration > 0)
-                            delay(blockDuration * 1000)
-
-                        Logger.log.warning("Retrying on soft error (attempt $runAttemptCount of $MAX_RUN_ATTEMPTS)")
-                        return@withContext Result.retry()
-                    }
-
-                    Logger.log.warning("Max retries on soft errors reached ($runAttemptCount of $MAX_RUN_ATTEMPTS). Treating as failed")
-
-                    notificationManager.notifyIfPossible(
-                        softErrorNotificationTag,
-                        NotificationUtils.NOTIFY_SYNC_ERROR,
-                        NotificationUtils.newBuilder(applicationContext, NotificationUtils.CHANNEL_SYNC_IO_ERRORS)
-                            .setSmallIcon(R.drawable.ic_sync_problem_notify)
-                            .setContentTitle(account.name)
-                            .setContentText(applicationContext.getString(R.string.sync_error_retry_limit_reached))
-                            .setSubText(account.name)
-                            .setOnlyAlertOnce(true)
-                            .setPriority(NotificationCompat.PRIORITY_MIN)
-                            .setCategory(NotificationCompat.CATEGORY_ERROR)
-                            .build()
-                    )
-
-                    return@withContext Result.failure(syncResult)
-                }
-
-                // If no soft error found, dismiss sync error notification
-                notificationManager.cancel(
-                    softErrorNotificationTag,
-                    NotificationUtils.NOTIFY_SYNC_ERROR
-                )
-
-                // On a hard error - fail with an error message
-                // Note: SyncManager should have notified the user
-                if (result.hasHardError()) {
-                    Logger.log.warning("Hard error while syncing: result=$result, stats=${result.stats}")
-                    return@withContext Result.failure(syncResult)
-                }
-            }
-        }
-
-        return@withContext Result.success()
-    }
-
-}