Updated name, package and color

Signed-off-by: Arnau Mora Gras <arnyminerz@proton.me>

.github/ISSUE_TEMPLATE/qualified-bug.yml

@@ -0,0 +1,43 @@
+name: Qualified Bug Report
+description: "[Developers only] For qualified bug reports. (Use Discussions if unsure.)"
+labels: ["bug"]
+body:
+  - type: checkboxes
+    attributes:
+      label: Problem scope
+      description: Use Discussions if you're unsure which component (DAVx⁵, calendar app, server, …) causes your problem.
+      options:
+        - label: I'm sure that this is a DAVx⁵ problem.
+          required: true
+  - type: checkboxes
+    attributes:
+      label: App version
+      options:
+        - label: I'm using the latest available DAVx⁵ version.
+          required: true
+  - type: input
+    attributes:
+      label: Android version and device/firmware type
+      placeholder: "Android 13 (Samsung A32)"
+  - type: textarea
+    attributes:
+      label: Steps to reproduce
+      description: Provide detailed steps to reproduce the problem.
+      placeholder: |
+        1. Create DAVx⁵ account with Some Server (Version).
+        2. Sync Some Calendar.
+        3. SomeException appears.
+  - type: textarea
+    attributes:
+      label: Actual result
+      description: Describe what you DAVx⁵ currently does (and what is not expected).
+      placeholder: "Some Property in ICS file causes the whole synchronization to stop."
+  - type: textarea
+    attributes:
+      label: Expected result
+      description: Describe what you would expect DAVx⁵ to avoid/solve the problem.
+      placeholder: "Some Property in ICS file should be ignored even if faulty and sync should continue instead of showing an error."
+  - type: textarea
+    attributes:
+      label: Further info
+      description: Debug info, links to further information, …

.github/ISSUE_TEMPLATE/qualified-feature.yml

@@ -0,0 +1,19 @@
+name: Qualified Feature Request
+description: "[Developers only] For qualified feature requests. (Use Discussions if unsure.)"
+labels: ["enhancement"]
+body:
+  - type: checkboxes
+    attributes:
+      label: Scope
+      description: Use this form only for features that have been discussed in Discussions or if you're a DAVx5 developer.
+      options:
+        - label: I'm sure that this feature request belongs here and not into Discussions.
+          required: true
+  - type: textarea
+    attributes:
+      label: Description
+      description: Describe the requested feature and why it is desired.
+  - type: textarea
+    attributes:
+      label: Further info
+      description: How this could be implemented, links to further information, …

.github/pull_request_template.md

@@ -0,0 +1,38 @@
+
+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/)
+
+
+### Purpose
+
+What this PR is intended to do and why this is desirable.
+
+Example: 
+
+> Adds support for AAA in BBB, as requested by several people in issue #XX.
+
+
+### Short description
+
+A short description of the chosen approach to achieve the purpose.
+
+Example:
+
+> - Added authentication option _Some authentication_ to _some module_.
+> - Added support for _Some authentication_ to _some content provider_.
+> - Added UI support for _Some authentication_ in account settings.
+
+Related information (links to Android docs and other resources that help to understand/review
+the changes) can also be put here.
+
+
+### Checklist
+
+- [ ] The PR has a proper title, description and label.
+- [ ] I have [self-reviewed the PR](https://patrickdinh.medium.com/review-your-own-pull-requests-5634cad10b7a).
+- [ ] I have added documentation to complex functions and functions that can be used by other modules.
+- [ ] I have added reasonable tests or consciously decided to not add tests.
+

.github/release.yml

@@ -0,0 +1,20 @@
+changelog:
+  exclude:
+    labels:
+      - ignore-for-release
+  categories:
+    - title: New features
+      labels:
+        - enhancement
+    - title: Bug fixes
+      labels:
+        - bug
+    - title: Refactoring
+      labels:
+        - refactoring
+    - title: Dependencies
+      labels:
+        - dependencies
+    - title: Other changes
+      labels:
+        - "*"

.github/workflows/codeql.yml

@@ -2,14 +2,14 @@ name: "CodeQL"
 
 on:
   push:
-    branches: [ "dev-ose", main-ose ]
+    branches: [ main-ose ]
   pull_request:
     # The branches below must be a subset of the branches above
-    branches: [ "dev-ose" ]
+    branches: [ main-ose ]
   schedule:
     - cron: '22 10 * * 1'
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: codeql-${{ github.ref }}
   cancel-in-progress: true
 
 jobs:
@@ -28,18 +28,19 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v3
+      uses: actions/checkout@v4
+    - uses: actions/setup-java@v4
       with:
-        submodules: recursive
-    - uses: actions/setup-java@v3
+        distribution: temurin
+        java-version: 21
+    - uses: gradle/actions/setup-gradle@v3
       with:
-        distribution: 'temurin'
-        java-version: 17
-    - uses: gradle/gradle-build-action@v2
+        cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+        cache-read-only: true         # gradle user home cache is generated by test jobs
 
     # Initializes the CodeQL tools for scanning.
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
+      uses: github/codeql-action/init@v3
       with:
         languages: ${{ matrix.language }}
 
@@ -49,9 +50,9 @@ jobs:
     #  uses: github/codeql-action/autobuild@v2
 
     - name: Build
-      run: ./gradlew --no-daemon app:assembleOseDebug
+      run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn --no-daemon app:assembleOseDebug
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2
+      uses: github/codeql-action/analyze@v3
       with:
         category: "/language:${{matrix.language}}"

.github/workflows/dependent-issues.yml

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

@@ -3,31 +3,35 @@ on:
   push:
     tags:
       - v*
+
 concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
+  group: release-${{ github.ref }}
   cancel-in-progress: true
+
+env:
+  prerelease: ${{ contains(github.ref_name, '-alpha') || contains(github.ref_name, '-beta') || contains(github.ref_name, '-rc') }}
+
 jobs:
   build:
     name: Create release
     permissions:
       contents: write
+      discussions: write
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - uses: actions/setup-java@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: 17
-      - uses: gradle/gradle-build-action@v2
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v3
 
       - name: Prepare keystore
         run: echo ${{ secrets.android_keystore_base64 }} | base64 -d >$GITHUB_WORKSPACE/keystore.jks
+
       - name: Build signed package
-        # --no-configuration-cache is only required for AboutLibraries (bitfireAT/davx5#263, mikepenz/AboutLibraries#857)
-        # Remove it as soon as AboutLibraries is compatbile with the gradle configuration cache.
-        run: ./gradlew --no-configuration-cache --no-daemon app:assembleRelease
+        # Make sure that caches are disabled to generate reproducible release builds
+        run: ./gradlew --no-build-cache --no-configuration-cache --no-daemon app:assembleRelease
         env:
           ANDROID_KEYSTORE: ${{ github.workspace }}/keystore.jks
           ANDROID_KEYSTORE_PASSWORD: ${{ secrets.android_keystore_password }}
@@ -35,8 +39,10 @@ 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: ${{ contains(github.ref_name, '-alpha') || contains(github.ref_name, '-beta') || contains(github.ref_name, '-rc') }}
+          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

@@ -1,48 +1,69 @@
 name: Development tests
-on: [push, pull_request]
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-jobs:
+on:
+  push:
+    branches:
+      - '*'
 
-  test:
-    name: Tests without emulator
+concurrency:
+  group: test-dev-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  compile:
+    name: Compile for build cache
+    if: ${{ github.ref == 'refs/heads/main-ose' }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - uses: actions/setup-java@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: 17
-      - uses: gradle/gradle-build-action@v2
+          java-version: 21
 
-      - name: Run lint and unit tests
-        run: ./gradlew app:check
-      - name: Archive results
-        uses: actions/upload-artifact@v2
+      # See https://community.gradle.org/github-actions/docs/setup-gradle/ for more information
+      - uses: gradle/actions/setup-gradle@v3            # creates build cache when on main branch
         with:
-          name: test-results
-          path: |
-            app/build/outputs/lint*
-            app/build/reports
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          dependency-graph: generate-and-submit         # submit Github Dependency Graph info
+
+      - run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:compileOseDebugSource
+
+  test:
+    needs: compile
+    if: ${{ always() }}     # even if compile didn't run (because not on main branch)
+    name: Lint and unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v3
+        with:
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          cache-read-only: true
+
+      - name: Run lint
+        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:lintOseDebug
+      - name: Run unit tests
+        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:testOseDebugUnitTest
 
   test_on_emulator:
-    name: Tests with emulator
-    runs-on: ubuntu-latest-4-cores
-    strategy:
-      matrix:
-        api-level: [ 31 ]
+    needs: compile
+    if: ${{ always() }}     # even if compile didn't run (because not on main branch)
+    name: Instrumented tests
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - uses: actions/setup-java@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: 17
-      - uses: gradle/gradle-build-action@v2
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v3
+        with:
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          cache-read-only: true
 
       - name: Enable KVM group perms
         run: |
@@ -50,40 +71,11 @@ jobs:
           sudo udevadm control --reload-rules
           sudo udevadm trigger --name-match=kvm
 
-      - name: Cache AVD and APKs
-        uses: actions/cache@v3
-        id: avd-cache
+      - name: Cache AVD
+        uses: actions/cache@v4
         with:
-          path: |
-            ~/.android/avd/*
-            ~/.android/adb*
-          key: avd-${{ matrix.api-level }}
+          path: ~/.config/.android/avd
+          key: avd-${{ hashFiles('app/build.gradle.kts') }}   # gradle-managed devices are defined there
 
-      - name: Create AVD and generate snapshot for caching
-        if: steps.avd-cache.outputs.cache-hit != 'true'
-        uses: reactivecircus/android-emulator-runner@v2
-        with:
-          api-level: ${{ matrix.api-level }}
-          arch: x86_64
-          force-avd-creation: false
-          emulator-options: -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
-          disable-animations: false
-          script: echo "Generated AVD snapshot for caching."
-
-      - name: Run tests
-        uses: reactivecircus/android-emulator-runner@v2
-        with:
-          api-level: ${{ matrix.api-level }}
-          arch: x86_64
-          force-avd-creation: false
-          emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -camera-back none
-          disable-animations: true
-          script: ./gradlew app:connectedCheck
-
-      - name: Archive results
-        if: always()
-        uses: actions/upload-artifact@v2
-        with:
-          name: test-results
-          path: |
-            app/build/reports
+      - name: Run device tests
+        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:virtualCheck

.gitignore

@@ -8,8 +8,9 @@
 # Files for the Dalvik VM
 *.dex
 
-# Java class files
+# Java/Kotlin
 *.class
+.kotlin/
 
 # Generated files
 bin/

.gitmodules

@@ -1,6 +0,0 @@
-[submodule "ical4android"]
-	path = ical4android
-	url = https://github.com/bitfireAT/ical4android.git
-[submodule "vcard4android"]
-	path = vcard4android
-	url = https://github.com/bitfireAT/vcard4android.git

.tx/config

@@ -1,6 +1,6 @@
 [main]
 host     = https://www.transifex.com
-lang_map = ar_SA: ar, en_GB: en-rGB, es_MX: es-rMX, fa_IR: fa-rIR, fi_FI: fi, fr_FR: fr-rFR, nb_NO: nb, pt_BR: pt-rBR, sk_SK: sk, sl_SI: sl, sv_SE: sv-rSE, tr_TR: tr, zh_CN: zh, zh_TW: zh-rTW
+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

README.md

@@ -1,8 +1,8 @@
 
 [![Website](https://img.shields.io/website?style=flat-square&up_color=%237cb342&url=https%3A%2F%2Fwww.davx5.com)](https://www.davx5.com/)
-[![Twitter](https://img.shields.io/twitter/follow/davx5app?color=%237cb342&label=%40davx5app&style=flat-square)](https://twitter.com/davx5app)
 [![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)
 
 ![DAVx⁵ logo](app/src/main/res/mipmap-xxxhdpi/ic_launcher.png)
@@ -12,14 +12,13 @@ DAVx⁵
 ========
 
 Please see the [DAVx⁵ Web site](https://www.davx5.com) for
-comprehensive information about DAVx⁵.
+comprehensive information about DAVx⁵, including a list of services it has been tested with.
 
 DAVx⁵ is licensed under the [GPLv3 License](LICENSE).
 
 News and updates: 
 
 * [@davx5app@fosstodon.org](https://fosstodon.org/@davx5app) on Mastodon
-* [@davx5app](https://twitter.com/davx5app) on Twitter
 
 **Help, feature requests, bug reports: [DAVx⁵ discussions](https://github.com/bitfireAT/davx5-ose/discussions)**
 
@@ -43,3 +42,5 @@ The most important libraries which are used by DAVx⁵ (alphabetically):
 * [ez-vcard](https://github.com/mangstadt/ez-vcard) – [New BSD License](https://github.com/mangstadt/ez-vcard/blob/master/LICENSE)
 * [iCal4j](https://github.com/ical4j/ical4j) – [New BSD License](https://github.com/ical4j/ical4j/blob/develop/LICENSE.txt)
 * [okhttp](https://square.github.io/okhttp) – [Apache License, Version 2.0](https://square.github.io/okhttp/#license)
+
+See _About / Libraries_ in the app for all used libraries and their licenses.

app/build.gradle

@@ -1,198 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-apply plugin: 'com.android.application'
-apply plugin: 'com.mikepenz.aboutlibraries.plugin'
-apply plugin: 'dagger.hilt.android.plugin'
-apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-kapt'
-
-// Android configuration
-android {
-    compileSdkVersion 33
-    buildToolsVersion '33.0.2'
-
-    defaultConfig {
-        applicationId "at.bitfire.davdroid"
-
-        versionCode 403040000
-        versionName '4.3.4'
-
-        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
-
-        setProperty "archivesBaseName", "davx5-ose-" + getVersionName()
-
-        minSdkVersion 21        // Android 5
-        targetSdkVersion 33     // Android 13
-
-        buildConfigField "String", "userAgent", "\"DAVx5\""
-
-        manifestPlaceholders = [
-            'appAuthRedirectScheme': applicationId
-        ]
-
-        testInstrumentationRunner "at.bitfire.davdroid.CustomTestRunner"
-
-        kapt {
-            arguments {
-                arg("room.schemaLocation", "$projectDir/schemas")
-            }
-        }
-    }
-
-    compileOptions {
-        // enable because ical4android requires desugaring
-        coreLibraryDesugaringEnabled true
-
-        sourceCompatibility JavaVersion.VERSION_17
-        targetCompatibility JavaVersion.VERSION_17
-    }
-
-    buildFeatures {
-        buildConfig = true
-        compose = true
-        viewBinding = true
-        dataBinding = true
-    }
-    composeOptions {
-        // Keep this in sync with Kotlin version:
-        // https://developer.android.com/jetpack/androidx/releases/compose-kotlin
-        kotlinCompilerExtensionVersion = "1.4.7"
-    }
-
-    // Java namespace for our classes (not to be confused with Android package ID)
-    namespace 'at.bitfire.davdroid'
-
-    flavorDimensions "distribution"
-    productFlavors {
-        ose {
-            versionNameSuffix "-ose"
-        }
-    }
-
-    sourceSets {
-        androidTest.java.srcDirs = [ "src/androidTest/java" ]
-        androidTest.assets.srcDirs += files("$projectDir/schemas".toString())
-    }
-
-    signingConfigs {
-        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")
-        }
-    }
-
-    buildTypes {
-        debug {
-        }
-        release {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules-release.pro'
-
-            shrinkResources true
-
-            signingConfig signingConfigs.bitfire
-        }
-    }
-
-    lint {
-        disable 'GoogleAppIndexingWarning', 'ImpliedQuantity', 'MissingQuantity', 'MissingTranslation', 'ExtraTranslation', 'RtlEnabled', 'RtlHardcoded', 'Typos', 'NullSafeMutableLiveData'
-    }
-
-    packagingOptions {
-        resources {
-            excludes += ['META-INF/*.md']
-        }
-    }
-}
-
-dependencies {
-    implementation "com.github.bitfireAT:cert4android:${versions.cert4android}"
-    implementation project(':ical4android')
-    implementation project(':vcard4android')
-
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin}"
-    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1"
-    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.3'
-
-    implementation "com.google.dagger:hilt-android:${versions.hilt}"
-    kapt "com.google.dagger:hilt-android-compiler:${versions.hilt}"
-
-    implementation 'androidx.appcompat:appcompat:1.6.1'
-    implementation 'androidx.browser:browser:1.5.0'
-    implementation 'androidx.cardview:cardview:1.0.0'
-    implementation 'androidx.concurrent:concurrent-futures-ktx:1.1.0'
-    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
-    implementation 'androidx.core:core-ktx:1.10.1'
-    implementation 'androidx.fragment:fragment-ktx:1.6.0'
-    implementation 'androidx.hilt:hilt-work:1.0.0'
-    kapt 'androidx.hilt:hilt-compiler:1.0.0'
-    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
-    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.6.1'
-    implementation 'androidx.paging:paging-runtime-ktx:3.1.1'
-    implementation 'androidx.preference:preference-ktx:1.2.0'
-    implementation 'androidx.security:security-crypto:1.1.0-alpha06'
-    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
-    implementation 'androidx.work:work-runtime-ktx:2.8.1'
-    implementation 'com.google.android.flexbox:flexbox:3.0.0'
-    implementation 'com.google.android.material:material:1.9.0'
-    implementation 'net.openid:appauth:0.11.1'
-
-    // Jetpack Compose
-    def composeBom = platform("androidx.compose:compose-bom:${versions.composeBom}")
-    implementation composeBom
-    androidTestImplementation composeBom
-    implementation 'androidx.compose.material:material'
-    implementation 'androidx.compose.runtime:runtime-livedata'
-    debugImplementation 'androidx.compose.ui:ui-tooling'
-    implementation 'androidx.compose.ui:ui-tooling-preview'
-    implementation 'com.google.accompanist:accompanist-themeadapter-material:0.30.1'
-
-    // Jetpack Room
-    implementation "androidx.room:room-runtime:${versions.room}"
-    implementation "androidx.room:room-ktx:${versions.room}"
-    implementation "androidx.room:room-paging:${versions.room}"
-    kapt "androidx.room:room-compiler:${versions.room}"
-    androidTestImplementation "androidx.room:room-testing:${versions.room}"
-
-    // third-party libs
-    implementation 'com.jaredrummler:colorpicker:1.1.0'
-    implementation "com.github.AppIntro:AppIntro:${versions.appIntro}"
-    implementation("com.github.bitfireAT:dav4jvm:${versions.dav4jvm}") {
-        exclude group: 'junit'
-    }
-    implementation "com.mikepenz:aboutlibraries-compose:${versions.aboutLibraries}"
-    implementation "com.squareup.okhttp3:okhttp:${versions.okhttp}"
-    implementation "com.squareup.okhttp3:okhttp-brotli:${versions.okhttp}"
-    implementation "com.squareup.okhttp3:logging-interceptor:${versions.okhttp}"
-    //noinspection GradleDependency - don't update until API level 26 (Android 8) is the minimum API [https://github.com/bitfireAT/davx5/issues/130]
-    implementation 'commons-io:commons-io:2.8.0'
-    //noinspection GradleDependency - dnsjava 3+ needs Java 8/Android 7
-    implementation 'dnsjava:dnsjava:2.1.9'
-    //noinspection GradleDependency
-    implementation "org.apache.commons:commons-collections4:${versions.commonsCollections}"
-    //noinspection GradleDependency
-    implementation "org.apache.commons:commons-lang3:${versions.commonsLang}"
-    //noinspection GradleDependency
-    implementation "org.apache.commons:commons-text:${versions.commonsText}"
-
-    // for tests
-    androidTestImplementation "com.google.dagger:hilt-android-testing:${versions.hilt}"
-    kaptAndroidTest "com.google.dagger:hilt-android-compiler:${versions.hilt}"
-
-    androidTestImplementation "androidx.arch.core:core-testing:2.2.0"
-    androidTestImplementation 'androidx.test:core-ktx:1.5.0'
-    androidTestImplementation 'androidx.test:runner:1.5.2'
-    androidTestImplementation 'androidx.test:rules:1.5.0'
-    androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.5'
-    androidTestImplementation 'androidx.work:work-testing:2.8.1'
-    androidTestImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
-    androidTestImplementation 'io.mockk:mockk-android:1.13.4'
-    androidTestImplementation 'junit:junit:4.13.2'
-
-    testImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
-    testImplementation 'junit:junit:4.13.2'
-}

app/build.gradle.kts

@@ -0,0 +1,219 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+plugins {
+    alias(libs.plugins.mikepenz.aboutLibraries)
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.ksp)
+}
+
+// Android configuration
+android {
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = "at.bitfire.davdroid"
+
+        versionCode = 404030200
+        versionName = "4.4.3.2"
+
+        setProperty("archivesBaseName", "davx5-ose-$versionName")
+
+        minSdk = 24        // Android 7.0
+        targetSdk = 35     // Android 15
+
+        testInstrumentationRunner = "at.bitfire.davdroid.HiltTestRunner"
+    }
+
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(21)
+        }
+    }
+
+    compileOptions {
+        // required for
+        // - dnsjava 3.x: java.nio.file.Path
+        // - ical4android: time API
+        isCoreLibraryDesugaringEnabled = true
+    }
+
+    buildFeatures {
+        buildConfig = true
+        compose = true
+    }
+
+    // Java namespace for our classes (not to be confused with Android package ID)
+    namespace = "at.bitfire.davdroid"
+
+    flavorDimensions += "distribution"
+    productFlavors {
+        create("ose") {
+            dimension = "distribution"
+            versionNameSuffix = "-ose"
+        }
+    }
+
+    sourceSets {
+        getByName("androidTest") {
+            assets.srcDir("$projectDir/schemas")
+        }
+    }
+
+    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")
+        }
+    }
+
+    buildTypes {
+        getByName("release") {
+            isMinifyEnabled = true
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules-release.pro")
+
+            isShrinkResources = true
+
+            signingConfig = signingConfigs.findByName("bitfire")
+        }
+        getByName("debug") {
+            applicationIdSuffix = ".debug"
+        }
+    }
+
+    lint {
+        disable += arrayOf("GoogleAppIndexingWarning", "ImpliedQuantity", "MissingQuantity", "MissingTranslation", "ExtraTranslation", "RtlEnabled", "RtlHardcoded", "Typos", "NullSafeMutableLiveData")
+    }
+
+    packaging {
+        resources {
+            excludes += arrayOf("META-INF/*.md")
+        }
+    }
+
+    androidResources {
+        generateLocaleConfig = true
+    }
+
+    @Suppress("UnstableApiUsage")
+    testOptions {
+        managedDevices {
+            localDevices {
+                create("virtual") {
+                    device = "Pixel 3"
+                    apiLevel = 34
+                    systemImageSource = "aosp-atd"
+                }
+            }
+        }
+    }
+}
+
+ksp {
+    arg("room.schemaLocation", "$projectDir/schemas")
+}
+
+aboutLibraries {
+    excludeFields = arrayOf("generated")
+}
+
+configurations {
+    configureEach {
+        // exclude modules which are in conflict with system libraries
+        exclude(module="commons-logging")
+        exclude(group="org.json", module="json")
+
+        // Groovy requires SDK 26+, and it's not required, so exclude it
+        exclude(group="org.codehaus.groovy")
+    }
+}
+
+dependencies {
+    // core
+    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.activityCompose)
+    implementation(libs.androidx.appcompat)
+    implementation(libs.androidx.browser)
+    implementation(libs.androidx.core)
+    implementation(libs.androidx.hilt.navigation.compose)
+    implementation(libs.androidx.hilt.work)
+    implementation(libs.androidx.lifecycle.runtime.compose)
+    implementation(libs.androidx.lifecycle.viewmodel.base)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.paging)
+    implementation(libs.androidx.paging.compose)
+    implementation(libs.androidx.preference)
+    implementation(libs.androidx.security)
+    implementation(libs.androidx.work.base)
+
+    // Jetpack Compose
+    implementation(libs.compose.accompanist.permissions)
+    implementation(platform(libs.compose.bom))
+    implementation(libs.compose.material3)
+    implementation(libs.compose.materialIconsExtended)
+    implementation(libs.compose.runtime.livedata)
+    debugImplementation(libs.compose.ui.tooling)
+    implementation(libs.compose.ui.toolingPreview)
+
+    // Glance Widgets
+    implementation(libs.glance.base)
+    implementation(libs.glance.material)
+
+    // Jetpack Room
+    implementation(libs.room.runtime)
+    implementation(libs.room.base)
+    implementation(libs.room.paging)
+    ksp(libs.room.compiler)
+
+    // own libraries
+    implementation(libs.bitfire.cert4android)
+    implementation(libs.bitfire.dav4jvm) {
+        exclude(group="junit")
+    }
+    implementation(libs.bitfire.ical4android)
+    implementation(libs.bitfire.vcard4android)
+
+    // third-party libs
+    @Suppress("RedundantSuppression")
+    implementation(libs.dnsjava)
+    implementation(libs.guava)
+    implementation(libs.mikepenz.aboutLibraries)
+    implementation(libs.nsk90.kstatemachine)
+    implementation(libs.okhttp.base)
+    implementation(libs.okhttp.brotli)
+    implementation(libs.okhttp.logging)
+    implementation(libs.openid.appauth)
+    implementation(libs.unifiedpush)
+
+    // for tests
+    androidTestImplementation(libs.androidx.arch.core.testing)
+    androidTestImplementation(libs.androidx.test.core)
+    androidTestImplementation(libs.androidx.test.junit)
+    androidTestImplementation(libs.androidx.test.rules)
+    androidTestImplementation(libs.androidx.test.runner)
+    androidTestImplementation(libs.androidx.work.testing)
+    androidTestImplementation(libs.hilt.android.testing)
+    androidTestImplementation(libs.junit)
+    androidTestImplementation(libs.mockk.android)
+    androidTestImplementation(libs.okhttp.mockwebserver)
+    androidTestImplementation(libs.room.testing)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.mockk)
+    testImplementation(libs.okhttp.mockwebserver)
+}

app/proguard-rules-release.pro

@@ -2,6 +2,7 @@
 # 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
@@ -21,6 +22,9 @@
 # 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();
@@ -30,18 +34,27 @@
 # 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.xbill.DNS.spi.DnsjavaInetAddressResolverProvider      # dnsjava
 -dontwarn org.xmlpull.**
 -dontwarn sun.net.spi.nameservice.NameService
 -dontwarn sun.net.spi.nameservice.NameServiceDescriptor

app/schemas/at.bitfire.davdroid.db.AppDatabase/13.json

@@ -0,0 +1,640 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 13,
+    "identityHash": "0a6a9705ff471acd766ab96e3edf8ac3",
+    "entities": [
+      {
+        "tableName": "service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `accountName` TEXT NOT NULL, `type` TEXT NOT NULL, `principal` TEXT)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accountName",
+            "columnName": "accountName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "principal",
+            "columnName": "principal",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_service_accountName_type` ON `${TABLE_NAME}` (`accountName`, `type`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "homeset",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `personal` INTEGER NOT NULL, `url` TEXT NOT NULL, `privBind` INTEGER NOT NULL, `displayName` TEXT, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "personal",
+            "columnName": "personal",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privBind",
+            "columnName": "privBind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_homeset_serviceId_url` ON `${TABLE_NAME}` (`serviceId`, `url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "collection",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `homeSetId` INTEGER, `ownerId` INTEGER, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, `pushTopic` TEXT, `supportsWebPush` INTEGER NOT NULL DEFAULT 0, `pushSubscription` TEXT, `pushSubscriptionCreated` INTEGER, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`homeSetId`) REFERENCES `homeset`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL , FOREIGN KEY(`ownerId`) REFERENCES `principal`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "homeSetId",
+            "columnName": "homeSetId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "ownerId",
+            "columnName": "ownerId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privWriteContent",
+            "columnName": "privWriteContent",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privUnbind",
+            "columnName": "privUnbind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "forceReadOnly",
+            "columnName": "forceReadOnly",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "timezone",
+            "columnName": "timezone",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVEVENT",
+            "columnName": "supportsVEVENT",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVTODO",
+            "columnName": "supportsVTODO",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVJOURNAL",
+            "columnName": "supportsVJOURNAL",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "source",
+            "columnName": "source",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "sync",
+            "columnName": "sync",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pushTopic",
+            "columnName": "pushTopic",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsWebPush",
+            "columnName": "supportsWebPush",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "pushSubscription",
+            "columnName": "pushSubscription",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "pushSubscriptionCreated",
+            "columnName": "pushSubscriptionCreated",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_serviceId_type` ON `${TABLE_NAME}` (`serviceId`, `type`)"
+          },
+          {
+            "name": "index_collection_homeSetId_type",
+            "unique": false,
+            "columnNames": [
+              "homeSetId",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          },
+          {
+            "name": "index_collection_url",
+            "unique": false,
+            "columnNames": [
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_url` ON `${TABLE_NAME}` (`url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "homeset",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "homeSetId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "principal",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "ownerId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "principal",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `url` TEXT NOT NULL, `displayName` TEXT, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_principal_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_principal_serviceId_url` ON `${TABLE_NAME}` (`serviceId`, `url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "syncstats",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `collectionId` INTEGER NOT NULL, `authority` TEXT NOT NULL, `lastSync` INTEGER NOT NULL, FOREIGN KEY(`collectionId`) REFERENCES `collection`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "collectionId",
+            "columnName": "collectionId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "authority",
+            "columnName": "authority",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastSync",
+            "columnName": "lastSync",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_syncstats_collectionId_authority",
+            "unique": true,
+            "columnNames": [
+              "collectionId",
+              "authority"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_syncstats_collectionId_authority` ON `${TABLE_NAME}` (`collectionId`, `authority`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "collection",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "collectionId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "webdav_document",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `mountId` INTEGER NOT NULL, `parentId` INTEGER, `name` TEXT NOT NULL, `isDirectory` INTEGER NOT NULL, `displayName` TEXT, `mimeType` TEXT, `eTag` TEXT, `lastModified` INTEGER, `size` INTEGER, `mayBind` INTEGER, `mayUnbind` INTEGER, `mayWriteContent` INTEGER, `quotaAvailable` INTEGER, `quotaUsed` INTEGER, FOREIGN KEY(`mountId`) REFERENCES `webdav_mount`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`parentId`) REFERENCES `webdav_document`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "mountId",
+            "columnName": "mountId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parentId",
+            "columnName": "parentId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isDirectory",
+            "columnName": "isDirectory",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mimeType",
+            "columnName": "mimeType",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "eTag",
+            "columnName": "eTag",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "lastModified",
+            "columnName": "lastModified",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "size",
+            "columnName": "size",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mayBind",
+            "columnName": "mayBind",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mayUnbind",
+            "columnName": "mayUnbind",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mayWriteContent",
+            "columnName": "mayWriteContent",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "quotaAvailable",
+            "columnName": "quotaAvailable",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "quotaUsed",
+            "columnName": "quotaUsed",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_webdav_document_mountId_parentId_name",
+            "unique": true,
+            "columnNames": [
+              "mountId",
+              "parentId",
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_webdav_document_mountId_parentId_name` ON `${TABLE_NAME}` (`mountId`, `parentId`, `name`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "webdav_mount",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "mountId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "webdav_document",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "parentId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "webdav_mount",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `url` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '0a6a9705ff471acd766ab96e3edf8ac3')"
+    ]
+  }
+}

app/schemas/at.bitfire.davdroid.db.AppDatabase/14.json

@@ -0,0 +1,669 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 14,
+    "identityHash": "9a0eb47f27473eab254db568081a4585",
+    "entities": [
+      {
+        "tableName": "service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `accountName` TEXT NOT NULL, `type` TEXT NOT NULL, `principal` TEXT)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accountName",
+            "columnName": "accountName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "principal",
+            "columnName": "principal",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_service_accountName_type` ON `${TABLE_NAME}` (`accountName`, `type`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "homeset",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `personal` INTEGER NOT NULL, `url` TEXT NOT NULL, `privBind` INTEGER NOT NULL, `displayName` TEXT, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "personal",
+            "columnName": "personal",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privBind",
+            "columnName": "privBind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_homeset_serviceId_url` ON `${TABLE_NAME}` (`serviceId`, `url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "collection",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `homeSetId` INTEGER, `ownerId` INTEGER, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, `pushTopic` TEXT, `supportsWebPush` INTEGER NOT NULL DEFAULT 0, `pushSubscription` TEXT, `pushSubscriptionCreated` INTEGER, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`homeSetId`) REFERENCES `homeset`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL , FOREIGN KEY(`ownerId`) REFERENCES `principal`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "homeSetId",
+            "columnName": "homeSetId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "ownerId",
+            "columnName": "ownerId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privWriteContent",
+            "columnName": "privWriteContent",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privUnbind",
+            "columnName": "privUnbind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "forceReadOnly",
+            "columnName": "forceReadOnly",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "timezone",
+            "columnName": "timezone",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVEVENT",
+            "columnName": "supportsVEVENT",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVTODO",
+            "columnName": "supportsVTODO",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVJOURNAL",
+            "columnName": "supportsVJOURNAL",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "source",
+            "columnName": "source",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "sync",
+            "columnName": "sync",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "pushTopic",
+            "columnName": "pushTopic",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsWebPush",
+            "columnName": "supportsWebPush",
+            "affinity": "INTEGER",
+            "notNull": true,
+            "defaultValue": "0"
+          },
+          {
+            "fieldPath": "pushSubscription",
+            "columnName": "pushSubscription",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "pushSubscriptionCreated",
+            "columnName": "pushSubscriptionCreated",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_serviceId_type` ON `${TABLE_NAME}` (`serviceId`, `type`)"
+          },
+          {
+            "name": "index_collection_homeSetId_type",
+            "unique": false,
+            "columnNames": [
+              "homeSetId",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          },
+          {
+            "name": "index_collection_ownerId_type",
+            "unique": false,
+            "columnNames": [
+              "ownerId",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_ownerId_type` ON `${TABLE_NAME}` (`ownerId`, `type`)"
+          },
+          {
+            "name": "index_collection_pushTopic_type",
+            "unique": false,
+            "columnNames": [
+              "pushTopic",
+              "type"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_pushTopic_type` ON `${TABLE_NAME}` (`pushTopic`, `type`)"
+          },
+          {
+            "name": "index_collection_url",
+            "unique": false,
+            "columnNames": [
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_url` ON `${TABLE_NAME}` (`url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "homeset",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "homeSetId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "principal",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "ownerId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "principal",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `url` TEXT NOT NULL, `displayName` TEXT, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_principal_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_principal_serviceId_url` ON `${TABLE_NAME}` (`serviceId`, `url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "syncstats",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `collectionId` INTEGER NOT NULL, `authority` TEXT NOT NULL, `lastSync` INTEGER NOT NULL, FOREIGN KEY(`collectionId`) REFERENCES `collection`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "collectionId",
+            "columnName": "collectionId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "authority",
+            "columnName": "authority",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastSync",
+            "columnName": "lastSync",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_syncstats_collectionId_authority",
+            "unique": true,
+            "columnNames": [
+              "collectionId",
+              "authority"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_syncstats_collectionId_authority` ON `${TABLE_NAME}` (`collectionId`, `authority`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "collection",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "collectionId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "webdav_document",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `mountId` INTEGER NOT NULL, `parentId` INTEGER, `name` TEXT NOT NULL, `isDirectory` INTEGER NOT NULL, `displayName` TEXT, `mimeType` TEXT, `eTag` TEXT, `lastModified` INTEGER, `size` INTEGER, `mayBind` INTEGER, `mayUnbind` INTEGER, `mayWriteContent` INTEGER, `quotaAvailable` INTEGER, `quotaUsed` INTEGER, FOREIGN KEY(`mountId`) REFERENCES `webdav_mount`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`parentId`) REFERENCES `webdav_document`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "mountId",
+            "columnName": "mountId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "parentId",
+            "columnName": "parentId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "isDirectory",
+            "columnName": "isDirectory",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mimeType",
+            "columnName": "mimeType",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "eTag",
+            "columnName": "eTag",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "lastModified",
+            "columnName": "lastModified",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "size",
+            "columnName": "size",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mayBind",
+            "columnName": "mayBind",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mayUnbind",
+            "columnName": "mayUnbind",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "mayWriteContent",
+            "columnName": "mayWriteContent",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "quotaAvailable",
+            "columnName": "quotaAvailable",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "quotaUsed",
+            "columnName": "quotaUsed",
+            "affinity": "INTEGER",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [
+          {
+            "name": "index_webdav_document_mountId_parentId_name",
+            "unique": true,
+            "columnNames": [
+              "mountId",
+              "parentId",
+              "name"
+            ],
+            "orders": [],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_webdav_document_mountId_parentId_name` ON `${TABLE_NAME}` (`mountId`, `parentId`, `name`)"
+          },
+          {
+            "name": "index_webdav_document_parentId",
+            "unique": false,
+            "columnNames": [
+              "parentId"
+            ],
+            "orders": [],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_webdav_document_parentId` ON `${TABLE_NAME}` (`parentId`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "webdav_mount",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "mountId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "webdav_document",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "parentId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "webdav_mount",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `name` TEXT NOT NULL, `url` TEXT NOT NULL)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "name",
+            "columnName": "name",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "autoGenerate": true,
+          "columnNames": [
+            "id"
+          ]
+        },
+        "indices": [],
+        "foreignKeys": []
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '9a0eb47f27473eab254db568081a4585')"
+    ]
+  }
+}

app/src/androidTest/AndroidManifest.xml

@@ -7,4 +7,21 @@
     <uses-permission android:name="android.permission.GET_ACCOUNTS" android:maxSdkVersion="22"/>
     <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" android:maxSdkVersion="22"/>
 
-</manifest>
+    <application>
+
+        <!-- test account type (without associated sync adapters) -->
+        <service
+            android:name="at.bitfire.davdroid.sync.account.TestAccountAuthenticator"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.accounts.AccountAuthenticator"
+                android:resource="@xml/test_account_authenticator"/>
+        </service>
+
+    </application>
+
+</manifest>

app/src/androidTest/java/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/java/at/bitfire/davdroid/MockingModule.kt

@@ -1,31 +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.settings.SettingsManager
-import dagger.Module
-import dagger.Provides
-import dagger.hilt.android.qualifiers.ApplicationContext
-import dagger.hilt.components.SingletonComponent
-import dagger.hilt.testing.TestInstallIn
-import io.mockk.spyk
-import javax.inject.Singleton
-
-@Module
-@TestInstallIn(
-    components = [ SingletonComponent::class ],
-    replaces = [
-        SettingsManager.SettingsManagerModule::class
-    ]
-)
-class MockingModule {
-
-    @Provides
-    @Singleton
-    fun spykSettingsManager(@ApplicationContext context: Context): SettingsManager =
-        spyk(SettingsManager(context))
-
-}

app/src/androidTest/java/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/java/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(value) = throw NotImplementedError()
-
-    override var readOnly: Boolean
-        get() = false
-        set(value) = throw NotImplementedError()
-
-
-    fun clear() {
-        for (contact in queryContacts(null, null))
-            contact.delete()
-        for (group in queryGroups(null, null))
-            group.delete()
-    }
-
-}

app/src/androidTest/java/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/java/at/bitfire/davdroid/settings/SettingsManagerTest.kt

@@ -1,41 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.settings
-
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import javax.inject.Inject
-
-@HiltAndroidTest
-class SettingsManagerTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @Inject lateinit var settingsManager: SettingsManager
-
-    @Before
-    fun inject() {
-        hiltRule.inject()
-    }
-
-
-    @Test
-    fun testContainsKey_NotExisting() {
-        assertFalse(settingsManager.containsKey("notExisting"))
-    }
-
-    @Test
-    fun testContainsKey_Existing() {
-        // provided by DefaultsProvider
-        assertEquals(Settings.PROXY_TYPE_SYSTEM, settingsManager.getInt(Settings.PROXY_TYPE))
-    }
-
-}

app/src/androidTest/java/at/bitfire/davdroid/ui/AppSettingsActivityTest.kt

@@ -1,13 +0,0 @@
-package at.bitfire.davdroid.ui
-
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class AppSettingsActivityTest {
-    @Test
-    fun testResourceQualifierToLanguageTag() {
-        assertEquals("en", AppSettingsActivity.resourceQualifierToLanguageTag("en"))
-        assertEquals("en-GB", AppSettingsActivity.resourceQualifierToLanguageTag("en-GB"))
-        assertEquals("en-GB", AppSettingsActivity.resourceQualifierToLanguageTag("en-rGB"))
-    }
-}

app/src/androidTest/java/at/bitfire/davdroid/ui/setup/AccountDetailsFragmentTest.kt

@@ -1,212 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.ui.setup
-
-import android.accounts.AccountManager
-import android.content.ContentResolver
-import android.content.Context
-import android.provider.CalendarContract
-import android.util.Log
-import androidx.annotation.RequiresApi
-import androidx.arch.core.executor.testing.InstantTaskExecutorRule
-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.getOrAwaitValue
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.resource.TaskUtils
-import at.bitfire.davdroid.servicedetection.DavResourceFinder
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.ical4android.TaskProvider
-import at.bitfire.vcard4android.GroupMethod
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.mockk.*
-import org.junit.*
-import org.junit.Assert.*
-import javax.inject.Inject
-
-@HiltAndroidTest
-class AccountDetailsFragmentTest {
-
-    @get:Rule
-    var hiltRule = HiltAndroidRule(this)
-
-    @get:Rule
-    var instantTaskExecutorRule = InstantTaskExecutorRule()     // required for TestUtils: LiveData.getOrAwaitValue()
-
-
-    @Inject
-    lateinit var db: AppDatabase
-    @Inject
-    lateinit var settingsManager: SettingsManager
-
-    private val targetContext: Context = InstrumentationRegistry.getInstrumentation().targetContext
-    private val fakeCredentials = Credentials("test", "test")
-
-    @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(targetContext)
-
-        // Initialize WorkManager for instrumentation tests.
-        val config = Configuration.Builder()
-            .setMinimumLoggingLevel(Log.DEBUG)
-            .build()
-        WorkManagerTestInitHelper.initializeTestWorkManager(targetContext, config)
-    }
-
-    @After
-    fun tearDown() {
-        // Remove accounts created by tests
-        val am = AccountManager.get(targetContext)
-        val accounts = am.getAccountsByType(targetContext.getString(R.string.account_type))
-        for (account in accounts) {
-            am.removeAccountExplicitly(account)
-        }
-    }
-
-
-    @Test
-    fun testModel_CreateAccount_configuresContactsAndCalendars() {
-        val accountName = "MyAccountName"
-        val emptyServiceInfo = DavResourceFinder.Configuration.ServiceInfo()
-        val config = DavResourceFinder.Configuration(emptyServiceInfo, emptyServiceInfo, false, "")
-
-        // Create account -> should also set sync interval in settings
-        val accountCreated = AccountDetailsFragment.Model(targetContext, db, settingsManager)
-            .createAccount(accountName, fakeCredentials, config, GroupMethod.GROUP_VCARDS)
-        assertTrue(accountCreated.getOrAwaitValue(5))
-
-        // Get the created account
-        val account = AccountManager.get(targetContext)
-            .getAccountsByType(targetContext.getString(R.string.account_type))
-            .first { account -> account.name == accountName }
-
-        for (authority in listOf(
-            targetContext.getString(R.string.address_books_authority),
-            CalendarContract.AUTHORITY,
-        )) {
-            // Check isSyncable was set
-            assertEquals(1, ContentResolver.getIsSyncable(account, authority))
-
-            // Check default sync interval was set for
-            // [AccountSettings.KEY_SYNC_INTERVAL_ADDRESSBOOKS],
-            // [AccountSettings.KEY_SYNC_INTERVAL_CALENDARS]
-            assertEquals(
-                settingsManager.getLong(Settings.DEFAULT_SYNC_INTERVAL),
-                AccountSettings(targetContext, account).getSyncInterval(authority)
-            )
-        }
-    }
-
-    @Test
-    @RequiresApi(28)        // for mockkObject
-    fun testModel_CreateAccount_configuresCalendarsWithTasks() {
-        for (provider in listOf(
-            TaskProvider.ProviderName.JtxBoard,
-            TaskProvider.ProviderName.OpenTasks,
-            TaskProvider.ProviderName.TasksOrg
-        )) {
-            val accountName = "testAccount-$provider"
-            val emptyServiceInfo = DavResourceFinder.Configuration.ServiceInfo()
-            val config = DavResourceFinder.Configuration(emptyServiceInfo, emptyServiceInfo, false, "")
-
-            // Mock TaskUtils currentProvider method, pretending that one of the task apps is installed :)
-            mockkObject(TaskUtils)
-            every { TaskUtils.currentProvider(targetContext) } returns provider
-            assertEquals(provider, TaskUtils.currentProvider(targetContext))
-
-            // Create account -> should also set tasks sync interval in settings
-            val accountCreated =
-                AccountDetailsFragment.Model(targetContext, db, settingsManager)
-                    .createAccount(accountName, fakeCredentials, config, GroupMethod.GROUP_VCARDS)
-            assertTrue(accountCreated.getOrAwaitValue(5))
-
-            // Get the created account
-            val account = AccountManager.get(targetContext)
-                .getAccountsByType(targetContext.getString(R.string.account_type))
-                .first { account -> account.name == accountName }
-
-            // Calendar: Check isSyncable and default interval are set correctly
-            assertEquals(1, ContentResolver.getIsSyncable(account, CalendarContract.AUTHORITY))
-            assertEquals(
-                settingsManager.getLong(Settings.DEFAULT_SYNC_INTERVAL),
-                AccountSettings(targetContext, account).getSyncInterval(CalendarContract.AUTHORITY)
-            )
-
-            // Tasks: Check isSyncable and default sync interval were set
-            assertEquals(1, ContentResolver.getIsSyncable(account, provider.authority))
-            assertEquals(
-                settingsManager.getLong(Settings.DEFAULT_SYNC_INTERVAL),
-                AccountSettings(targetContext, account).getSyncInterval(provider.authority)
-            )
-        }
-    }
-
-    @Test
-    @RequiresApi(28)
-    fun testModel_CreateAccount_configuresCalendarsWithoutTasks() {
-        val accountName = "testAccount"
-        val emptyServiceInfo = DavResourceFinder.Configuration.ServiceInfo()
-        val config = DavResourceFinder.Configuration(emptyServiceInfo, emptyServiceInfo, false, "")
-
-        // Mock TaskUtils currentProvider method, pretending that no task app is installed
-        mockkObject(TaskUtils)
-        every { TaskUtils.currentProvider(targetContext) } returns null
-        assertEquals(null, TaskUtils.currentProvider(targetContext))
-
-        // Mock static ContentResolver calls
-        // TODO: Should not be needed, see below
-        mockkStatic(ContentResolver::class)
-        every { ContentResolver.setIsSyncable(any(), any(), any()) } returns Unit
-        every { ContentResolver.getIsSyncable(any(), any()) } returns 1
-
-        // Create account -> should also set tasks sync interval in settings
-        val accountCreated = AccountDetailsFragment.Model(targetContext, db, settingsManager)
-            .createAccount(accountName, fakeCredentials, config, GroupMethod.GROUP_VCARDS)
-        assertTrue(accountCreated.getOrAwaitValue(5))
-
-        // Get the created account
-        val account = AccountManager.get(targetContext)
-            .getAccountsByType(targetContext.getString(R.string.account_type))
-            .first { account -> account.name == accountName }
-        val accountSettings = AccountSettings(targetContext, account)
-
-        // Calendar: Check automatic sync is enabled and default interval are set correctly
-        assertEquals(1, ContentResolver.getIsSyncable(account, CalendarContract.AUTHORITY))
-        assertEquals(
-            settingsManager.getLong(Settings.DEFAULT_SYNC_INTERVAL),
-            accountSettings.getSyncInterval(CalendarContract.AUTHORITY)
-        )
-
-        // Tasks: Check isSyncable state is unknown (=-1) and sync interval is "unset" (=null)
-        for (authority in listOf(
-            TaskProvider.ProviderName.JtxBoard.authority,
-            TaskProvider.ProviderName.OpenTasks.authority,
-            TaskProvider.ProviderName.TasksOrg.authority
-        )) {
-            // Until below is fixed, just verify the method for enabling sync did not get called
-            verify(exactly = 0) { ContentResolver.setIsSyncable(account, authority, 1) }
-
-            // TODO: Flaky, returns 1, although it should not. It only returns -1 if the test is run
-            //  alone, on a blank emulator and if it's the first test run.
-            //  This seems to have to do with the previous calls to ContentResolver by other tests.
-            //  Finding a a way of resetting the ContentResolver before each test is run should
-            //  solve the issue.
-            //assertEquals(-1, ContentResolver.getIsSyncable(account, authority))
-            //assertNull(accountSettings.getSyncInterval(authority)) // Depends on above
-        }
-    }
-
-}

app/src/androidTest/java/at/bitfire/davdroid/ui/webdav/AddWebdavMountActivityTest.kt

@@ -1,76 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.ui.webdav
-
-import android.security.NetworkSecurityPolicy
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.WebDavMount
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import io.mockk.spyk
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-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 AddWebdavMountActivityTest {
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @Inject
-    lateinit var db: AppDatabase
-
-    @Before
-    fun setUp() {
-        hiltRule.inject()
-
-        model = spyk(AddWebdavMountActivity.Model(InstrumentationRegistry.getInstrumentation().targetContext, db))
-
-        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
-    }
-
-
-    lateinit var model: AddWebdavMountActivity.Model
-    val web = MockWebServer()
-
-    @Test
-    fun testHasWebDav_NoDavHeader() {
-        web.enqueue(MockResponse().setResponseCode(200))
-        assertFalse(model.hasWebDav(WebDavMount(name = "Test", url = web.url("/")), null))
-    }
-
-    @Test
-    fun testHasWebDav_DavClass_1() {
-        web.enqueue(MockResponse()
-            .setResponseCode(200)
-            .addHeader("DAV", "1"))
-        assertTrue(model.hasWebDav(WebDavMount(name = "Test", url = web.url("/")), null))
-    }
-
-    @Test
-    fun testHasWebDav_DavClass_1and2() {
-        web.enqueue(MockResponse()
-            .setResponseCode(200)
-            .addHeader("DAV", "1,2"))
-        assertTrue(model.hasWebDav(WebDavMount(name = "Test", url = web.url("/")), null))
-    }
-
-    @Test
-    fun testHasWebDav_DavClass_2() {
-        web.enqueue(MockResponse()
-            .setResponseCode(200)
-            .addHeader("DAV", "2"))
-        assertTrue(model.hasWebDav(WebDavMount(name = "Test", url = web.url("/")), null))
-    }
-
-}

app/src/androidTest/java/at/bitfire/davdroid/webdav/CredentialsStoreTest.kt

@@ -1,26 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.webdav
-
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.db.Credentials
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-
-class CredentialsStoreTest {
-
-    private val store = CredentialsStore(InstrumentationRegistry.getInstrumentation().targetContext)
-
-    @Test
-    fun testSetGetDelete() {
-        store.setCredentials(0, Credentials(userName = "myname", password = "12345"))
-        assertEquals(Credentials(userName = "myname", password = "12345"), store.getCredentials(0))
-
-        store.setCredentials(0, null)
-        assertNull(store.getCredentials(0))
-    }
-
-}

app/src/androidTest/java/at/bitfire/davdroid/webdav/MemoryCacheTest.kt

@@ -1,78 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.webdav
-
-import at.bitfire.davdroid.webdav.cache.MemoryCache
-import org.apache.commons.io.FileUtils
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.Test
-
-class MemoryCacheTest {
-
-    companion object {
-        val SAMPLE_KEY1 = "key1"
-        val SAMPLE_CONTENT1 = "Sample Content 1".toByteArray()
-        val SAMPLE_CONTENT2 = "Another Content".toByteArray()
-    }
-
-    lateinit var storage: MemoryCache<String>
-
-
-    @Before
-    fun createStorage() {
-        storage = MemoryCache(1*FileUtils.ONE_MB.toInt())
-    }
-
-
-    @Test
-    fun testGet() {
-        // no entry yet, get should return null
-        assertNull(storage.get(SAMPLE_KEY1))
-
-        // add entry
-        storage.getOrPut(SAMPLE_KEY1) { SAMPLE_CONTENT1 }
-        assertArrayEquals(SAMPLE_CONTENT1, storage.get(SAMPLE_KEY1))
-    }
-
-    @Test
-    fun testGetOrPut() {
-        assertNull(storage.get(SAMPLE_KEY1))
-        // no entry yet; SAMPLE_CONTENT1 should be generated
-        var calledGenerateSampleContent1 = false
-        assertArrayEquals(SAMPLE_CONTENT1, storage.getOrPut(SAMPLE_KEY1) {
-            calledGenerateSampleContent1 = true
-            SAMPLE_CONTENT1
-        })
-        assertTrue(calledGenerateSampleContent1)
-        assertNotNull(storage.get(SAMPLE_KEY1))
-
-        // now there's a SAMPLE_CONTENT1 entry, it should be returned while SAMPLE_CONTENT2 is not generated
-        var calledGenerateSampleContent2 = false
-        assertArrayEquals(SAMPLE_CONTENT1, storage.getOrPut(SAMPLE_KEY1) {
-            calledGenerateSampleContent2 = true
-            SAMPLE_CONTENT2
-        })
-        assertFalse(calledGenerateSampleContent2)
-    }
-
-    @Test
-    fun testMaxCacheSize() {
-        // Cache size is 1 MB. Add 11*100 kB -> the first entry should be gone then
-        for (i in 0 until 11) {
-            val key = "key$i"
-            storage.getOrPut(key) {
-                ByteArray(100 * FileUtils.ONE_KB.toInt()) { i.toByte() }
-            }
-            assertNotNull(storage.get(key))
-        }
-
-        // now key0 should have been evicted and only key1..key11 should be there
-        assertNull(storage.get("key0"))
-        for (i in 1 until 11)
-            assertNotNull(storage.get("key$i"))
-    }
-
-}

app/src/androidTest/java/at/bitfire/davdroid/webdav/SegmentedCacheTest.kt

@@ -1,159 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.webdav
-
-import at.bitfire.davdroid.webdav.cache.Cache
-import at.bitfire.davdroid.webdav.cache.SegmentedCache
-import org.apache.commons.io.FileUtils
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Test
-
-class SegmentedCacheTest {
-
-    companion object {
-        const val PAGE_SIZE = 100*FileUtils.ONE_KB.toInt()
-
-        const val SAMPLE_KEY1 = "key1"
-        const val PAGE2_SIZE = 123
-    }
-
-    val noCache = object: Cache<SegmentedCache.SegmentKey<String>> {
-        override fun get(key: SegmentedCache.SegmentKey<String>) = null
-        override fun getOrPut(key: SegmentedCache.SegmentKey<String>, generate: () -> ByteArray) = generate()
-    }
-
-    @Test
-    fun testRead_AcrossPages() {
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int) =
-                when (key.segment) {
-                    0 -> ByteArray(PAGE_SIZE) { 1 }
-                    1 -> ByteArray(PAGE2_SIZE) { 2 }
-                    else -> throw IndexOutOfBoundsException()
-                }
-        }, noCache)
-        val dst = ByteArray(20)
-        assertEquals(20, cache.read(SAMPLE_KEY1, (PAGE_SIZE - 10).toLong(), dst.size, dst))
-        assertArrayEquals(ByteArray(20) { i ->
-            if (i < 10)
-                1
-            else
-                2
-        }, dst)
-    }
-
-    @Test
-    fun testRead_AcrossPagesAndEOF() {
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int) =
-                when (key.segment) {
-                    0 -> ByteArray(PAGE_SIZE) { 1 }
-                    1 -> ByteArray(PAGE2_SIZE) { 2 }
-                    else -> throw IndexOutOfBoundsException()
-                }
-        }, noCache)
-        val dst = ByteArray(10 + PAGE2_SIZE + 10)
-        assertEquals(10 + PAGE2_SIZE, cache.read(SAMPLE_KEY1, (PAGE_SIZE - 10).toLong(), dst.size, dst))
-        assertArrayEquals(ByteArray(10 + PAGE2_SIZE) { i ->
-            if (i < 10)
-                1
-            else
-                2
-        }, dst.copyOf(10 + PAGE2_SIZE))
-    }
-
-    @Test
-    fun testRead_ExactlyPageSize_BufferAlsoPageSize() {
-        var loadCalled = 0
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int): ByteArray {
-                loadCalled++
-                if (key.segment == 0)
-                    return ByteArray(PAGE_SIZE)
-                else
-                    throw IndexOutOfBoundsException()
-            }
-        }, noCache)
-        val dst = ByteArray(PAGE_SIZE)
-        assertEquals(PAGE_SIZE, cache.read(SAMPLE_KEY1, 0, dst.size, dst))
-        assertEquals(1, loadCalled)
-    }
-
-    @Test
-    fun testRead_ExactlyPageSize_ButLargerBuffer() {
-        var loadCalled = 0
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int): ByteArray {
-                loadCalled++
-                if (key.segment == 0)
-                    return ByteArray(PAGE_SIZE)
-                else
-                    throw IndexOutOfBoundsException()
-            }
-        }, noCache)
-        val dst = ByteArray(PAGE_SIZE + 10)     // 10 bytes more so that the second segment is read
-        assertEquals(PAGE_SIZE, cache.read(SAMPLE_KEY1, 0, dst.size, dst))
-        assertEquals(2, loadCalled)
-    }
-
-    @Test
-    fun testRead_Offset() {
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int): ByteArray {
-                if (key.segment == 0)
-                    return ByteArray(PAGE_SIZE) { 1 }
-                else
-                    throw IndexOutOfBoundsException()
-            }
-        }, noCache)
-        val dst = ByteArray(PAGE_SIZE)
-        assertEquals(PAGE_SIZE - 100, cache.read(SAMPLE_KEY1, 100, dst.size, dst))
-        assertArrayEquals(ByteArray(PAGE_SIZE) { i ->
-            if (i < PAGE_SIZE - 100)
-                1
-            else
-                0
-        }, dst)
-    }
-
-    @Test
-    fun testRead_OnlyOnePageSmallerThanPageSize_From0() {
-        val contentSize = 123
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int) =
-                when (key.segment) {
-                    0 -> ByteArray(contentSize) { it.toByte() }
-                    else -> throw IndexOutOfBoundsException()
-                }
-        }, noCache)
-
-        // read less than content size
-        var dst = ByteArray(10)     // 10 < contentSize
-        assertEquals(10, cache.read(SAMPLE_KEY1, 0, dst.size, dst))
-        assertArrayEquals(ByteArray(10) { it.toByte() }, dst)
-
-        // read more than content size
-        dst = ByteArray(1000)       // 1000 > contentSize
-        assertEquals(contentSize, cache.read(SAMPLE_KEY1, 0, dst.size, dst))
-        assertArrayEquals(ByteArray(1000) { i ->
-            if (i < contentSize)
-                i.toByte()
-            else
-                0
-        }, dst)
-    }
-
-    @Test
-    fun testRead_ZeroByteFile() {
-        val cache = SegmentedCache<String>(PAGE_SIZE, object: SegmentedCache.PageLoader<String> {
-            override fun load(key: SegmentedCache.SegmentKey<String>, segmentSize: Int) =
-                throw IndexOutOfBoundsException()
-        }, noCache)
-        val dst = ByteArray(10)
-        assertEquals(0, cache.read(SAMPLE_KEY1, 10, dst.size, dst))
-    }
-
-}

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

@@ -4,6 +4,17 @@
 
 package at.bitfire.davdroid
 
-import android.accounts.Account
+import android.util.Xml
+import at.bitfire.dav4jvm.XmlUtils
+import org.junit.Assert.assertTrue
+import org.junit.Test
 
-class InvalidAccountException(account: Account): Exception("Invalid account: $account")
+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/HiltTestRunner.kt

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

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

@@ -0,0 +1,123 @@
+/*
+ * 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.ContentProviderClient
+import android.content.ContentUris
+import android.content.ContentValues
+import android.os.Build
+import android.provider.CalendarContract
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+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.Assert.assertNotNull
+import org.junit.rules.ExternalResource
+import org.junit.rules.RuleChain
+import java.util.logging.Logger
+
+/**
+ * JUnit ClassRule which initializes the AOSP CalendarProvider.
+ *
+ * It seems that the calendar provider unfortunately forgets the very first requests when it is used the very first time,
+ * maybe by some wrongly synchronized database initialization. So things like querying the instances
+ * fails in this case.
+ *
+ * So this rule is needed to allow tests which need the calendar provider to succeed even when the calendar provider
+ * is used the very first time (especially in CI tests / a fresh emulator).
+ *
+ * See [at.bitfire.davdroid.resource.LocalCalendarTest] for an example of how to use this rule.
+ */
+class InitCalendarProviderRule private constructor(): ExternalResource() {
+
+    companion object {
+
+        private var isInitialized = false
+        private val logger = Logger.getLogger(InitCalendarProviderRule::javaClass.name)
+
+        fun getInstance(): RuleChain = RuleChain
+            .outerRule(GrantPermissionRule.grant(Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR))
+            .around(InitCalendarProviderRule())
+
+    }
+
+    override fun before() {
+        if (!isInitialized) {
+            logger.info("Initializing calendar provider")
+            if (Build.VERSION.SDK_INT < 31)
+                logger.warning("Calendar provider initialization may or may not work. See InitCalendarProviderRule")
+
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+            val client = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)
+            assertNotNull("Couldn't acquire calendar provider", client)
+
+            client!!.use {
+                initCalendarProvider(client)
+                isInitialized = true
+            }
+        }
+    }
+
+    private fun initCalendarProvider(provider: ContentProviderClient) {
+        val account = Account("LocalCalendarTest", CalendarContract.ACCOUNT_TYPE_LOCAL)
+
+        // Sometimes, the calendar provider returns an ID for the created calendar, but then fails to find it.
+        var calendarOrNull: LocalCalendar? = null
+        for (i in 0..50) {
+            calendarOrNull = createAndVerifyCalendar(account, provider)
+            if (calendarOrNull != null)
+                break
+            else
+                Thread.sleep(100)
+        }
+        val calendar = calendarOrNull ?: throw IllegalStateException("Couldn't create calendar")
+
+        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()
+        }
+    }
+
+    private fun createAndVerifyCalendar(account: Account, provider: ContentProviderClient): LocalCalendar? {
+        val uri = AndroidCalendar.create(account, provider, ContentValues())
+
+        return try {
+            AndroidCalendar.findByID(
+                account,
+                provider,
+                LocalCalendar.Factory,
+                ContentUris.parseId(uri)
+            )
+        } catch (e: Exception) {
+            logger.warning("Couldn't find calendar after creation: $e")
+            null
+        }
+    }
+
+}

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

@@ -1,12 +1,13 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid
 
-import androidx.test.platform.app.InstrumentationRegistry
+import android.content.Context
 import at.bitfire.davdroid.network.HttpClient
 import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import okhttp3.Request
@@ -21,6 +22,10 @@ class OkhttpClientTest {
     @get:Rule
     val hiltRule = HiltAndroidRule(this)
 
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
     @Inject
     lateinit var settingsManager: SettingsManager
 
@@ -32,8 +37,7 @@ class OkhttpClientTest {
 
     @Test
     fun testIcloudWithSettings() {
-        val client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
-                .build()
+        val client = HttpClient.Builder(context).build()
         client.okHttpClient.newCall(Request.Builder()
                 .get()
                 .url("https://icloud.com")

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

@@ -0,0 +1,38 @@
+package at.bitfire.davdroid
+
+import at.bitfire.davdroid.push.PushRegistrationWorker
+import at.bitfire.davdroid.repository.DavCollectionRepository
+import at.bitfire.davdroid.startup.StartupPlugin
+import at.bitfire.davdroid.startup.TasksAppWatcher
+import dagger.Module
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import dagger.multibindings.Multibinds
+
+interface TestModules {
+
+    // remove PushRegistrationWorkerModule from Android tests
+    @Module
+    @TestInstallIn(
+        components = [SingletonComponent::class],
+        replaces = [PushRegistrationWorker.PushRegistrationWorkerModule::class]
+    )
+    abstract class TestPushRegistrationWorkerModule {
+        // provides empty set of listeners
+        @Multibinds
+        abstract fun empty(): Set<DavCollectionRepository.OnChangeListener>
+    }
+
+    // remove TasksAppWatcherModule from Android tests
+    @Module
+    @TestInstallIn(
+        components = [SingletonComponent::class],
+        replaces = [TasksAppWatcher.TasksAppWatcherModule::class]
+    )
+    abstract class TestTasksAppWatcherModuleModule {
+        // provides empty set of plugins
+        @Multibinds
+        abstract fun empty(): Set<StartupPlugin>
+    }
+
+}

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid
 
@@ -11,12 +11,22 @@ import androidx.work.WorkInfo
 import androidx.work.WorkManager
 import androidx.work.WorkQuery
 import org.jetbrains.annotations.TestOnly
+import org.junit.Assert.assertTrue
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.TimeoutException
+import kotlin.math.abs
 
 object TestUtils {
 
+    fun assertWithin(expected: Long, actual: Long, tolerance: Long) {
+        val absDifference = abs(expected - actual)
+        assertTrue(
+            "$actual not within ($expected ± $tolerance)",
+            absDifference <= tolerance
+        )
+    }
+
     @TestOnly
     fun workScheduledOrRunning(context: Context, workerName: String): Boolean =
         workInStates(context, workerName, listOf(

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.db
 

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

@@ -1,23 +1,27 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.db
 
+import android.content.Context
 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.ResourceType
+import at.bitfire.dav4jvm.property.webdav.ResourceType
 import at.bitfire.davdroid.network.HttpClient
 import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.qualifiers.ApplicationContext
 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.*
+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
@@ -30,26 +34,26 @@ class CollectionTest {
     @get:Rule
     val hiltRule = HiltAndroidRule(this)
 
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
     @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()
+    fun setup() {
+        hiltRule.inject()
+
+        httpClient = HttpClient.Builder(context).build()
         Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
     }
 
     @After
-    fun shutDown() {
+    fun teardown() {
         httpClient.close()
     }
 

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.db
 

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.network
 
@@ -21,10 +21,10 @@ class Android10ResolverTest {
     @Test
     @SdkSuppress(minSdkVersion = Build.VERSION_CODES.Q)
     fun testResolveA() {
-        val www = InetAddress.getAllByName(FQDN_DAVX5).filterIsInstance(Inet4Address::class.java).first()
+        val www = InetAddress.getAllByName(FQDN_DAVX5).filterIsInstance<Inet4Address>().first()
 
         val srvLookup = Lookup(FQDN_DAVX5, Type.A)
-        srvLookup.setResolver(Android10Resolver)
+        srvLookup.setResolver(Android10Resolver())
         val resultGeneric = srvLookup.run()
         assertEquals(1, resultGeneric.size)
 

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

@@ -0,0 +1,122 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.network
+
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.xbill.DNS.DClass
+import org.xbill.DNS.Name
+import org.xbill.DNS.SRVRecord
+import org.xbill.DNS.TXTRecord
+import javax.inject.Inject
+
+@HiltAndroidTest
+class DnsRecordResolverTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var dnsRecordResolver: DnsRecordResolver
+
+    @Before
+    fun setup() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testBestSRVRecord_Empty() {
+        assertNull(dnsRecordResolver.bestSRVRecord(emptyArray()))
+    }
+
+    @Test
+    fun testBestSRVRecord_MultipleRecords_Priority_Different() {
+        val dns1010 = SRVRecord(
+            Name.fromString("_caldavs._tcp.example.com."),
+            DClass.IN, 3600, 10, 10, 8443, Name.fromString("dav1010.example.com.")
+        )
+        val dns2010 = SRVRecord(
+            Name.fromString("_caldavs._tcp.example.com."),
+            DClass.IN, 3600, 20, 20, 8443, Name.fromString("dav2010.example.com.")
+        )
+
+        // lowest priority first
+        val result = dnsRecordResolver.bestSRVRecord(arrayOf(dns1010, dns2010))
+        assertEquals(dns1010, result)
+    }
+
+    @Test
+    fun testBestSRVRecord_MultipleRecords_Priority_Same() {
+        val dns1010 = SRVRecord(
+            Name.fromString("_caldavs._tcp.example.com."),
+            DClass.IN, 3600, 10, 10, 8443, Name.fromString("dav1010.example.com.")
+        )
+        val dns1020 = SRVRecord(
+            Name.fromString("_caldavs._tcp.example.com."),
+            DClass.IN, 3600, 10, 20, 8443, Name.fromString("dav1020.example.com.")
+        )
+
+        // entries are selected randomly (for load balancing)
+        // run 1000 times to get a good distribution
+        val counts = IntArray(2)
+        for (i in 0 until 1000) {
+            val result = dnsRecordResolver.bestSRVRecord(arrayOf(dns1010, dns1020))
+
+            when (result) {
+                dns1010 -> counts[0]++
+                dns1020 -> counts[1]++
+            }
+        }
+
+        /* We had weights 10 and 20, so the distribution of 1000 tries should be roughly
+            weight 10   fraction 1/3   expected count 333   binomial distribution (p=1/3) with 99.99% in [275..393]
+            weight 20   fraction 2/3   expected count 667   binomial distribution (p=2/3) with 99.99% in [607..725]
+         */
+        assertTrue(counts[0] in 275..393)
+        assertTrue(counts[1] in 607..725)
+    }
+
+    @Test
+    fun testBestSRVRecord_OneRecord() {
+        val dns1010 = SRVRecord(
+            Name.fromString("_caldavs._tcp.example.com."),
+            DClass.IN, 3600, 10, 10, 8443, Name.fromString("dav1010.example.com.")
+        )
+        val result = dnsRecordResolver.bestSRVRecord(arrayOf(dns1010))
+        assertEquals(dns1010, result)
+    }
+
+
+    @Test
+    fun testPathsFromTXTRecords_Empty() {
+        assertTrue(dnsRecordResolver.pathsFromTXTRecords(arrayOf()).isEmpty())
+    }
+
+    @Test
+    fun testPathsFromTXTRecords_OnePath() {
+        val result = dnsRecordResolver.pathsFromTXTRecords(arrayOf(
+            TXTRecord(Name.fromString("example.com."), 0, 0L, listOf("something=else", "path=/path1"))
+        )).toTypedArray()
+        assertArrayEquals(arrayOf("/path1"), result)
+    }
+
+    @Test
+    fun testPathsFromTXTRecords_TwoPaths() {
+        val result = dnsRecordResolver.pathsFromTXTRecords(arrayOf(
+            TXTRecord(Name.fromString("example.com."), 0, 0L, listOf("path=/path1", "something-else", "path=/path2"))
+        )).toTypedArray()
+        result.sort()
+        assertArrayEquals(arrayOf("/path1", "/path2"), result)
+    }
+
+}

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

@@ -1,11 +1,12 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.network
 
+import android.content.Context
 import android.security.NetworkSecurityPolicy
-import androidx.test.platform.app.InstrumentationRegistry
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import okhttp3.Request
@@ -14,10 +15,12 @@ import okhttp3.mockwebserver.MockWebServer
 import org.junit.After
 import org.junit.Assert.assertEquals
 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 HttpClientTest {
@@ -28,11 +31,15 @@ class HttpClientTest {
     @get:Rule
     var hiltRule = HiltAndroidRule(this)
 
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
     @Before
     fun setUp() {
         hiltRule.inject()
 
-        httpClient = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build()
+        httpClient = HttpClient.Builder(context).build()
 
         server = MockWebServer()
         server.start(30000)
@@ -70,7 +77,8 @@ class HttpClientTest {
         httpClient.okHttpClient.newCall(Request.Builder()
                 .get().url(url)
                 .build()).execute()
-        assertEquals("cookie2=2; cookie1=1", server.takeRequest().getHeader("Cookie"))
+        val header = server.takeRequest().getHeader("Cookie")
+        assertTrue(header == "cookie1=1; cookie2=2" || header == "cookie2=2; cookie1=1")
 
         server.enqueue(MockResponse()
                 .setResponseCode(200))

app/src/androidTest/kotlin/at/bitfire/davdroid/repository/DavCollectionRepositoryTest.kt

@@ -0,0 +1,88 @@
+package at.bitfire.davdroid.repository
+
+import android.content.Context
+import at.bitfire.davdroid.db.AppDatabase
+import at.bitfire.davdroid.db.Collection
+import at.bitfire.davdroid.db.Service
+import at.bitfire.davdroid.settings.AccountSettings
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.mockk
+import io.mockk.verify
+import kotlinx.coroutines.runBlocking
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class DavCollectionRepositoryTest {
+
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var accountSettingsFactory: AccountSettings.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var db: AppDatabase
+
+    @Inject
+    lateinit var serviceRepository: DavServiceRepository
+
+    var service: Service? = null
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+        service = createTestService(Service.TYPE_CARDDAV)!!
+    }
+
+    @After
+    fun cleanUp() {
+        db.close()
+        serviceRepository.deleteAll()
+    }
+
+
+    @Test
+    fun testOnChangeListener_setForceReadOnly() = runBlocking {
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                serviceId = service!!.id,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = "https://example.com".toHttpUrl(),
+                forceReadOnly = false,
+            )
+        )
+        val testObserver = mockk<DavCollectionRepository.OnChangeListener>(relaxed = true)
+        val collectionRepository = DavCollectionRepository(accountSettingsFactory, context, db, mutableSetOf(testObserver), serviceRepository)
+
+        assert(db.collectionDao().get(collectionId)?.forceReadOnly == false)
+        verify(exactly = 0) {
+            testObserver.onCollectionsChanged()
+        }
+        collectionRepository.setForceReadOnly(collectionId, true)
+        assert(db.collectionDao().get(collectionId)?.forceReadOnly == true)
+        verify(exactly = 1) {
+            testObserver.onCollectionsChanged()
+        }
+    }
+
+
+    // Test helpers and dependencies
+
+    private fun createTestService(serviceType: String) : Service? {
+        val service = Service(id=0, accountName="test", type=serviceType, principal = null)
+        val serviceId = serviceRepository.insertOrReplace(service)
+        return serviceRepository.get(serviceId)
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/repository/DavHomeSetRepositoryTest.kt

@@ -1,13 +1,14 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
-package at.bitfire.davdroid.db
+package at.bitfire.davdroid.repository
 
+import at.bitfire.davdroid.db.HomeSet
+import at.bitfire.davdroid.db.Service
 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
@@ -15,67 +16,63 @@ import org.junit.Test
 import javax.inject.Inject
 
 @HiltAndroidTest
-class HomesetDaoTest {
+class DavHomeSetRepositoryTest {
 
     @get:Rule
     var hiltRule = HiltAndroidRule(this)
 
     @Inject
-    lateinit var db: AppDatabase
+    lateinit var repository: DavHomeSetRepository
+
+    @Inject
+    lateinit var serviceRepository: DavServiceRepository
 
     @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)
+        val insertId1 = repository.insertOrUpdateByUrl(entry1)
         assertEquals(1L, insertId1)
-        assertEquals(entry1.apply { id = 1L }, homeSetDao.getById(1L))
+        assertEquals(entry1.apply { id = 1L }, repository.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)
+        val updateId1 = repository.insertOrUpdateByUrl(updatedEntry1)
         assertEquals(1L, updateId1)
-        assertEquals(updatedEntry1.apply { id = 1L }, homeSetDao.getById(1L))
+        assertEquals(updatedEntry1.apply { id = 1L }, repository.getById(1L))
 
         val entry2 = HomeSet(id=0, serviceId=serviceId, personal=true, url= "https://example.com/2".toHttpUrl())
-        val insertId2 = homeSetDao.insertOrUpdateByUrl(entry2)
+        val insertId2 = repository.insertOrUpdateByUrl(entry2)
         assertEquals(2L, insertId2)
-        assertEquals(entry2.apply { id = 2L }, homeSetDao.getById(2L))
+        assertEquals(entry2.apply { id = 2L }, repository.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)
+        val insertId1 = repository.insertOrUpdateByUrl(entry1)
         assertEquals(1L, insertId1)
-        assertEquals(entry1, homesetDao.getById(1L))
+        assertEquals(entry1, repository.getById(1L))
 
-        homesetDao.delete(entry1)
-
-        assertEquals(null, homesetDao.getById(1L))
+        repository.delete(entry1)
+        assertEquals(null, repository.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)
+
+    private fun createTestService() : Long {
+        val service = Service(id=0, accountName="test", type= Service.TYPE_CALDAV, principal = null)
+        return serviceRepository.insertOrReplace(service)
     }
 
 }

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

@@ -0,0 +1,151 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.resource
+
+import android.Manifest
+import android.accounts.Account
+import android.content.ContentProviderClient
+import android.content.ContentUris
+import android.content.Context
+import android.provider.ContactsContract
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.GroupMethod
+import at.bitfire.vcard4android.LabeledProperty
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import ezvcard.property.Telephone
+import java.util.LinkedList
+import javax.inject.Inject
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+
+@HiltAndroidTest
+class LocalAddressBookTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    lateinit var addressBook: LocalTestAddressBook
+
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        addressBook = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
+        LocalTestAddressBook.createAccount(context)
+    }
+
+    @After
+    fun tearDown() {
+        // remove address book
+        addressBook.deleteCollection()
+    }
+
+
+    /**
+     * Tests whether contacts are moved (and not lost) when an address book is renamed.
+     */
+    @Test
+    fun test_renameAccount_retainsContacts() {
+        // insert contact with data row
+        val uid = "12345"
+        val contact = Contact(
+            uid = uid,
+            displayName = "Test Contact",
+            phoneNumbers = LinkedList(listOf(LabeledProperty(Telephone("1234567890"))))
+        )
+        val uri = LocalContact(addressBook, contact, null, null, 0).add()
+        val id = ContentUris.parseId(uri)
+        val localContact = addressBook.findContactById(id)
+        localContact.resetDirty()
+        assertFalse("Contact is dirty before moving", addressBook.isContactDirty(id))
+
+        // rename address book
+        val newName = "New Name"
+        addressBook.renameAccount(newName)
+        assertEquals(Account(newName, LocalTestAddressBook.ACCOUNT.type), addressBook.addressBookAccount)
+
+        // check whether contact is still here (including data rows) and not dirty
+        val result = addressBook.findContactById(id)
+        assertFalse("Contact is dirty after moving", addressBook.isContactDirty(id))
+
+        val contact2 = result.getContact()
+        assertEquals(uid, contact2.uid)
+        assertEquals("Test Contact", contact2.displayName)
+        assertEquals("1234567890", contact2.phoneNumbers.first().component1().text)
+    }
+
+    /**
+     * Tests whether groups are moved (and not lost) when an address book is renamed.
+     */
+    @Test
+    fun test_renameAccount_retainsGroups() {
+        // insert group
+        val localGroup = LocalGroup(addressBook, Contact(displayName = "Test Group"), null, null, 0)
+        val uri = localGroup.add()
+        val id = ContentUris.parseId(uri)
+
+        // make sure it's not dirty
+        localGroup.clearDirty(null, null, null)
+        assertFalse("Group is dirty before moving", addressBook.isGroupDirty(id))
+
+        // rename address book
+        val newName = "New Name"
+        addressBook.renameAccount(newName)
+        assertEquals(Account(newName, LocalTestAddressBook.ACCOUNT.type), addressBook.addressBookAccount)
+
+        // check whether group is still here and not dirty
+        val result = addressBook.findGroupById(id)
+        assertFalse("Group is dirty after moving", addressBook.isGroupDirty(id))
+
+        val group = result.getContact()
+        assertEquals("Test Group", group.displayName)
+    }
+
+
+
+    companion object {
+
+        @JvmField
+        @ClassRule
+        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
+
+        private lateinit var provider: ContentProviderClient
+
+        @BeforeClass
+        @JvmStatic
+        fun connect() {
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
+            assertNotNull(provider)
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun disconnect() {
+            provider.close()
+        }
+    }
+
+}

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.resource
 
@@ -15,19 +15,25 @@ 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.ContentProviderClientHelper.closeCompat
-import at.bitfire.ical4android.util.MiscUtils.UriHelper.asSyncAdapter
+import at.bitfire.ical4android.util.MiscUtils.asSyncAdapter
+import at.bitfire.ical4android.util.MiscUtils.closeCompat
 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.After
+import org.junit.AfterClass
 import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Test
 import org.junit.rules.TestRule
 
 class LocalCalendarTest {
 
     companion object {
+
         @JvmField
         @ClassRule
         val initCalendarProviderRule: TestRule = InitCalendarProviderRule.getInstance()
@@ -36,14 +42,14 @@ class LocalCalendarTest {
 
         @BeforeClass
         @JvmStatic
-        fun setUpProvider() {
+        fun setUpClass() {
             val context = InstrumentationRegistry.getInstrumentation().targetContext
             provider = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)!!
         }
 
         @AfterClass
         @JvmStatic
-        fun closeProvider() {
+        fun tearDownClass() {
             provider.closeCompat()
         }
 
@@ -53,14 +59,14 @@ class LocalCalendarTest {
     private lateinit var calendar: LocalCalendar
 
     @Before
-    fun prepare() {
+    fun setUp() {
         val uri = AndroidCalendar.create(account, provider, ContentValues())
         calendar = AndroidCalendar.findByID(account, provider, LocalCalendar.Factory, ContentUris.parseId(uri))
     }
 
     @After
-    fun shutdown() {
-        calendar.delete()
+    fun tearDown() {
+        calendar.deleteCollection()
     }
 
 

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.resource
 
@@ -16,16 +16,27 @@ 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.ContentProviderClientHelper.closeCompat
+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 net.fortuna.ical4j.model.property.DtStart
+import net.fortuna.ical4j.model.property.ExDate
+import net.fortuna.ical4j.model.property.RRule
+import net.fortuna.ical4j.model.property.RecurrenceId
+import net.fortuna.ical4j.model.property.Status
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Test
 import org.junit.rules.TestRule
-import java.util.*
+import java.util.UUID
 
 class LocalEventTest {
 
@@ -35,34 +46,35 @@ class LocalEventTest {
         @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() {
+        fun setUpClass() {
             val context = InstrumentationRegistry.getInstrumentation().targetContext
             provider = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)!!
         }
 
         @AfterClass
         @JvmStatic
-        fun disconnect() {
+        fun tearDownClass() {
             provider.closeCompat()
         }
+
     }
 
+    private val account = Account("LocalCalendarTest", ACCOUNT_TYPE_LOCAL)
+    private lateinit var calendar: LocalCalendar
+
     @Before
-    fun createCalendar() {
+    fun setUp() {
         val uri = AndroidCalendar.create(account, provider, ContentValues())
         calendar = AndroidCalendar.findByID(account, provider, LocalCalendar.Factory, ContentUris.parseId(uri))
     }
 
     @After
     fun removeCalendar() {
-        calendar.delete()
+        calendar.deleteCollection()
     }
 
 

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.resource
 
@@ -8,77 +8,79 @@ import android.Manifest
 import android.content.ContentProviderClient
 import android.content.ContentUris
 import android.content.ContentValues
+import android.content.Context
 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.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.*
-import org.junit.Assert.*
+import org.junit.AfterClass
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
 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()
+            provider.close()
         }
     }
 
-    private fun newGroup(addressBook: LocalAddressBook = addressBookGroupsAsCategories): LocalGroup =
-        LocalGroup(addressBook,
-            Contact().apply {
-                displayName = "Test Group"
-            }, null, null, 0
-        ).apply {
-            add()
-        }
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
 
 
+    private lateinit var addressBookGroupsAsCategories: LocalTestAddressBook
+    private lateinit var addressBookGroupsAsVCards: LocalTestAddressBook
 
     @Before
-    fun clearContacts() {
+    fun setup() {
+        hiltRule.inject()
+
+        addressBookGroupsAsCategories = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
+        addressBookGroupsAsVCards = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+
+        // clear contacts
         addressBookGroupsAsCategories.clear()
         addressBookGroupsAsVCards.clear()
     }
@@ -264,4 +266,16 @@ class LocalGroupTest {
         assertEquals("$newUid.vcf", fileName)
     }
 
+
+    // helpers
+
+    private fun newGroup(addressBook: LocalAddressBook = addressBookGroupsAsCategories): LocalGroup =
+        LocalGroup(addressBook,
+            Contact().apply {
+                displayName = "Test Group"
+            }, null, null, 0
+        ).apply {
+            add()
+        }
+
 }

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

@@ -0,0 +1,97 @@
+/*
+ * 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.ContentUris
+import android.content.Context
+import android.provider.ContactsContract
+import at.bitfire.davdroid.repository.DavCollectionRepository
+import at.bitfire.davdroid.repository.DavServiceRepository
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.vcard4android.GroupMethod
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import dagger.hilt.android.qualifiers.ApplicationContext
+import org.junit.Assert.assertTrue
+import java.io.FileNotFoundException
+import java.util.logging.Logger
+
+class LocalTestAddressBook @AssistedInject constructor(
+    @Assisted provider: ContentProviderClient,
+    @Assisted override val groupMethod: GroupMethod,
+    accountSettingsFactory: AccountSettings.Factory,
+    collectionRepository: DavCollectionRepository,
+    @ApplicationContext context: Context,
+    logger: Logger,
+    serviceRepository: DavServiceRepository
+): LocalAddressBook(ACCOUNT, provider, accountSettingsFactory, collectionRepository, context, logger, serviceRepository) {
+
+    @AssistedFactory
+    interface Factory {
+        fun create(provider: ContentProviderClient, groupMethod: GroupMethod): LocalTestAddressBook
+    }
+
+    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()
+    }
+
+
+    /**
+     * Returns the dirty flag of the given contact.
+     *
+     * @return true if the contact is dirty, false otherwise
+     *
+     * @throws FileNotFoundException if the contact can't be found
+     */
+    fun isContactDirty(id: Long): Boolean {
+        val uri = ContentUris.withAppendedId(rawContactsSyncUri(), id)
+        provider!!.query(uri, arrayOf(ContactsContract.RawContacts.DIRTY), null, null, null)?.use { cursor ->
+            if (cursor.moveToFirst())
+                return cursor.getInt(0) != 0
+        }
+        throw FileNotFoundException()
+    }
+
+    /**
+     * Returns the dirty flag of the given contact group.
+     *
+     * @return true if the group is dirty, false otherwise
+     *
+     * @throws FileNotFoundException if the group can't be found
+     */
+    fun isGroupDirty(id: Long): Boolean {
+        val uri = ContentUris.withAppendedId(groupsSyncUri(), id)
+        provider!!.query(uri, arrayOf(ContactsContract.Groups.DIRTY), null, null, null)?.use { cursor ->
+            if (cursor.moveToFirst())
+                return cursor.getInt(0) != 0
+        }
+        throw FileNotFoundException()
+    }
+
+
+    companion object {
+
+        val ACCOUNT = Account("LocalTestAddressBook", "at.bitfire.davdroid.test")
+
+        fun createAccount(context: Context) {
+            val am = AccountManager.get(context)
+            assertTrue("Couldn't create account for local test address-book", am.addAccountExplicitly(ACCOUNT, null, null))
+        }
+
+    }
+
+}

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

@@ -1,12 +1,13 @@
-/***************************************************************************************************
+/*
  * 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.content.Context
 import android.provider.ContactsContract
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.rule.GrantPermissionRule
@@ -15,9 +16,19 @@ 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 dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
 import org.junit.Assert.assertArrayEquals
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
 
+@HiltAndroidTest
 class CachedGroupMembershipHandlerTest {
 
     companion object {
@@ -27,30 +38,43 @@ class CachedGroupMembershipHandlerTest {
         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()
+            provider.close()
         }
 
     }
 
 
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
     @Test
     fun testMembership() {
+        val addressBook = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+
         val contact = Contact()
         val localContact = LocalContact(addressBook, contact, null, null, 0)
         CachedGroupMembershipHandler(localContact).handle(ContentValues().apply {

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

@@ -1,11 +1,12 @@
-/***************************************************************************************************
+/*
  * 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.Context
 import android.net.Uri
 import android.provider.ContactsContract
 import android.provider.ContactsContract.CommonDataKinds.GroupMembership
@@ -14,38 +15,57 @@ 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 dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
 import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
 
+@HiltAndroidTest
 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
+            val context: 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()
+            provider.close()
         }
+
+    }
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
     }
 
 
@@ -54,6 +74,7 @@ class GroupMembershipBuilderTest {
         val contact = Contact().apply {
             categories += "TEST GROUP"
         }
+        val addressBookGroupsAsCategories = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
         GroupMembershipBuilder(Uri.EMPTY, null, contact, addressBookGroupsAsCategories, false).build().also { result ->
             assertEquals(1, result.size)
             assertEquals(GroupMembership.CONTENT_ITEM_TYPE, result[0].values[GroupMembership.MIMETYPE])
@@ -66,6 +87,7 @@ class GroupMembershipBuilderTest {
         val contact = Contact().apply {
             categories += "TEST GROUP"
         }
+        val addressBookGroupsAsVCards = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
         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,12 +1,13 @@
-/***************************************************************************************************
+/*
  * 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.content.Context
 import android.provider.ContactsContract
 import androidx.test.platform.app.InstrumentationRegistry
 import androidx.test.rule.GrantPermissionRule
@@ -15,44 +16,67 @@ 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 dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
+import org.junit.Assert
 import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
 
+@HiltAndroidTest
 class GroupMembershipHandlerTest {
 
-    @JvmField
-    @Rule
-    val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
+    companion object {
 
-    private lateinit var provider: ContentProviderClient
+        @JvmField
+        @ClassRule
+        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
 
-    private lateinit var addressBookGroupsAsCategories: LocalTestAddressBook
-    private var addressBookGroupsAsCategoriesGroup: Long = -1
+        private lateinit var provider: ContentProviderClient
 
-    private lateinit var addressBookGroupsAsVCards: LocalTestAddressBook
+        @BeforeClass
+        @JvmStatic
+        fun connect() {
+            val context: Context = InstrumentationRegistry.getInstrumentation().context
+            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
+            Assert.assertNotNull(provider)
+        }
 
-    @Before
-    fun connect() {
-        val context = InstrumentationRegistry.getInstrumentation().targetContext
-        provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
-        Assert.assertNotNull(provider)
+        @AfterClass
+        @JvmStatic
+        fun disconnect() {
+            provider.close()
+        }
 
-        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()
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject @ApplicationContext
+    lateinit var context: Context
+
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
     }
 
 
     @Test
     fun testMembership_GroupsAsCategories() {
+        val addressBookGroupsAsCategories = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
+        val addressBookGroupsAsCategoriesGroup = addressBookGroupsAsCategories.findOrCreateGroup("TEST GROUP")
+
         val contact = Contact()
         val localContact = LocalContact(addressBookGroupsAsCategories, contact, null, null, 0)
         GroupMembershipHandler(localContact).handle(ContentValues().apply {
@@ -66,6 +90,8 @@ class GroupMembershipHandlerTest {
 
     @Test
     fun testMembership_GroupsAsVCards() {
+        val addressBookGroupsAsVCards = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+
         val contact = Contact()
         val localContact = LocalContact(addressBookGroupsAsVCards, contact, null, null, 0)
         GroupMembershipHandler(localContact).handle(ContentValues().apply {

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.resource.contactrow
 

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

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.resource.contactrow
 

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

@@ -1,39 +1,28 @@
-/***************************************************************************************************
+/*
  * 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.WorkManager
-import androidx.work.testing.WorkManagerTestInitHelper
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.TestUtils.workScheduledOrRunning
 import at.bitfire.davdroid.db.AppDatabase
 import at.bitfire.davdroid.db.Collection
-import at.bitfire.davdroid.db.Credentials
 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 at.bitfire.davdroid.ui.setup.LoginModel
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import io.mockk.every
-import io.mockk.mockk
+import io.mockk.mockkObject
 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
@@ -42,38 +31,11 @@ import org.junit.Assume
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import java.net.URI
+import java.util.logging.Logger
 import javax.inject.Inject
 
 @HiltAndroidTest
-class RefreshCollectionsWorkerTest {
-    
-    @get:Rule
-    var hiltRule = HiltAndroidRule(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
+class CollectionListRefresherTest {
 
     companion object {
         private const val PATH_CALDAV = "/caldav"
@@ -88,68 +50,55 @@ class RefreshCollectionsWorkerTest {
         private const val SUBPATH_ADDRESSBOOK_INACCESSIBLE = "/addressbooks/inaccessible-contacts"
     }
 
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
     @Inject
     lateinit var db: AppDatabase
 
+    @Inject
+    lateinit var logger: Logger
+
+    @Inject
+    lateinit var refresherFactory: CollectionListRefresher.Factory
+
     @Inject
     lateinit var settings: SettingsManager
 
-    var mockServer =  MockWebServer()
-
-    lateinit var client: HttpClient
-    lateinit var loginModel: LoginModel
+    private val mockServer = MockWebServer()
+    private lateinit var client: HttpClient
 
     @Before
-    fun mockServerSetup() {
+    fun setup() {
+        hiltRule.inject()
+
         // Start mock web server
-        mockServer.dispatcher = TestDispatcher()
+        mockServer.dispatcher = TestDispatcher(logger)
         mockServer.start()
 
-        loginModel = LoginModel()
-        loginModel.baseURI = URI.create("/")
-        loginModel.credentials = Credentials("mock", "12345")
-
-        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
-            .addAuthentication(null, loginModel.credentials!!)
-            .build()
+        client = HttpClient.Builder(context).build()
 
         Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
     }
 
     @After
-    fun cleanUp() {
+    fun teardown() {
         mockServer.shutdown()
         db.close()
     }
 
-    
-    // Actual tests
-    
-    @Test
-    fun testRefreshCollections_enqueuesWorker() {
-        val service = createTestService(Service.TYPE_CALDAV)!!
-        val workerName = RefreshCollectionsWorker.refreshCollections(context, service.id)
-        assertTrue(workScheduledOrRunning(context, workerName))
-    }
 
     @Test
-    fun testOnStopped_stopsRefreshThread() {
-        val service = createTestService(Service.TYPE_CALDAV)!!
-        val workerName = RefreshCollectionsWorker.refreshCollections(context, service.id)
-        WorkManager.getInstance(context).cancelUniqueWork(workerName)
-        assertFalse(workScheduledOrRunning(context, workerName))
-
-        // here we should test whether stopping the work really interrupts the refresh thread
-    }
-
-    @Test
-    fun testQueryHomesets() {
+    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)
-            .queryHomeSets(baseUrl)
+        refresherFactory.create(service, 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)
@@ -169,8 +118,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomesetsAndTheirCollections()
 
         // Check the collection defined in homeset is now in the database
         assertEquals(
@@ -207,8 +155,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomesetsAndTheirCollections()
 
         // Check the collection got updated
         assertEquals(
@@ -247,8 +194,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomesetsAndTheirCollections()
 
         // Check the collection got updated
         assertEquals(
@@ -289,9 +235,8 @@ class RefreshCollectionsWorkerTest {
             )
         )
 
-        // Refresh - should mark collection as homeless, because serverside homeset is empty
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
+        // Refresh - should mark collection as homeless, because serverside homeset is empty.
+        refresherFactory.create(service, client.okHttpClient).refreshHomesetsAndTheirCollections()
 
         // Check the collection, is now marked as homeless
         assertEquals(null, db.collectionDao().get(collectionId)!!.homeSetId)
@@ -320,8 +265,7 @@ class RefreshCollectionsWorkerTest {
 
         // Refresh - homesets and their collections
         assertEquals(0, db.principalDao().getByService(service.id).size)
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomesetsAndTheirCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomesetsAndTheirCollections()
 
         // Check principal saved and the collection was updated with its reference
         val principals = db.principalDao().getByService(service.id)
@@ -354,8 +298,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomelessCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomelessCollections()
 
         // Check the collection got updated - with display name and description
         assertEquals(
@@ -390,8 +333,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh - should delete collection
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomelessCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomelessCollections()
 
         // Check the collection got deleted
         assertEquals(null, db.collectionDao().get(collectionId))
@@ -415,8 +357,7 @@ class RefreshCollectionsWorkerTest {
 
         // Refresh homeless collections
         assertEquals(0, db.principalDao().getByService(service.id).size)
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshHomelessCollections()
+        refresherFactory.create(service, client.okHttpClient).refreshHomelessCollections()
 
         // Check principal saved and the collection was updated with its reference
         val principals = db.principalDao().getByService(service.id)
@@ -458,8 +399,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh principals
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshPrincipals()
+        refresherFactory.create(service, client.okHttpClient).refreshPrincipals()
 
         // Check principal was not updated
         val principals = db.principalDao().getByService(service.id)
@@ -494,8 +434,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh principals
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshPrincipals()
+        refresherFactory.create(service, client.okHttpClient).refreshPrincipals()
 
         // Check principal now got a display name
         val principals = db.principalDao().getByService(service.id)
@@ -518,8 +457,7 @@ class RefreshCollectionsWorkerTest {
         )
 
         // Refresh principals - detecting it does not own collections
-        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
-            .refreshPrincipals()
+        refresherFactory.create(service, client.okHttpClient).refreshPrincipals()
 
         // Check principal was deleted
         val principals = db.principalDao().getByService(service.id)
@@ -532,46 +470,48 @@ class RefreshCollectionsWorkerTest {
     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 ""
+        mockkObject(settings) {
+            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 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))
+            val refresher = refresherFactory.create(service, 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 ""
+        mockkObject(settings) {
+            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 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))
+            val refresher = refresherFactory.create(service, client.okHttpClient)
+            assertTrue(refresher.shouldPreselect(collection, homesets))
+        }
     }
 
     @Test
@@ -579,69 +519,72 @@ class RefreshCollectionsWorkerTest {
         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()
+        mockkObject(settings) {
+            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 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))
+            val refresher = refresherFactory.create(service, 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 ""
+        mockkObject(settings) {
+            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 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))
+            val refresher = refresherFactory.create(service, 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 ""
+        mockkObject(settings) {
+            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 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))
+            val refresher = refresherFactory.create(service, client.okHttpClient)
+            assertTrue(refresher.shouldPreselect(collection, homesets))
+        }
     }
 
     @Test
@@ -649,23 +592,24 @@ class RefreshCollectionsWorkerTest {
         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()
+        mockkObject(settings) {
+            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 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))
+            val refresher = refresherFactory.create(service, client.okHttpClient)
+            assertFalse(refresher.shouldPreselect(collection, homesets))
+        }
     }
 
     // Test helpers and dependencies
@@ -676,10 +620,13 @@ class RefreshCollectionsWorkerTest {
         return db.serviceDao().get(serviceId)
     }
 
-    class TestDispatcher: Dispatcher() {
+
+    class TestDispatcher(
+        private val logger: Logger
+    ): Dispatcher() {
 
         override fun dispatch(request: RecordedRequest): MockResponse {
-            val path = StringUtils.removeEnd(request.path!!, "/")
+            val path = request.path!!.trimEnd('/')
 
             if (request.method.equals("PROPFIND", true)) {
                 val properties = when (path) {
@@ -757,8 +704,8 @@ class RefreshCollectionsWorkerTest {
                             "</multistatus>"
                 }
 
-                Logger.log.info("Queried: $path")
-                Logger.log.info("Response: $responseBody")
+                logger.info("Queried: $path")
+                logger.info("Response: $responseBody")
                 return MockResponse()
                     .setResponseCode(responseCode)
                     .setBody(responseBody)
@@ -768,4 +715,4 @@ class RefreshCollectionsWorkerTest {
         }
 
     }
-}
+}

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

@@ -1,46 +1,43 @@
-/***************************************************************************************************
+/*
  * 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 androidx.test.filters.SmallTest
-import androidx.test.platform.app.InstrumentationRegistry
 import at.bitfire.dav4jvm.DavResource
-import at.bitfire.dav4jvm.property.AddressbookHomeSet
-import at.bitfire.dav4jvm.property.ResourceType
-import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.dav4jvm.property.carddav.AddressbookHomeSet
+import at.bitfire.dav4jvm.property.webdav.ResourceType
 import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.network.HttpClient
 import at.bitfire.davdroid.servicedetection.DavResourceFinder.Configuration.ServiceInfo
 import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.ui.setup.LoginModel
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import okhttp3.mockwebserver.Dispatcher
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import okhttp3.mockwebserver.RecordedRequest
-import org.junit.*
-import org.junit.Assert.*
+import org.junit.After
+import org.junit.Assert.assertArrayEquals
+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 java.net.URI
+import java.util.logging.Logger
 import javax.inject.Inject
 
 @HiltAndroidTest
 class DavResourceFinderTest {
 
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @Inject
-    lateinit var settingsManager: SettingsManager
-
-    @Before
-    fun inject() {
-        hiltRule.inject()
-    }
-
     companion object {
         private const val PATH_NO_DAV = "/nodav"
         private const val PATH_CALDAV = "/caldav"
@@ -52,31 +49,47 @@ class DavResourceFinderTest {
         private const val SUBPATH_ADDRESSBOOK = "/addressbooks/private-contacts"
     }
 
-    val server = MockWebServer()
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
 
-    lateinit var finder: DavResourceFinder
-    lateinit var client: HttpClient
-    lateinit var loginModel: LoginModel
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var logger: Logger
+
+    @Inject
+    lateinit var resourceFinderFactory: DavResourceFinder.Factory
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    private val server = MockWebServer()
+
+    private lateinit var finder: DavResourceFinder
+    private lateinit var client: HttpClient
 
     @Before
-    fun initServerAndClient() {
-        server.dispatcher = TestDispatcher()
+    fun setup() {
+        hiltRule.inject()
+
+        server.dispatcher = TestDispatcher(logger)
         server.start()
 
-        loginModel = LoginModel()
-        loginModel.baseURI = URI.create("/")
-        loginModel.credentials = Credentials("mock", "12345")
+        val baseURI = URI.create("/")
+        val credentials = Credentials("mock", "12345")
 
-        finder = DavResourceFinder(InstrumentationRegistry.getInstrumentation().targetContext, loginModel)
-        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
-                .addAuthentication(null, loginModel.credentials!!)
+        finder = resourceFinderFactory.create(baseURI, credentials)
+        client = HttpClient.Builder(context)
+                .addAuthentication(null, credentials)
                 .build()
 
         Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
     }
 
     @After
-    fun stopServer() {
+    fun teardown() {
         server.shutdown()
     }
 
@@ -151,7 +164,9 @@ class DavResourceFinderTest {
 
     // mock server
 
-    class TestDispatcher: Dispatcher() {
+    class TestDispatcher(
+        private val logger: Logger
+    ): Dispatcher() {
 
         override fun dispatch(request: RecordedRequest): MockResponse {
             if (!checkAuth(request)) {
@@ -200,7 +215,7 @@ class DavResourceFinderTest {
 
                     else -> props = null
                 }
-                Logger.log.info("Sending props: $props")
+                logger.info("Sending props: $props")
                 return MockResponse()
                         .setResponseCode(207)
                         .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +

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

@@ -0,0 +1,93 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.settings
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.take
+import kotlinx.coroutines.flow.toSet
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class SettingsManagerTest {
+
+    companion object {
+        /** Use this setting to test SettingsManager methods. Will be removed after every test run. */
+        const val SETTING_TEST = "test"
+    }
+
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+    @get:Rule
+    val instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @Inject lateinit var settingsManager: SettingsManager
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+    @After
+    fun removeTestSetting() {
+        settingsManager.remove(SETTING_TEST)
+    }
+
+
+    @Test
+    fun test_containsKey_NotExisting() {
+        assertFalse(settingsManager.containsKey("notExisting"))
+    }
+
+    @Test
+    fun test_containsKey_Existing() {
+        // provided by DefaultsProvider
+        assertEquals(Settings.PROXY_TYPE_SYSTEM, settingsManager.getInt(Settings.PROXY_TYPE))
+    }
+
+
+    @Test
+    fun test_observerFlow_initialValue() = runBlocking {
+        var counter = 0
+        val live = settingsManager.observerFlow {
+            if (counter++ == 0)
+                23
+            else
+                throw AssertionError("A second value was requested")
+        }
+        assertEquals(23, live.first())
+    }
+
+    @Test
+    fun test_observerFlow_updatedValue() = runBlocking {
+        var counter = 0
+        val live = settingsManager.observerFlow {
+            when (counter++) {
+                0 -> {
+                    // update some setting so that we will be called a second time
+                    settingsManager.putBoolean(SETTING_TEST, true)
+                    // and emit initial value
+                    23
+                }
+                1 -> 42     // updated value
+                else -> throw AssertionError()
+            }
+        }
+
+        val result = live.take(2).toSet()
+        assertEquals(setOf(23, 42), result)
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/LocalTestCollection.kt

@@ -1,13 +1,15 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
-package at.bitfire.davdroid.syncadapter
+package at.bitfire.davdroid.sync
 
 import at.bitfire.davdroid.db.SyncState
 import at.bitfire.davdroid.resource.LocalCollection
 
-class LocalTestCollection: LocalCollection<LocalTestResource> {
+class LocalTestCollection(
+    override val collectionUrl: String = "http://example.com/test/"
+): LocalCollection<LocalTestResource> {
 
     override val tag = "LocalTestCollection"
     override val title = "Local Test Collection"
@@ -16,10 +18,15 @@ class LocalTestCollection: LocalCollection<LocalTestResource> {
 
     val entries = mutableListOf<LocalTestResource>()
 
+    override val readOnly: Boolean
+        get() = throw NotImplementedError()
+
+    override fun deleteCollection(): Boolean = true
+
     override fun findDeleted() = entries.filter { it.deleted }
     override fun findDirty() = entries.filter { it.dirty }
 
-    override fun findByName(name: String) = entries.filter { it.fileName == name }.firstOrNull()
+    override fun findByName(name: String) = entries.firstOrNull { it.fileName == name }
 
     override fun markNotDirty(flags: Int): Int {
         var updated = 0

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/LocalTestResource.kt

@@ -1,8 +1,8 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
-package at.bitfire.davdroid.syncadapter
+package at.bitfire.davdroid.sync
 
 import at.bitfire.davdroid.resource.LocalResource
 
@@ -34,5 +34,6 @@ class LocalTestResource: LocalResource<Any> {
     override fun add() = throw NotImplementedError()
     override fun update(data: Any) = throw NotImplementedError()
     override fun delete() = throw NotImplementedError()
+    override fun resetDeleted() = throw NotImplementedError()
 
 }

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/SyncAdapterServicesTest.kt

@@ -0,0 +1,192 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync
+
+import android.accounts.Account
+import android.content.Context
+import android.content.SyncResult
+import android.os.Bundle
+import android.provider.CalendarContract
+import android.util.Log
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.Configuration
+import androidx.work.WorkInfo
+import androidx.work.WorkManager
+import androidx.work.testing.WorkManagerTestInitHelper
+import at.bitfire.davdroid.repository.DavCollectionRepository
+import at.bitfire.davdroid.repository.DavServiceRepository
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.sync.account.TestAccountAuthenticator
+import at.bitfire.davdroid.sync.worker.SyncWorkerManager
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.Awaits
+import io.mockk.coEvery
+import io.mockk.every
+import io.mockk.just
+import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withTimeout
+import org.junit.After
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.rules.Timeout
+import java.util.concurrent.Executors
+import java.util.logging.Logger
+import javax.inject.Inject
+import kotlin.coroutines.cancellation.CancellationException
+
+@HiltAndroidTest
+class SyncAdapterServicesTest {
+
+    lateinit var account: Account
+
+    @Inject
+    lateinit var accountSettingsFactory: AccountSettings.Factory
+
+    @Inject
+    lateinit var collectionRepository: DavCollectionRepository
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var logger: Logger
+
+    @Inject
+    lateinit var serviceRepository: DavServiceRepository
+
+    @Inject
+    lateinit var syncConditionsFactory: SyncConditions.Factory
+
+    @Inject
+    lateinit var workerFactory: HiltWorkerFactory
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    // test methods should run quickly and not wait 60 seconds for a sync timeout or something like that
+    @get:Rule
+    val timeoutRule: Timeout = Timeout.seconds(5)
+
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        account = TestAccountAuthenticator.create()
+
+        // Initialize WorkManager for instrumentation tests.
+        val config = Configuration.Builder()
+            .setMinimumLoggingLevel(Log.DEBUG)
+            .setWorkerFactory(workerFactory)
+            .build()
+        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
+    }
+
+    @After
+    fun tearDown() {
+        TestAccountAuthenticator.remove(account)
+        unmockkAll()
+    }
+
+
+    private fun syncAdapter(
+        syncWorkerManager: SyncWorkerManager
+    ): SyncAdapterService.SyncAdapter =
+        SyncAdapterService.SyncAdapter(
+            accountSettingsFactory = accountSettingsFactory,
+            collectionRepository = collectionRepository,
+            serviceRepository = serviceRepository,
+            context = context,
+            logger = logger,
+            syncConditionsFactory = syncConditionsFactory,
+            syncWorkerManager = syncWorkerManager
+        )
+
+
+    @Test
+    fun testSyncAdapter_onPerformSync_cancellation() {
+        val syncWorkerManager = mockk<SyncWorkerManager>()
+        val syncAdapter = syncAdapter(syncWorkerManager = syncWorkerManager)
+        val workManager = WorkManager.getInstance(context)
+
+        mockkObject(workManager) {
+            // don't actually create a worker
+            every { syncWorkerManager.enqueueOneTime(any(), any()) } returns "TheSyncWorker"
+
+            // assume worker takes a long time
+            every { workManager.getWorkInfosForUniqueWorkFlow("TheSyncWorker") } just Awaits
+
+            runBlocking {
+                val sync = launch {
+                    syncAdapter.onPerformSync(account, Bundle(), CalendarContract.AUTHORITY, mockk(), SyncResult())
+                }
+
+                // simulate incoming cancellation from sync framework
+                syncAdapter.onSyncCanceled()
+
+                // wait for sync to finish (should happen immediately)
+                sync.join()
+            }
+        }
+    }
+
+    @Test
+    fun testSyncAdapter_onPerformSync_returnsAfterTimeout() {
+        val syncWorkerManager = mockk<SyncWorkerManager>()
+        val syncAdapter = syncAdapter(syncWorkerManager = syncWorkerManager)
+        val workManager = WorkManager.getInstance(context)
+
+        mockkObject(workManager) {
+            // don't actually create a worker
+            every { syncWorkerManager.enqueueOneTime(any(), any()) } returns "TheSyncWorker"
+
+            // assume worker takes a long time
+            every { workManager.getWorkInfosForUniqueWorkFlow("TheSyncWorker") } just Awaits
+
+            mockkStatic("kotlinx.coroutines.TimeoutKt") {   // mock global extension function
+                // immediate timeout (instead of really waiting)
+                coEvery { withTimeout(any<Long>(), any<suspend CoroutineScope.() -> Unit>()) } throws CancellationException("Simulated timeout")
+
+                syncAdapter.onPerformSync(account, Bundle(), CalendarContract.AUTHORITY, mockk(), SyncResult())
+            }
+        }
+    }
+
+    @Test
+    fun testSyncAdapter_onPerformSync_runsInTime() {
+        val syncWorkerManager = mockk<SyncWorkerManager>()
+        val syncAdapter = syncAdapter(syncWorkerManager = syncWorkerManager)
+        val workManager = WorkManager.getInstance(context)
+
+        mockkObject(workManager) {
+            // don't actually create a worker
+            every { syncWorkerManager.enqueueOneTime(any(), any()) } returns "TheSyncWorker"
+
+            // assume worker immediately returns with success
+            val success = mockk<WorkInfo>()
+            every { success.state } returns WorkInfo.State.SUCCEEDED
+            every { workManager.getWorkInfosForUniqueWorkFlow("TheSyncWorker") } returns flow {
+                emit(listOf(success))
+                delay(60000)    // keep the flow active
+            }
+
+            // should just run
+            syncAdapter.onPerformSync(account, Bundle(), CalendarContract.AUTHORITY, mockk(), SyncResult())
+        }
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/SyncManagerTest.kt

@@ -1,140 +1,170 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
-package at.bitfire.davdroid.syncadapter
+package at.bitfire.davdroid.sync
 
 import android.accounts.Account
-import android.accounts.AccountManager
 import android.content.Context
-import android.content.SyncResult
 import android.util.Log
 import androidx.core.app.NotificationManagerCompat
 import androidx.hilt.work.HiltWorkerFactory
-import androidx.test.platform.app.InstrumentationRegistry
 import androidx.work.Configuration
 import androidx.work.testing.WorkManagerTestInitHelper
 import at.bitfire.dav4jvm.PropStat
 import at.bitfire.dav4jvm.Response
 import at.bitfire.dav4jvm.Response.HrefRelation
-import at.bitfire.dav4jvm.property.GetETag
-import at.bitfire.davdroid.network.HttpClient
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.db.Credentials
+import at.bitfire.dav4jvm.property.webdav.GetETag
+import at.bitfire.davdroid.TestUtils.assertWithin
+import at.bitfire.davdroid.db.Collection
 import at.bitfire.davdroid.db.SyncState
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.repository.DavSyncStatsRepository
 import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.ui.NotificationUtils
+import at.bitfire.davdroid.sync.account.TestAccountAuthenticator
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
+import dagger.hilt.components.SingletonComponent
+import io.mockk.every
+import io.mockk.mockk
 import okhttp3.Protocol
 import okhttp3.internal.http.StatusLine
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
-import org.junit.*
-import org.junit.Assert.*
-import java.util.concurrent.TimeUnit
+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 java.time.Instant
 import javax.inject.Inject
 
 @HiltAndroidTest
 class SyncManagerTest {
 
-    companion object {
-
-        val context = InstrumentationRegistry.getInstrumentation().targetContext
-        val account = Account("SyncManagerTest", context.getString(R.string.account_type))
-
-        @BeforeClass
-        @JvmStatic
-        fun createAccount() {
-            assertTrue(AccountManager.get(context).addAccountExplicitly(account, "test", AccountSettings.initialUserData(Credentials("test", "test"))))
-        }
-
-        @AfterClass
-        @JvmStatic
-        fun removeAccount() {
-            assertTrue(AccountManager.get(context).removeAccount(account, null, null).getResult(10, TimeUnit.SECONDS))
-
-            // clear annoying syncError notifications
-            NotificationManagerCompat.from(context).cancelAll()
-        }
-
+    @Module
+    @InstallIn(SingletonComponent::class)
+    object SyncManagerTestModule {
+        @Provides
+        fun davSyncStatsRepository(): DavSyncStatsRepository = mockk<DavSyncStatsRepository>(relaxed = true)
     }
 
 
     @get:Rule
     val hiltRule = HiltAndroidRule(this)
 
-    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
+    @Inject
+    lateinit var accountSettingsFactory: AccountSettings.Factory
 
     @Inject
-    lateinit var settingsManager: SettingsManager
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var syncManagerFactory: TestSyncManager.Factory
 
     @Inject
     lateinit var workerFactory: HiltWorkerFactory
 
-    val server = MockWebServer()
+    lateinit var account: Account
+    private val server = MockWebServer()
 
     @Before
-    fun inject() {
+    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)
-    }
 
+        account = TestAccountAuthenticator.create()
 
-    private fun syncManager(collection: LocalTestCollection) =
-            TestSyncManager(
-                    context,
-                    account,
-                    arrayOf(),
-                    "TestAuthority",
-                    HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build(),
-                    SyncResult(),
-                    collection,
-                    server
-            )
-
-    @Before
-    fun startServer() {
         server.start()
     }
 
     @After
-    fun stopServer() {
+    fun tearDown() {
+        TestAccountAuthenticator.remove(account)
+
+        // clear annoying syncError notifications
+        NotificationManagerCompat.from(context).cancelAll()
+
         server.close()
     }
 
 
+    @Test
+    fun testGetDelayUntil_defaultOnNull() {
+        val now = Instant.now()
+        val delayUntil = SyncManager.getDelayUntil(null).epochSecond
+        val default = now.plusSeconds(SyncManager.DELAY_UNTIL_DEFAULT).epochSecond
+        assertWithin(default, delayUntil, 5)
+    }
+
+    @Test
+    fun testGetDelayUntil_reducesToMax() {
+        val now = Instant.now()
+        val delayUntil = SyncManager.getDelayUntil(now.plusSeconds(10*24*60*60)).epochSecond
+        val max = now.plusSeconds(SyncManager.DELAY_UNTIL_MAX).epochSecond
+        assertWithin(max, delayUntil, 5)
+    }
+
+    @Test
+    fun testGetDelayUntil_increasesToMin() {
+        val delayUntil = SyncManager.getDelayUntil(Instant.EPOCH).epochSecond
+        val min = Instant.now().plusSeconds(SyncManager.DELAY_UNTIL_MIN).epochSecond
+        assertWithin(min, delayUntil, 5)
+    }
+
+
     private fun queryCapabilitiesResponse(cTag: String? = null): MockResponse {
         val body = StringBuilder()
-        body.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" +
-                "<multistatus xmlns=\"DAV:\" xmlns:CALDAV=\"http://calendarserver.org/ns/\">\n" +
-                "  <response>\n" +
-                "    <href>/</href>\n" +
-                "    <propstat>\n" +
-                "      <prop>\n")
-        if (cTag != null)
-                body.append("<CALDAV:getctag>$cTag</CALDAV:getctag>\n")
         body.append(
-                "      </prop>\n" +
-                "    </propstat>\n" +
-                "  </response>\n" +
-                "</multistatus>")
-        val response = MockResponse()
-                .setResponseCode(207)
-                .setHeader("Content-Type", "text/xml")
-                .setBody(body.toString())
-        return response
+            "<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" +
+                    "<multistatus xmlns=\"DAV:\" xmlns:CALDAV=\"http://calendarserver.org/ns/\">\n" +
+                    "  <response>\n" +
+                    "    <href>/</href>\n" +
+                    "    <propstat>\n" +
+                    "      <prop>\n"
+        )
+        if (cTag != null)
+            body.append("<CALDAV:getctag>$cTag</CALDAV:getctag>\n")
+        body.append(
+            "      </prop>\n" +
+                    "    </propstat>\n" +
+                    "  </response>\n" +
+                    "</multistatus>"
+        )
+        return MockResponse()
+            .setResponseCode(207)
+            .setHeader("Content-Type", "text/xml")
+            .setBody(body.toString())
+    }
+
+    @Test
+    fun testPerformSync_503RetryAfter_DelaySeconds() {
+        server.enqueue(MockResponse()
+            .setResponseCode(503)
+            .setHeader("Retry-After", "60"))    // 60 seconds
+
+        val result = SyncResult()
+        val syncManager = syncManager(LocalTestCollection(), result)
+        syncManager.performSync()
+
+        val expected = Instant.now()
+            .plusSeconds(60)
+            .toEpochMilli()
+        // 5 sec tolerance for test
+        assertWithin(expected, result.delayUntil*1000, 5000)
     }
 
     @Test
@@ -479,4 +509,25 @@ class SyncManagerTest {
         assertTrue(collection.entries.isEmpty())
     }
 
+
+    // helpers
+
+    private fun syncManager(
+        localCollection: LocalTestCollection,
+        syncResult: SyncResult = SyncResult(),
+        collection: Collection = mockk<Collection>() {
+            every { id } returns 1
+            every { url } returns server.url("/")
+        }
+    ) = syncManagerFactory.create(
+        account,
+        accountSettingsFactory.create(account),
+        arrayOf(),
+        "TestAuthority",
+        HttpClient.Builder(context).build(),
+        syncResult,
+        localCollection,
+        collection
+    )
+
 }

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/SyncerTest.kt

@@ -0,0 +1,206 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync
+
+import android.accounts.Account
+import android.content.ContentProviderClient
+import at.bitfire.davdroid.db.Collection
+import at.bitfire.davdroid.sync.account.TestAccountAuthenticator
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.spyk
+import io.mockk.verify
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import org.junit.After
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class SyncerTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var testSyncer: TestSyncer.Factory
+
+    lateinit var account: Account
+
+    private lateinit var syncer: TestSyncer
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        account = TestAccountAuthenticator.create()
+        syncer = spyk(testSyncer.create(account, emptyArray(), SyncResult()))
+    }
+
+    @After
+    fun tearDown() {
+        TestAccountAuthenticator.remove(account)
+    }
+
+
+    @Test
+    fun testSync_prepare_fails() {
+        val provider = mockk<ContentProviderClient>()
+        every { syncer.prepare(provider) } returns false
+        every { syncer.getSyncEnabledCollections() } returns emptyMap()
+
+        // Should stop the sync after prepare returns false
+        syncer.sync(provider)
+        verify(exactly = 1) { syncer.prepare(provider) }
+        verify(exactly = 0) { syncer.getSyncEnabledCollections() }
+    }
+
+    @Test
+    fun testSync_prepare_succeeds() {
+        val provider = mockk<ContentProviderClient>()
+        every { syncer.prepare(provider) } returns true
+        every { syncer.getSyncEnabledCollections() } returns emptyMap()
+
+        // Should continue the sync after prepare returns true
+        syncer.sync(provider)
+        verify(exactly = 1) { syncer.prepare(provider) }
+        verify(exactly = 1) { syncer.getSyncEnabledCollections() }
+    }
+
+
+    @Test
+    fun testUpdateCollections_deletesCollection() {
+        val localCollection = mockk<LocalTestCollection>()
+        every { localCollection.collectionUrl } returns "http://delete.the/collection"
+        every { localCollection.deleteCollection() } returns true
+        every { localCollection.title } returns "Collection to be deleted locally"
+
+        // Should delete the localCollection if dbCollection (remote) does not exist
+        val localCollections = mutableListOf(localCollection)
+        val result = syncer.updateCollections(mockk(), localCollections, emptyMap())
+        verify(exactly = 1) { localCollection.deleteCollection() }
+
+        // Updated local collection list should be empty
+        assertTrue(result.isEmpty())
+    }
+
+    @Test
+    fun testUpdateCollections_updatesCollection() {
+        val localCollection = mockk<LocalTestCollection>()
+        val dbCollection = mockk<Collection>()
+        val dbCollections = mapOf("http://update.the/collection".toHttpUrl() to dbCollection)
+        every { dbCollection.url } returns "http://update.the/collection".toHttpUrl()
+        every { localCollection.collectionUrl } returns "http://update.the/collection"
+        every { localCollection.title } returns "The Local Collection"
+
+        // Should update the localCollection if it exists
+        val result = syncer.updateCollections(mockk(), listOf(localCollection), dbCollections)
+        verify(exactly = 1) { syncer.update(localCollection, dbCollection) }
+
+        // Updated local collection list should be same as input
+        assertArrayEquals(arrayOf(localCollection), result.toTypedArray())
+    }
+
+    @Test
+    fun testUpdateCollections_findsNewCollection() {
+        val dbCollection = mockk<Collection>()
+        every { dbCollection.url } returns "http://newly.found/collection".toHttpUrl()
+        val dbCollections = mapOf(dbCollection.url to dbCollection)
+
+        // Should return the new collection, because it was not updated
+        val result = syncer.updateCollections(mockk(), emptyList(), dbCollections)
+
+        // Updated local collection list contain new entry
+        assertEquals(1, result.size)
+        assertEquals(dbCollection.url.toString(), result[0].collectionUrl)
+    }
+
+
+    @Test
+    fun testCreateLocalCollections() {
+        val provider = mockk<ContentProviderClient>()
+        val localCollection = mockk<LocalTestCollection>()
+        val dbCollection = mockk<Collection>()
+        every { syncer.create(provider, dbCollection) } returns localCollection
+        every { dbCollection.url } returns "http://newly.found/collection".toHttpUrl()
+
+        // Should return list of newly created local collections
+        val result = syncer.createLocalCollections(provider, listOf(dbCollection))
+        assertEquals(listOf(localCollection), result)
+    }
+
+    
+    @Test
+    fun testSyncCollectionContents() {
+        val provider = mockk<ContentProviderClient>()
+        val dbCollection1 = mockk<Collection>()
+        val dbCollection2 = mockk<Collection>()
+        val dbCollections = mapOf(
+            "http://newly.found/collection1".toHttpUrl() to dbCollection1,
+            "http://newly.found/collection2".toHttpUrl() to dbCollection2
+        )
+        val localCollection1 = mockk<LocalTestCollection>()
+        val localCollection2 = mockk<LocalTestCollection>()
+        val localCollections = listOf(localCollection1, localCollection2)
+        every { localCollection1.collectionUrl } returns "http://newly.found/collection1"
+        every { localCollection2.collectionUrl } returns "http://newly.found/collection2"
+
+        // Should call the collection content sync on both collections
+        syncer.syncCollectionContents(provider, localCollections, dbCollections)
+        verify(exactly = 1) { syncer.syncCollection(provider, localCollection1, dbCollection1) }
+        verify(exactly = 1) { syncer.syncCollection(provider, localCollection2, dbCollection2) }
+    }
+    
+
+    // Test helpers
+
+    class TestSyncer @AssistedInject constructor(
+        @Assisted account: Account,
+        @Assisted extras: Array<String>,
+        @Assisted syncResult: SyncResult
+    ) : Syncer<LocalTestCollection>(account, extras, syncResult) {
+
+        @AssistedFactory
+        interface Factory {
+            fun create(account: Account, extras: Array<String>, syncResult: SyncResult): TestSyncer
+        }
+
+        override val authority: String
+            get() = ""
+        override val serviceType: String
+            get() = ""
+
+        override fun prepare(provider: ContentProviderClient): Boolean =
+            true
+
+        override fun getLocalCollections(provider: ContentProviderClient): List<LocalTestCollection> =
+            emptyList()
+
+        override fun getDbSyncCollections(serviceId: Long): List<Collection> =
+            emptyList()
+
+        override fun create(provider: ContentProviderClient, remoteCollection: Collection): LocalTestCollection =
+            LocalTestCollection(remoteCollection.url.toString())
+
+        override fun syncCollection(
+            provider: ContentProviderClient,
+            localCollection: LocalTestCollection,
+            remoteCollection: Collection
+        ) {}
+
+        override fun update(localCollection: LocalTestCollection, remoteCollection: Collection) {}
+
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/TestSyncManager.kt

@@ -1,41 +1,64 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
-package at.bitfire.davdroid.syncadapter
+package at.bitfire.davdroid.sync
 
 import android.accounts.Account
-import android.content.Context
-import android.content.SyncResult
 import at.bitfire.dav4jvm.DavCollection
 import at.bitfire.dav4jvm.MultiResponseCallback
 import at.bitfire.dav4jvm.Response
-import at.bitfire.dav4jvm.property.GetCTag
-import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.dav4jvm.property.caldav.GetCTag
+import at.bitfire.davdroid.db.Collection
 import at.bitfire.davdroid.db.SyncState
+import at.bitfire.davdroid.network.HttpClient
 import at.bitfire.davdroid.resource.LocalResource
 import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.util.DavUtils
+import at.bitfire.davdroid.util.DavUtils.lastSegment
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
 import okhttp3.HttpUrl
 import okhttp3.RequestBody
 import okhttp3.RequestBody.Companion.toRequestBody
-import okhttp3.mockwebserver.MockWebServer
 import org.junit.Assert.assertEquals
 
-class TestSyncManager(
-    context: Context,
-    account: Account,
-    extras: Array<String>,
-    authority: String,
-    httpClient: HttpClient,
-    syncResult: SyncResult,
-    localCollection: LocalTestCollection,
-    val mockWebServer: MockWebServer
-): SyncManager<LocalTestResource, LocalTestCollection, DavCollection>(context, account, AccountSettings(context, account), httpClient, extras, authority, syncResult, localCollection) {
+class TestSyncManager @AssistedInject constructor(
+    @Assisted account: Account,
+    @Assisted accountSettings: AccountSettings,
+    @Assisted extras: Array<String>,
+    @Assisted authority: String,
+    @Assisted httpClient: HttpClient,
+    @Assisted syncResult: SyncResult,
+    @Assisted localCollection: LocalTestCollection,
+    @Assisted collection: Collection
+): SyncManager<LocalTestResource, LocalTestCollection, DavCollection>(
+    account,
+    accountSettings,
+    httpClient,
+    extras,
+    authority,
+    syncResult,
+    localCollection,
+    collection
+) {
+
+    @AssistedFactory
+    interface Factory {
+        fun create(
+            account: Account,
+            accountSettings: AccountSettings,
+            extras: Array<String>,
+            authority: String,
+            httpClient: HttpClient,
+            syncResult: SyncResult,
+            localCollection: LocalTestCollection,
+            collection: Collection
+        ): TestSyncManager
+    }
 
     override fun prepare(): Boolean {
-        collectionURL = mockWebServer.url("/")
-        davCollection = DavCollection(httpClient.okHttpClient, collectionURL)
+        davCollection = DavCollection(httpClient.okHttpClient, collection.url)
         return true
     }
 
@@ -81,8 +104,8 @@ class TestSyncManager(
         assertEquals(assertDownloadRemote.keys.toList(), bunch)
 
         for ((url, eTag) in assertDownloadRemote) {
-            val fileName = DavUtils.lastSegmentOfUrl(url)
-            var localEntry = localCollection.entries.filter { it.fileName == fileName }.firstOrNull()
+            val fileName = url.lastSegment
+            var localEntry = localCollection.entries.firstOrNull { it.fileName == fileName }
             if (localEntry == null) {
                 val newEntry = LocalTestResource().also {
                     it.fileName = fileName

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/account/AccountUtilsTest.kt

@@ -1,15 +1,17 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
-package at.bitfire.davdroid.syncadapter
+package at.bitfire.davdroid.sync.account
 
 import android.accounts.Account
 import android.accounts.AccountManager
+import android.content.Context
 import android.os.Bundle
 import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.R
 import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.davdroid.test.R
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import org.junit.Assert.assertEquals
@@ -17,7 +19,6 @@ import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import java.util.concurrent.TimeUnit
 import javax.inject.Inject
 
 @HiltAndroidTest
@@ -26,33 +27,40 @@ class AccountUtilsTest {
     @get:Rule
     val hiltRule = HiltAndroidRule(this)
 
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+    val testContext = InstrumentationRegistry.getInstrumentation().context
+
     @Inject
     lateinit var settingsManager: SettingsManager
 
+    val account = Account(
+        "AccountUtilsTest",
+        testContext.getString(R.string.account_type_test)
+    )
+
     @Before
-    fun inject() {
+    fun setUp() {
         hiltRule.inject()
     }
 
 
-    val context by lazy { InstrumentationRegistry.getInstrumentation().targetContext }
-    val account by lazy { Account("Test Account", context.getString(R.string.account_type)) }
-
     @Test
     fun testCreateAccount() {
         val userData = Bundle(2)
         userData.putString("int", "1")
         userData.putString("string", "abc/\"-")
+
+        val manager = AccountManager.get(context)
         try {
-            assertTrue(AccountUtils.createAccount(context, account, userData))
+            assertTrue(SystemAccountUtils.createAccount(context, account, userData))
 
             // validate user data
-            val manager = AccountManager.get(context)
             assertEquals("1", manager.getUserData(account, "int"))
             assertEquals("abc/\"-", manager.getUserData(account, "string"))
         } finally {
-            val futureResult = AccountManager.get(context).removeAccount(account, {}, null)
-            assertTrue(futureResult.getResult(10, TimeUnit.SECONDS))
+            assertTrue(manager.removeAccountExplicitly(account))
         }
     }
 

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/account/AccountsCleanupWorkerTest.kt

@@ -0,0 +1,152 @@
+package at.bitfire.davdroid.sync.account
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.Context
+import android.os.Bundle
+import android.util.Log
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.Configuration
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import androidx.work.testing.WorkManagerTestInitHelper
+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.resource.LocalAddressBook.Companion.USER_DATA_COLLECTION_ID
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.qualifiers.ApplicationContext
+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.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class AccountsCleanupWorkerTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var accountsCleanupWorkerFactory: AccountsCleanupWorker.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var db: AppDatabase
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    @Inject
+    lateinit var workerFactory: HiltWorkerFactory
+
+    lateinit var accountManager: AccountManager
+    lateinit var addressBookAccountType: String
+    lateinit var addressBookAccount: Account
+    lateinit var service: Service
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        service = createTestService(Service.TYPE_CARDDAV)
+
+        // Prepare test account
+        accountManager = AccountManager.get(context)
+        addressBookAccountType = context.getString(R.string.account_type_address_book)
+        addressBookAccount = Account(
+            "Fancy address book account",
+            addressBookAccountType
+        )
+
+        // Initialize WorkManager for instrumentation tests.
+        val config = Configuration.Builder()
+            .setMinimumLoggingLevel(Log.DEBUG)
+            .setWorkerFactory(workerFactory)
+            .build()
+        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
+    }
+
+    @After
+    fun tearDown() {
+        // Remove the account here in any case; Nice to have when the test fails
+        accountManager.removeAccountExplicitly(addressBookAccount)
+    }
+
+
+    @Test
+    fun testDeleteOrphanedAddressBookAccounts_deletesAddressBookAccountWithoutCollection() {
+        // Create address book account without corresponding collection
+        assertTrue(accountManager.addAccountExplicitly(addressBookAccount, null, null))
+
+        val addressBookAccounts = accountManager.getAccountsByType(addressBookAccountType)
+        assertEquals(addressBookAccount, addressBookAccounts.firstOrNull())
+
+        // Create worker and run the method
+        val worker = TestListenableWorkerBuilder<AccountsCleanupWorker>(context)
+            .setWorkerFactory(object: WorkerFactory() {
+                override fun createWorker(appContext: Context, workerClassName: String, workerParameters: WorkerParameters) =
+                    accountsCleanupWorkerFactory.create(appContext, workerParameters)
+            })
+            .build()
+        worker.deleteOrphanedAddressBookAccounts(addressBookAccounts)
+
+        // Verify account was deleted
+        assertTrue(accountManager.getAccountsByType(addressBookAccountType).isEmpty())
+    }
+
+    @Test
+    fun testDeleteOrphanedAddressBookAccounts_leavesAddressBookAccountWithCollection() {
+        // Create address book account _with_ corresponding collection and verify
+        val randomCollectionId = 12345L
+        val userData = Bundle(1).apply {
+            putString(USER_DATA_COLLECTION_ID, "$randomCollectionId")
+        }
+        assertTrue(accountManager.addAccountExplicitly(addressBookAccount, null, userData))
+
+        val addressBookAccounts = accountManager.getAccountsByType(addressBookAccountType)
+        assertEquals(randomCollectionId, accountManager.getUserData(addressBookAccount, USER_DATA_COLLECTION_ID).toLong())
+
+        // Create the collection
+        val collectionDao = db.collectionDao()
+        collectionDao.insert(Collection(
+            randomCollectionId,
+            serviceId = service.id,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = "http://www.example.com/yay.php".toHttpUrl()
+        ))
+
+        // Create worker and run the method
+        val worker = TestListenableWorkerBuilder<AccountsCleanupWorker>(context)
+            .setWorkerFactory(object: WorkerFactory() {
+                override fun createWorker(appContext: Context, workerClassName: String, workerParameters: WorkerParameters) =
+                    accountsCleanupWorkerFactory.create(appContext, workerParameters)
+            })
+            .build()
+        worker.deleteOrphanedAddressBookAccounts(addressBookAccounts)
+
+        // Verify account was _not_ deleted
+        assertEquals(addressBookAccount, addressBookAccounts.firstOrNull())
+    }
+
+
+    // helpers
+
+    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)!!
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/account/TestAccountAuthenticator.kt

@@ -0,0 +1,96 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+package at.bitfire.davdroid.sync.account
+
+import android.accounts.AbstractAccountAuthenticator
+import android.accounts.Account
+import android.accounts.AccountAuthenticatorResponse
+import android.accounts.AccountManager
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.test.R
+import org.junit.Assert.assertTrue
+
+/**
+ * Handles the test account type, which has no sync adapters and side effects that run unintentionally.
+ *
+ * Usually used like this:
+ *
+ * ```
+ * lateinit var account: Account
+ *
+ * @Before
+ * fun setUp() {
+ *     account = TestAccountAuthenticator.create()
+ *
+ *     // You can now use the test account.
+ * }
+ *
+ * @After
+ * fun tearDown() {
+ *    TestAccountAuthenticator.remove(account)
+ * }
+ * ```
+ */
+class TestAccountAuthenticator: Service() {
+
+    companion object {
+
+        val context by lazy { InstrumentationRegistry.getInstrumentation().context }
+
+        /**
+         * Creates a test account, usually in the `Before` setUp of a test.
+         *
+         * Remove it with [remove].
+         */
+        fun create(): Account {
+            val accountType = context.getString(R.string.account_type_test)
+            val account = Account("Test Account", accountType)
+
+            assertTrue(SystemAccountUtils.createAccount(context, account, AccountSettings.initialUserData(null)))
+
+            return account
+        }
+
+        /**
+         * Removes a test account, usually in the `@After` tearDown of a test.
+         */
+        fun remove(account: Account) {
+            val am = AccountManager.get(context)
+            am.removeAccountExplicitly(account)
+        }
+
+    }
+
+
+    private lateinit var accountAuthenticator: AccountAuthenticator
+
+
+    override fun onCreate() {
+        accountAuthenticator = AccountAuthenticator(this)
+    }
+
+    override fun onBind(intent: Intent?) =
+            accountAuthenticator.iBinder.takeIf { intent?.action == AccountManager.ACTION_AUTHENTICATOR_INTENT }
+
+
+    private class AccountAuthenticator(
+        val context: Context
+    ): AbstractAccountAuthenticator(context) {
+
+        override fun addAccount(response: AccountAuthenticatorResponse?, accountType: String?, authTokenType: String?, requiredFeatures: Array<String>?, options: Bundle?) = null
+        override fun editProperties(response: AccountAuthenticatorResponse?, accountType: String?) = null
+        override fun getAuthTokenLabel(p0: String?) = null
+        override fun confirmCredentials(p0: AccountAuthenticatorResponse?, p1: Account?, p2: Bundle?) = null
+        override fun updateCredentials(p0: AccountAuthenticatorResponse?, p1: Account?, p2: String?, p3: Bundle?) = null
+        override fun getAuthToken(p0: AccountAuthenticatorResponse?, p1: Account?, p2: String?, p3: Bundle?) = null
+        override fun hasFeatures(p0: AccountAuthenticatorResponse?, p1: Account?, p2: Array<out String>?) = null
+
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/worker/PeriodicSyncWorkerTest.kt

@@ -0,0 +1,103 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.sync.worker
+
+import android.accounts.Account
+import android.content.Context
+import android.provider.CalendarContract
+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.sync.account.TestAccountAuthenticator
+import at.bitfire.davdroid.test.R
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.mockkObject
+import io.mockk.verify
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class PeriodicSyncWorkerTest {
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+    val testContext = InstrumentationRegistry.getInstrumentation().context
+
+    @Inject
+    lateinit var syncWorkerFactory: PeriodicSyncWorker.Factory
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    lateinit var account: Account
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        // Initialize WorkManager for instrumentation tests.
+        val config = Configuration.Builder()
+            .setMinimumLoggingLevel(Log.DEBUG)
+            .build()
+        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
+
+        account = TestAccountAuthenticator.create()
+    }
+
+    @After
+    fun tearDown() {
+        TestAccountAuthenticator.remove(account)
+    }
+
+
+    @Test
+    fun doWork_cancelsItselfOnInvalidAccount() {
+        val invalidAccount = Account("invalid", testContext.getString(R.string.account_type_test))
+
+        // 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/androidTest/kotlin/at/bitfire/davdroid/sync/worker/SyncConditionsTest.kt

@@ -0,0 +1,280 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync.worker
+
+import android.accounts.Account
+import android.content.Context
+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 android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import androidx.core.content.getSystemService
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.sync.SyncConditions
+import at.bitfire.davdroid.util.PermissionUtils
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.junit4.MockKRule
+import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.spyk
+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 SyncConditionsTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule
+    val mockkRule = MockKRule(this)
+
+    @MockK
+    lateinit var capabilities: NetworkCapabilities
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var factory: SyncConditions.Factory
+
+    @MockK
+    lateinit var network1: Network
+
+    @MockK
+    lateinit var network2: Network
+
+
+    private lateinit var accountSettings: AccountSettings
+
+    private lateinit var conditions: SyncConditions
+
+    private lateinit var connectivityManager: ConnectivityManager
+
+    @Before
+    fun setup() {
+        hiltRule.inject()
+
+        // prepare accountSettings with some necessary data
+        accountSettings = mockk<AccountSettings> {
+            every { account } returns Account("test", "test")
+            every { getIgnoreVpns() } returns false     // default value
+        }
+
+        conditions = factory.create(accountSettings)
+
+        connectivityManager = context.getSystemService<ConnectivityManager>()!!.also { cm ->
+            mockkObject(cm)
+            every { cm.allNetworks } returns arrayOf(network1, network2)
+            every { cm.getNetworkInfo(network1) } returns mockk()
+            every { cm.getNetworkInfo(network2) } returns mockk()
+            every { cm.getNetworkCapabilities(network1) } returns capabilities
+            every { cm.getNetworkCapabilities(network2) } returns capabilities
+        }
+    }
+
+
+    @Test
+    fun testCorrectWifiSsid_CorrectWiFiSsid() {
+        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(conditions.correctWifiSsid())
+    }
+
+    @Test
+    fun testCorrectWifiSsid_WrongWiFiSsid() {
+        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(conditions.correctWifiSsid())
+    }
+
+
+    @Test
+    fun testInternetAvailable_capabilitiesNull() {
+        every { connectivityManager.getNetworkCapabilities(network1) } returns null
+        every { connectivityManager.getNetworkCapabilities(network2) } returns null
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_Internet() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_Validated() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns false
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_InternetValidated() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertTrue(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_ignoreVpns() {
+        every { accountSettings.getIgnoreVpns() } returns true
+        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(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_ignoreVpns_NotVpn() {
+        every { accountSettings.getIgnoreVpns() } returns true
+        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(conditions.internetAvailable())
+    }
+
+    @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(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_twoConnectionsFirstOneWithoutValidated() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false andThen true
+        assertTrue(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_twoConnectionsFirstOneWithoutNotVpn() {
+        every { accountSettings.getIgnoreVpns() } returns true
+        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(conditions.internetAvailable())
+    }
+    
+
+    @Test
+    fun testWifiAvailable_capabilitiesNull() {
+        every { connectivityManager.getNetworkCapabilities(network1) } returns null
+        every { connectivityManager.getNetworkCapabilities(network2) } returns null
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns false
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable_wifi() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable_validated() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns false
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable_wifiValidated() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertTrue(conditions.wifiAvailable())
+    }
+
+
+    @Test
+    fun testWifiConditionsMet_withoutWifi() {
+        // "Sync only over Wi-Fi" is disabled
+        every { accountSettings.getSyncWifiOnly() } returns false
+
+        assertTrue(factory.create(accountSettings).wifiConditionsMet())
+    }
+
+    @Test
+    fun testWifiConditionsMet_anyWifi_wifiEnabled() {
+        // "Sync only over Wi-Fi" is enabled
+        every { accountSettings.getSyncWifiOnly() } returns true
+
+        // Wi-Fi is available
+        mockkObject(conditions) {
+            // Wi-Fi is available
+            every { conditions.wifiAvailable() } returns true
+
+            // Wi-Fi SSID is correct
+            every { conditions.correctWifiSsid() } returns true
+
+            assertTrue(conditions.wifiConditionsMet())
+        }
+    }
+
+    @Test
+    fun testWifiConditionsMet_anyWifi_wifiDisabled() {
+        // "Sync only over Wi-Fi" is enabled
+        every { accountSettings.getSyncWifiOnly() } returns true
+
+        mockkObject(conditions) {
+            // Wi-Fi is not available
+            every { conditions.wifiAvailable() } returns false
+
+            // Wi-Fi SSID is correct
+            every { conditions.correctWifiSsid() } returns true
+
+            assertFalse(conditions.wifiConditionsMet())
+        }
+    }
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/sync/worker/SyncWorkerManagerTest.kt

@@ -0,0 +1,99 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync.worker
+
+import android.accounts.Account
+import android.content.Context
+import android.provider.CalendarContract
+import android.util.Log
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.Configuration
+import androidx.work.testing.WorkManagerTestInitHelper
+import at.bitfire.davdroid.TestUtils
+import at.bitfire.davdroid.TestUtils.workScheduledOrRunning
+import at.bitfire.davdroid.sync.account.TestAccountAuthenticator
+import dagger.hilt.android.qualifiers.ApplicationContext
+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 SyncWorkerManagerTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var syncWorkerManager: SyncWorkerManager
+
+    @Inject
+    lateinit var workerFactory: HiltWorkerFactory
+
+    lateinit var account: Account
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        // Initialize WorkManager for instrumentation tests.
+        val config = Configuration.Builder()
+            .setMinimumLoggingLevel(Log.DEBUG)
+            .setWorkerFactory(workerFactory)
+            .build()
+        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
+
+        account = TestAccountAuthenticator.create()
+    }
+
+    @After
+    fun tearDown() {
+        TestAccountAuthenticator.remove(account)
+    }
+
+
+    // one-time sync workers
+
+    @Test
+    fun testEnqueueOneTime() {
+        val workerName = OneTimeSyncWorker.workerName(account, CalendarContract.AUTHORITY)
+        assertFalse(TestUtils.workScheduledOrRunningOrSuccessful(context, workerName))
+
+        val returnedName = syncWorkerManager.enqueueOneTime(account, CalendarContract.AUTHORITY)
+        assertEquals(workerName, returnedName)
+        assertTrue(TestUtils.workScheduledOrRunningOrSuccessful(context, workerName))
+    }
+
+
+    // periodic sync workers
+
+    @Test
+    fun enablePeriodic() {
+        syncWorkerManager.enablePeriodic(account, CalendarContract.AUTHORITY, 60, false).result.get()
+
+        val workerName = PeriodicSyncWorker.workerName(account, CalendarContract.AUTHORITY)
+        assertTrue(workScheduledOrRunning(context, workerName))
+    }
+
+    @Test
+    fun disablePeriodic() {
+        syncWorkerManager.enablePeriodic(account, CalendarContract.AUTHORITY, 60, false).result.get()
+        syncWorkerManager.disablePeriodic(account, CalendarContract.AUTHORITY).result.get()
+
+        val workerName = PeriodicSyncWorker.workerName(account, CalendarContract.AUTHORITY)
+        assertFalse(workScheduledOrRunning(context, workerName))
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/ui/DebugInfoActivityTest.kt

@@ -1,6 +1,6 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.ui
 
@@ -14,10 +14,10 @@ class DebugInfoActivityTest {
     fun testIntentBuilder_LargeLocalResource() {
         val a = 'A'.code.toByte()
         val intent = DebugInfoActivity.IntentBuilder(InstrumentationRegistry.getInstrumentation().context)
-            .withLocalResource(String(ByteArray(1024*1024, { a })))
+            .withLocalResource(String(ByteArray(1024*1024) { a }))
             .build()
         val expected = StringBuilder(DebugInfoActivity.IntentBuilder.MAX_ELEMENT_SIZE)
-        expected.append(String(ByteArray(DebugInfoActivity.IntentBuilder.MAX_ELEMENT_SIZE - 3, { a })))
+        expected.append(String(ByteArray(DebugInfoActivity.IntentBuilder.MAX_ELEMENT_SIZE - 3) { a }))
         expected.append("...")
         assertEquals(expected.toString(), intent.getStringExtra("localResource"))
     }
@@ -26,10 +26,10 @@ class DebugInfoActivityTest {
     fun testIntentBuilder_LargeLogs() {
         val a = 'A'.code.toByte()
         val intent = DebugInfoActivity.IntentBuilder(InstrumentationRegistry.getInstrumentation().context)
-            .withLogs(String(ByteArray(1024*1024, { a })))
+            .withLogs(String(ByteArray(1024*1024) { a }))
             .build()
         val expected = StringBuilder(DebugInfoActivity.IntentBuilder.MAX_ELEMENT_SIZE)
-        expected.append(String(ByteArray(DebugInfoActivity.IntentBuilder.MAX_ELEMENT_SIZE - 3, { a })))
+        expected.append(String(ByteArray(DebugInfoActivity.IntentBuilder.MAX_ELEMENT_SIZE - 3) { a }))
         expected.append("...")
         assertEquals(expected.toString(), intent.getStringExtra("logs"))
     }

app/src/androidTest/kotlin/at/bitfire/davdroid/webdav/CredentialsStoreTest.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.webdav
+
+import at.bitfire.davdroid.db.Credentials
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class CredentialsStoreTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var store: CredentialsStore
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+    }
+
+    @Test
+    fun testSetGetDelete() {
+        store.setCredentials(0, Credentials(username = "myname", password = "12345"))
+        assertEquals(Credentials(username = "myname", password = "12345"), store.getCredentials(0))
+
+        store.setCredentials(0, null)
+        assertNull(store.getCredentials(0))
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/webdav/DavDocumentsProviderTest.kt

@@ -1,20 +1,17 @@
-/***************************************************************************************************
+/*
  * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
+ */
 
 package at.bitfire.davdroid.webdav
 
 import android.content.Context
 import android.security.NetworkSecurityPolicy
-import androidx.test.platform.app.InstrumentationRegistry
-import at.bitfire.davdroid.network.HttpClient
 import at.bitfire.davdroid.R
 import at.bitfire.davdroid.db.AppDatabase
-import at.bitfire.davdroid.db.Credentials
 import at.bitfire.davdroid.db.WebDavDocument
 import at.bitfire.davdroid.db.WebDavMount
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.ui.setup.LoginModel
+import at.bitfire.davdroid.network.HttpClient
+import dagger.hilt.android.qualifiers.ApplicationContext
 import dagger.hilt.android.testing.HiltAndroidRule
 import dagger.hilt.android.testing.HiltAndroidTest
 import okhttp3.CookieJar
@@ -28,46 +25,46 @@ import org.junit.Assert.assertTrue
 import org.junit.Before
 import org.junit.Rule
 import org.junit.Test
-import java.net.URI
 import javax.inject.Inject
 
 @HiltAndroidTest
 class DavDocumentsProviderTest {
 
+    companion object {
+        private const val PATH_WEBDAV_ROOT = "/webdav"
+    }
+
     @get:Rule
     val hiltRule = HiltAndroidRule(this)
 
-    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
 
-    @Inject lateinit var db: AppDatabase
+    @Inject
+    lateinit var db: AppDatabase
+
+    @Inject
+    lateinit var logger: java.util.logging.Logger
 
     @Before
     fun setUp() {
         hiltRule.inject()
     }
 
+
     private var mockServer =  MockWebServer()
 
     private lateinit var client: HttpClient
-    private lateinit var loginModel: LoginModel
 
-    companion object {
-        private const val PATH_WEBDAV_ROOT = "/webdav"
-    }
 
     @Before
     fun mockServerSetup() {
         // Start mock web server
-        mockServer.dispatcher = TestDispatcher()
+        mockServer.dispatcher = TestDispatcher(logger)
         mockServer.start()
 
-        loginModel = LoginModel()
-        loginModel.baseURI = URI.create("/")
-        loginModel.credentials = Credentials("mock", "12345")
-
-        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
-            .addAuthentication(null, loginModel.credentials!!)
-            .build()
+        client = HttpClient.Builder(context).build()
 
         // mock server delivers HTTP without encryption
         assertTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
@@ -89,7 +86,7 @@ class DavDocumentsProviderTest {
         val cookieStore = mutableMapOf<Long, CookieJar>()
 
         // Query
-        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+        DavDocumentsProvider.DavDocumentsActor(context, db, logger, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
             .queryChildren(parent)
 
         // Assert new children were inserted into db
@@ -123,7 +120,7 @@ class DavDocumentsProviderTest {
         assertEquals("My Books", db.webDavDocumentDao().get(folderId)!!.displayName)
 
         // Query - should update the parent displayname and folder name
-        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+        DavDocumentsProvider.DavDocumentsActor(context, db, logger, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
             .queryChildren(parent)
 
         // Assert parent and children were updated in database
@@ -148,7 +145,7 @@ class DavDocumentsProviderTest {
         assertEquals("deleteme", db.webDavDocumentDao().get(folderId)!!.name)
 
         // Query - discovers serverside deletion
-        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+        DavDocumentsProvider.DavDocumentsActor(context, db, logger, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
             .queryChildren(parent)
 
         // Assert folder got deleted
@@ -172,9 +169,9 @@ class DavDocumentsProviderTest {
         assertEquals("parent2", parent2.name)
 
         // Query - find children of two nodes simultaneously
-        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+        DavDocumentsProvider.DavDocumentsActor(context, db, logger, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
             .queryChildren(parent1)
-        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+        DavDocumentsProvider.DavDocumentsActor(context, db, logger, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
             .queryChildren(parent2)
 
         // Assert the two folders names have changed
@@ -185,7 +182,9 @@ class DavDocumentsProviderTest {
 
     // mock server
 
-    class TestDispatcher: Dispatcher() {
+    class TestDispatcher(
+        private val logger: java.util.logging.Logger
+    ): Dispatcher() {
 
         data class Resource(
             val name: String,
@@ -240,8 +239,8 @@ class DavDocumentsProviderTest {
                         responses +
                     "</multistatus>"
 
-                Logger.log.info("Query path: $requestPath")
-                Logger.log.info("Response: $multistatus")
+                logger.info("Query path: $requestPath")
+                logger.info("Response: $multistatus")
                 return MockResponse()
                     .setResponseCode(207)
                     .setBody(multistatus)

app/src/androidTest/kotlin/at/bitfire/davdroid/webdav/WebDavMountRepositoryTest.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.webdav
+
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import kotlinx.coroutines.runBlocking
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+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 WebDavMountRepositoryTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var repository: WebDavMountRepository
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+    }
+
+    val web = MockWebServer()
+    val url = web.url("/")
+
+    @Test
+    fun testHasWebDav_NoDavHeader() = runBlocking {
+        web.enqueue(MockResponse().setResponseCode(200))
+        assertFalse(repository.hasWebDav(url, null))
+    }
+
+    @Test
+    fun testHasWebDav_DavClass1() = runBlocking {
+        web.enqueue(MockResponse()
+            .setResponseCode(200)
+            .addHeader("DAV: 1"))
+        assertTrue(repository.hasWebDav(url, null))
+    }
+
+    @Test
+    fun testHasWebDav_DavClass2() = runBlocking {
+        web.enqueue(MockResponse()
+            .setResponseCode(200)
+            .addHeader("DAV: 1, 2"))
+        assertTrue(repository.hasWebDav(url, null))
+    }
+
+    @Test
+    fun testHasWebDav_DavClass3() = runBlocking {
+        web.enqueue(MockResponse()
+            .setResponseCode(200)
+            .addHeader("DAV: 1, 3"))
+        assertTrue(repository.hasWebDav(url, null))
+    }
+
+}

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

@@ -10,5 +10,6 @@
 <resources>
 
     <string name="app_name">Davx5Test</string>
+    <string name="account_type_test">at.bitfire.davdroid.test</string>
 
-</resources>
+</resources>

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

@@ -1,3 +1,5 @@
 <account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
-    android:accountType="at.bitfire.davdroid.SyncManagerTest"
+    android:accountType="@string/account_type_test"
+    android:icon="@android:drawable/star_on"
+    android:smallIcon="@android:drawable/star_on"
     android:label="Test Account" />

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

@@ -1,126 +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.provider.CalendarContract
-import android.provider.ContactsContract
-import android.util.Log
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.work.Configuration
-import androidx.work.testing.TestWorkerBuilder
-import androidx.work.testing.WorkManagerTestInitHelper
-import androidx.work.workDataOf
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.TestUtils
-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 at.bitfire.ical4android.TaskProvider
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import org.junit.After
-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 java.util.concurrent.Executors
-
-@HiltAndroidTest
-class PeriodicSyncWorkerTest {
-
-    companion object {
-
-        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")
-
-        @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)
-        }
-
-    }
-
-    private val executor = Executors.newSingleThreadExecutor()
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
-
-    @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_immediatelyEnqueuesSyncWorkerForGivenAuthority() {
-        val authorities = listOf(
-            context.getString(R.string.address_books_authority),
-            CalendarContract.AUTHORITY,
-            ContactsContract.AUTHORITY,
-            TaskProvider.ProviderName.JtxBoard.authority,
-            TaskProvider.ProviderName.OpenTasks.authority,
-            TaskProvider.ProviderName.TasksOrg.authority
-        )
-        for (authority in authorities) {
-            val inputData = workDataOf(
-                PeriodicSyncWorker.ARG_AUTHORITY to authority,
-                PeriodicSyncWorker.ARG_ACCOUNT_NAME to account.name,
-                PeriodicSyncWorker.ARG_ACCOUNT_TYPE to account.type
-            )
-            // Run PeriodicSyncWorker as TestWorker
-            TestWorkerBuilder<PeriodicSyncWorker>(context, executor, inputData).build().doWork()
-
-            // Check the PeriodicSyncWorker enqueued the right SyncWorker
-            assertTrue(TestUtils.workScheduledOrRunningOrSuccessful(context,
-                SyncWorker.workerName(account, authority)
-            ))
-        }
-    }
-
-}

app/src/androidTestOse/java/at/bitfire/davdroid/syncadapter/SyncWorkerTest.kt

@@ -1,156 +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.provider.CalendarContract
-import android.provider.ContactsContract
-import android.util.Log
-import androidx.test.platform.app.InstrumentationRegistry
-import androidx.work.Configuration
-import androidx.work.testing.TestWorkerBuilder
-import androidx.work.testing.WorkManagerTestInitHelper
-import androidx.work.workDataOf
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.TestUtils.workScheduledOrRunningOrSuccessful
-import at.bitfire.davdroid.db.Credentials
-import at.bitfire.davdroid.settings.AccountSettings
-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.mockk
-import io.mockk.mockkObject
-import org.junit.After
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNotNull
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Rule
-import org.junit.Test
-import java.util.concurrent.Executors
-
-@HiltAndroidTest
-class SyncWorkerTest {
-
-    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")
-
-    private val executor = Executors.newSingleThreadExecutor()
-
-    @get:Rule
-    val hiltRule = HiltAndroidRule(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 testEnqueue_enqueuesWorker() {
-        SyncWorker.enqueue(context, account, CalendarContract.AUTHORITY)
-        val workerName = SyncWorker.workerName(account, CalendarContract.AUTHORITY)
-        assertTrue(workScheduledOrRunningOrSuccessful(context, workerName))
-    }
-
-    @Test
-    fun testWifiConditionsMet_withoutWifi() {
-        val accountSettings = mockk<AccountSettings>()
-        every { accountSettings.getSyncWifiOnly() } returns false
-        assertTrue(SyncWorker.wifiConditionsMet(context, accountSettings))
-    }
-    
-    @Test
-    fun testWifiConditionsMet_anyWifi_wifiEnabled() {
-        val accountSettings = AccountSettings(context, account)
-        accountSettings.setSyncWiFiOnly(true)
-
-        mockkObject(SyncWorker.Companion)
-        every { SyncWorker.Companion.wifiAvailable(any()) } returns true
-        every { SyncWorker.Companion.correctWifiSsid(any(), any()) } returns true
-
-        assertTrue(SyncWorker.wifiConditionsMet(context, accountSettings))
-    }
-
-    @Test
-    fun testWifiConditionsMet_anyWifi_wifiDisabled() {
-        val accountSettings = AccountSettings(context, account)
-        accountSettings.setSyncWiFiOnly(true)
-
-        mockkObject(SyncWorker.Companion)
-        every { SyncWorker.Companion.wifiAvailable(any()) } returns false
-        every { SyncWorker.Companion.correctWifiSsid(any(), any()) } returns true
-
-        assertFalse(SyncWorker.wifiConditionsMet(context, accountSettings))
-    }
-
-
-    @Test
-    fun testWifiConditionsMet_correctWifiSsid() {
-        // TODO: Write test
-    }
-
-    @Test
-    fun testWifiConditionsMet_wrongWifiSsid() {
-        // TODO: Write test
-    }
-
-
-    @Test
-    fun testOnStopped_interruptsSyncThread() {
-        val authority = CalendarContract.AUTHORITY
-        val inputData = workDataOf(
-            SyncWorker.ARG_AUTHORITY to authority,
-            SyncWorker.ARG_ACCOUNT_NAME to account.name,
-            SyncWorker.ARG_ACCOUNT_TYPE to account.type
-        )
-
-        // Create SyncWorker as TestWorker
-        val testSyncWorker = TestWorkerBuilder<SyncWorker>(context, executor, inputData).build()
-        assertNull(testSyncWorker.syncThread)
-
-        // Run SyncWorker and assert sync thread is alive
-        testSyncWorker.doWork()
-        assertNotNull(testSyncWorker.syncThread)
-        assertTrue(testSyncWorker.syncThread!!.isAlive)
-        assertFalse(testSyncWorker.syncThread!!.isInterrupted) // Sync running
-
-        // Stop SyncWorker and assert sync thread was interrupted
-        testSyncWorker.onStopped()
-        assertNotNull(testSyncWorker.syncThread)
-        assertTrue(testSyncWorker.syncThread!!.isAlive)
-        assertTrue(testSyncWorker.syncThread!!.isInterrupted) // Sync thread interrupted
-    }
-
-}

app/src/androidTestOse/java/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/debug/res/values/colors.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <color name="primaryColor">#E07C25</color>
+    <color name="primaryLightColor">#E5A371</color>
+    <color name="primaryDarkColor">#7C3E07</color>
+</resources>

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

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name" translatable="false">DAVx⁵ Debug</string>
+</resources>

app/src/main/AndroidManifest.xml

@@ -6,7 +6,6 @@
     <!-- normal permissions -->
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
     <uses-permission android:name="android.permission.INTERNET"/>
     <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
     <uses-permission android:name="android.permission.READ_SYNC_SETTINGS"/>
@@ -50,7 +49,7 @@
         android:networkSecurityConfig="@xml/network_security_config"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
-        android:theme="@style/AppTheme"
+        android:theme="@style/Theme.AppCompat.DayNight.NoActionBar"
         android:resizeableActivity="true"
         tools:ignore="UnusedAttribute"
         android:supportsRtl="true">
@@ -62,13 +61,13 @@
             tools:node="remove">
         </provider>
 
-        <service android:name=".ForegroundService"/>
+        <!-- Remove the node added by AppAuth (remove only from net.openid.appauth library, not from our flavor manifest files) -->
+        <activity android:name="net.openid.appauth.RedirectUriReceiverActivity"
+            tools:node="remove" tools:selector="net.openid.appauth"/>
 
-        <activity android:name=".ui.intro.IntroActivity" android:theme="@style/AppTheme.NoActionBar" />
+        <activity android:name=".ui.intro.IntroActivity" />
         <activity
             android:name=".ui.AccountsActivity"
-            android:label="@string/app_name"
-            android:theme="@style/AppTheme.NoActionBar"
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
@@ -79,7 +78,6 @@
         <activity
             android:name=".ui.AboutActivity"
             android:label="@string/navigation_drawer_about"
-            android:theme="@style/AppTheme.NoActionBar"
             android:parentActivityName=".ui.AccountsActivity"/>
 
         <activity
@@ -113,8 +111,8 @@
 
         <activity
             android:name=".ui.setup.LoginActivity"
-            android:label="@string/login_title"
             android:parentActivityName=".ui.AccountsActivity"
+            android:windowSoftInputMode="adjustResize"
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
@@ -132,7 +130,9 @@
             <intent-filter>
                 <action android:name="loginFlow" /> <!-- Ensures this filter matches, even if the sending app is not defining an action -->
                 <category android:name="android.intent.category.DEFAULT" />
-                <data android:scheme="http" />
+                <data
+                    tools:ignore="AppLinkUrlError"
+                    android:scheme="http" />
                 <data android:scheme="https" />
             </intent-filter>
         </activity>
@@ -140,38 +140,36 @@
         <activity
             android:name=".ui.account.AccountActivity"
             android:parentActivityName=".ui.AccountsActivity"
-            android:theme="@style/AppTheme.NoActionBar"
             android:exported="true">
         </activity>
+        <activity
+            android:name=".ui.account.CollectionActivity"
+            android:parentActivityName=".ui.account.AccountActivity" />
         <activity
             android:name=".ui.account.CreateAddressBookActivity"
-            android:label="@string/create_addressbook"
             android:parentActivityName=".ui.account.AccountActivity" />
         <activity
             android:name=".ui.account.CreateCalendarActivity"
-            android:label="@string/create_calendar"
             android:parentActivityName=".ui.account.AccountActivity" />
         <activity
-            android:name=".ui.account.SettingsActivity"
+            android:name=".ui.account.AccountSettingsActivity"
             android:parentActivityName=".ui.account.AccountActivity" />
         <activity
             android:name=".ui.account.WifiPermissionsActivity"
-            android:label="@string/wifi_permissions_label"
-            android:parentActivityName=".ui.account.SettingsActivity" />
+            android:parentActivityName=".ui.account.AccountSettingsActivity" />
 
         <activity
             android:name=".ui.webdav.WebdavMountsActivity"
-            android:label="@string/webdav_mounts_title"
-            android:parentActivityName=".ui.AccountsActivity"
-            android:exported="true" />
+            android:exported="true"
+            android:parentActivityName=".ui.AccountsActivity" />
         <activity
             android:name=".ui.webdav.AddWebdavMountActivity"
-            android:label="@string/webdav_add_mount_title"
-            android:parentActivityName=".ui.webdav.WebdavMountsActivity" />
+            android:parentActivityName=".ui.webdav.WebdavMountsActivity"
+            android:windowSoftInputMode="adjustResize" />
 
         <!-- account type "DAVx⁵" -->
         <service
-            android:name=".syncadapter.AccountAuthenticatorService"
+            android:name=".sync.account.AccountAuthenticatorService"
             android:exported="false">
             <intent-filter>
                 <action android:name="android.accounts.AccountAuthenticator"/>
@@ -181,7 +179,7 @@
                 android:resource="@xml/account_authenticator"/>
         </service>
         <service
-            android:name=".syncadapter.CalendarsSyncAdapterService"
+            android:name=".sync.CalendarsSyncAdapterService"
             android:exported="true"
             tools:ignore="ExportedService">
             <intent-filter>
@@ -192,7 +190,7 @@
                 android:resource="@xml/sync_calendars"/>
         </service>
         <service
-            android:name=".syncadapter.JtxSyncAdapterService"
+            android:name=".sync.JtxSyncAdapterService"
             android:exported="true"
             tools:ignore="ExportedService">
             <intent-filter>
@@ -203,7 +201,7 @@
                 android:resource="@xml/sync_notes"/>
         </service>
         <service
-            android:name=".syncadapter.OpenTasksSyncAdapterService"
+            android:name=".sync.OpenTasksSyncAdapterService"
             android:exported="true"
             tools:ignore="ExportedService">
             <intent-filter>
@@ -214,7 +212,7 @@
                 android:resource="@xml/sync_opentasks"/>
         </service>
         <service
-            android:name=".syncadapter.TasksOrgSyncAdapterService"
+            android:name=".sync.TasksOrgSyncAdapterService"
             android:exported="true"
             tools:ignore="ExportedService">
             <intent-filter>
@@ -237,8 +235,9 @@
 
         <!-- account type "DAVx⁵ Address book" -->
         <service
-            android:name=".syncadapter.AddressBookAuthenticatorService"
-            android:exported="true">   <!-- Since Android 11, this must be true so that Google Contacts shows the address book accounts -->
+            android:name=".sync.account.AddressBookAuthenticatorService"
+            android:exported="true"
+            tools:ignore="ExportedService">   <!-- Since Android 11, this must be true so that Google Contacts shows the address book accounts -->
             <intent-filter>
                 <action android:name="android.accounts.AccountAuthenticator"/>
             </intent-filter>
@@ -247,25 +246,8 @@
                 android:name="android.accounts.AccountAuthenticator"
                 android:resource="@xml/account_authenticator_address_book"/>
         </service>
-        <provider
-            android:authorities="@string/address_books_authority"
-            android:exported="false"
-            android:label="@string/address_books_authority_title"
-            android:name=".syncadapter.AddressBookProvider" />
         <service
-            android:name=".syncadapter.AddressBooksSyncAdapterService"
-            android:exported="true"
-            tools:ignore="ExportedService">
-            <intent-filter>
-                <action android:name="android.content.SyncAdapter"/>
-            </intent-filter>
-
-            <meta-data
-                android:name="android.content.SyncAdapter"
-                android:resource="@xml/sync_address_books"/>
-        </service>
-        <service
-            android:name=".syncadapter.ContactsSyncAdapterService"
+            android:name=".sync.ContactsSyncAdapterService"
             android:exported="true"
             tools:ignore="ExportedService">
             <intent-filter>
@@ -290,6 +272,29 @@
                 android:name="android.support.FILE_PROVIDER_PATHS"
                 android:resource="@xml/debug_paths" />
         </provider>
+
+        <!-- UnifiedPush receiver -->
+        <receiver android:exported="true"  android:enabled="true"  android:name=".push.UnifiedPushReceiver" tools:ignore="ExportedReceiver">
+            <intent-filter>
+                <action android:name="org.unifiedpush.android.connector.MESSAGE"/>
+                <action android:name="org.unifiedpush.android.connector.UNREGISTERED"/>
+                <action android:name="org.unifiedpush.android.connector.NEW_ENDPOINT"/>
+                <action android:name="org.unifiedpush.android.connector.REGISTRATION_FAILED"/>
+            </intent-filter>
+        </receiver>
+
+        <!-- Widgets -->
+        <receiver android:name=".ui.widget.SyncButtonWidgetReceiver"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.appwidget.provider"
+                android:resource="@xml/widget_info_sync_button" />
+        </receiver>
+
     </application>
 
     <!-- package visiblity – which apps do we need to see? -->
@@ -329,4 +334,4 @@
         </intent>
     </queries>
 
-</manifest>
+</manifest>

app/src/main/assets/known-base-urls.txt

@@ -1,28 +0,0 @@
-carddav.a1.net
-aol.com
-calendar.dingtalk.com/dav/
-cloud.disroot.org
-dav.edis.at
-dav.fruux.com
-caldav.gmx.net
-carddav.gmx.net
-framagenda.org/remote.php/dav/
-icloud.com
-cloud.liberta.vip
-office.luckycloud.de
-calendar.mail.ru
-dav.mailbox.org
-mailfence.com
-caldav.mailo.com
-carddav.mailo.com
-posteo.de:8443
-dav.runbox.com
-live.teambox.eu
-spica.t-online.de
-caldav.calendar.yahoo.com
-yandex.ru
-webmail.your-server.de/rpc.php/
-calendar.zoho.com
-calendar.zoho.eu
-contacts.zoho.com
-contacts.zoho.eu

app/src/main/assets/logging.properties

@@ -0,0 +1,4 @@
+
+# reduce verbose of some otherwise annoying ical4j messages
+net.fortuna.ical4j.data.level = INFO
+net.fortuna.ical4j.model.Recur.level = INFO

app/src/main/assets/translators.json

@@ -1 +1 @@
-{"ar_SA":["abdunnasir"],"bg":["dpa_transifex"],"ca":["Kintu","jordibrus","zagur"],"cs":["pavelb","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","Llorc","LoiX07","Novick","Poussinou","Thecross","YvanM","alkino2","boutil","callmemagnus","chfo","chrcha","grenatrad","jokx","mathieugfortin","paullbn","vincen","ÉricB."],"fr_FR":["Llorc","Poussinou","chrcha"],"gl":["aluaces","pikamoku"],"hu":["Roshek","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","toonvangerwen"],"pl":["TORminator","TheName","Valdnet","gsz","mg6","oskarjakiela"],"pt":["amalvarenga","wanderlei.huttel"],"pt_BR":["wanderlei.huttel"],"ru":["aigoshin","anm","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"]}
+{"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/java/at/bitfire/davdroid/App.kt

@@ -1,111 +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.content.Context
-import android.net.Uri
-import android.os.StrictMode
-import androidx.appcompat.content.res.AppCompatResources
-import androidx.core.graphics.drawable.toBitmap
-import androidx.hilt.work.HiltWorkerFactory
-import androidx.work.Configuration
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.syncadapter.AccountsUpdatedListener
-import at.bitfire.davdroid.syncadapter.SyncUtils
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.UiUtils
-import dagger.hilt.android.HiltAndroidApp
-import java.util.logging.Level
-import javax.inject.Inject
-import kotlin.concurrent.thread
-import kotlin.system.exitProcess
-
-@HiltAndroidApp
-class App: Application(), Thread.UncaughtExceptionHandler, Configuration.Provider {
-
-    companion object {
-
-        fun getLauncherBitmap(context: Context) =
-                AppCompatResources.getDrawable(context, R.mipmap.ic_launcher)?.toBitmap()
-
-        fun homepageUrl(context: Context) =
-                Uri.parse(context.getString(R.string.homepage_url)).buildUpon()
-                        .appendQueryParameter("pk_campaign", BuildConfig.APPLICATION_ID)
-                        .appendQueryParameter("pk_kwd", context::class.java.simpleName)
-                        .appendQueryParameter("app-version", BuildConfig.VERSION_NAME)
-                        .build()!!
-
-    }
-
-    @Inject lateinit var accountsUpdatedListener: AccountsUpdatedListener
-    @Inject lateinit var storageLowReceiver: StorageLowReceiver
-
-    @Inject lateinit var workerFactory: HiltWorkerFactory
-
-    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.setTheme(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
-        thread {
-            // watch for account changes/deletions
-            accountsUpdatedListener.listen()
-
-            // foreground service (possible workaround for devices which prevent DAVx5 from being started)
-            ForegroundService.startIfActive(this)
-
-            // watch storage because low storage means synchronization is stopped
-            storageLowReceiver.listen()
-
-            // watch installed/removed apps
-            TasksWatcher.watch(this)
-            // check whether a tasks app is currently installed
-            SyncUtils.updateTaskSync(this)
-
-            // create/update app shortcuts
-            UiUtils.updateShortcuts(this)
-        }
-    }
-
-    override fun getWorkManagerConfiguration() =
-        Configuration.Builder()
-            .setWorkerFactory(workerFactory)
-            .build()
-
-    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/java/at/bitfire/davdroid/Constants.kt

@@ -1,27 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-package at.bitfire.davdroid
-
-object Constants {
-
-    const val DAVDROID_GREEN_RGBA = 0xFF8bc34a.toInt()
-
-    // gplay billing
-    const val BILLINGCLIENT_CONNECTION_MAX_RETRIES = 4
-
-    /**
-     * Context label for [org.apache.commons.lang3.exception.ContextedException].
-     * Context value is the [at.bitfire.davdroid.resource.LocalResource]
-     * which is related to the exception cause.
-     */
-    const val EXCEPTION_CONTEXT_LOCAL_RESOURCE = "localResource"
-
-    /**
-     * Context label for [org.apache.commons.lang3.exception.ContextedException].
-     * Context value is the [okhttp3.HttpUrl] of the remote resource
-     * which is related to the exception cause.
-     */
-    const val EXCEPTION_CONTEXT_REMOTE_RESOURCE = "remoteResource"
-
-}

app/src/main/java/at/bitfire/davdroid/ForegroundService.kt

@@ -1,119 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid
-
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Context
-import android.content.Intent
-import android.os.Build
-import android.os.PowerManager
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.settings.SettingsManager
-import at.bitfire.davdroid.ui.AppSettingsActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.NotificationUtils.notifyIfPossible
-import dagger.hilt.EntryPoint
-import dagger.hilt.InstallIn
-import dagger.hilt.android.EntryPointAccessors
-import dagger.hilt.components.SingletonComponent
-
-class ForegroundService : Service() {
-
-    companion object {
-
-        @EntryPoint
-        @InstallIn(SingletonComponent::class)
-        interface ForegroundServiceEntryPoint {
-            fun settingsManager(): SettingsManager
-        }
-
-        /**
-         * Starts/stops a foreground service, according to the app setting [Settings.FOREGROUND_SERVICE]
-         * if [Settings.BATTERY_OPTIMIZATION] is enabled - meaning DAVx5 is whitelisted from optimization.
-         */
-        const val ACTION_FOREGROUND = "foreground"
-
-
-        /**
-         * Whether the app is currently exempted from battery optimization.
-         * @return true if battery optimization is not applied to the current app; false if battery optimization is applied
-         */
-        fun batteryOptimizationWhitelisted(context: Context) =
-            if (Build.VERSION.SDK_INT >= 23) {  // battery optimization exists since Android 6 (SDK level 23)
-                val powerManager = context.getSystemService(PowerManager::class.java)
-                powerManager.isIgnoringBatteryOptimizations(BuildConfig.APPLICATION_ID)
-            } else
-                true
-
-        /**
-         * Whether the foreground service is enabled (checked) in the app settings.
-         * @return true: foreground service enabled; false: foreground service not enabled
-         */
-        fun foregroundServiceActivated(context: Context): Boolean {
-            val settingsManager = EntryPointAccessors.fromApplication(context, ForegroundServiceEntryPoint::class.java).settingsManager()
-            return settingsManager.getBooleanOrNull(Settings.FOREGROUND_SERVICE) == true
-        }
-
-        /**
-         * Starts the foreground service when enabled in the app settings and applicable.
-         */
-        fun startIfActive(context: Context) {
-            if (foregroundServiceActivated(context)) {
-                if (batteryOptimizationWhitelisted(context)) {
-                    val serviceIntent = Intent(ACTION_FOREGROUND, null, context, ForegroundService::class.java)
-                    if (Build.VERSION.SDK_INT >= 26)
-                        context.startForegroundService(serviceIntent)
-                    else
-                        context.startService(serviceIntent)
-                } else
-                    notifyBatteryOptimization(context)
-            }
-        }
-
-        private fun notifyBatteryOptimization(context: Context) {
-            val settingsIntent = Intent(context, AppSettingsActivity::class.java).apply {
-                putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, Settings.BATTERY_OPTIMIZATION)
-            }
-            val pendingSettingsIntent = PendingIntent.getActivity(context, 0, settingsIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
-            val builder =
-                NotificationCompat.Builder(context, NotificationUtils.CHANNEL_DEBUG)
-                    .setSmallIcon(R.drawable.ic_warning_notify)
-                    .setContentTitle(context.getString(R.string.battery_optimization_notify_title))
-                    .setContentText(context.getString(R.string.battery_optimization_notify_text))
-                    .setContentIntent(pendingSettingsIntent)
-                    .setCategory(NotificationCompat.CATEGORY_ERROR)
-
-            val nm = NotificationManagerCompat.from(context)
-            nm.notifyIfPossible(NotificationUtils.NOTIFY_BATTERY_OPTIMIZATION, builder.build())
-        }
-    }
-
-
-    override fun onBind(intent: Intent?): Nothing? = null
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        if (foregroundServiceActivated(this)) {
-            val settingsIntent = Intent(this, AppSettingsActivity::class.java).apply {
-                putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, Settings.FOREGROUND_SERVICE)
-            }
-            val builder = NotificationCompat.Builder(this, NotificationUtils.CHANNEL_STATUS)
-                    .setSmallIcon(R.drawable.ic_foreground_notify)
-                    .setContentTitle(getString(R.string.foreground_service_notify_title))
-                    .setContentText(getString(R.string.foreground_service_notify_text))
-                    .setStyle(NotificationCompat.BigTextStyle())
-                    .setContentIntent(PendingIntent.getActivity(this, 0, settingsIntent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE))
-                    .setCategory(NotificationCompat.CATEGORY_STATUS)
-            startForeground(NotificationUtils.NOTIFY_FOREGROUND, builder.build())
-            return START_STICKY
-        } else {
-            stopForeground(true)
-            return START_NOT_STICKY
-        }
-    }
-
-}

app/src/main/java/at/bitfire/davdroid/PackageChangedReceiver.kt

@@ -1,29 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-
-abstract class PackageChangedReceiver(
-        val context: Context
-): BroadcastReceiver(), AutoCloseable {
-
-    init {
-        val filter = IntentFilter(Intent.ACTION_PACKAGE_ADDED).apply {
-            addAction(Intent.ACTION_PACKAGE_CHANGED)
-            addAction(Intent.ACTION_PACKAGE_REMOVED)
-            addDataScheme("package")
-        }
-        context.registerReceiver(this, filter)
-    }
-
-    override fun close() {
-        context.unregisterReceiver(this)
-    }
-
-}

app/src/main/java/at/bitfire/davdroid/StorageLowReceiver.kt

@@ -1,90 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid
-
-import android.app.PendingIntent
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.provider.Settings
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.lifecycle.MutableLiveData
-import at.bitfire.davdroid.log.Logger
-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 javax.inject.Singleton
-
-class StorageLowReceiver private constructor(
-    val context: Context
-): BroadcastReceiver(), AutoCloseable {
-
-    @Module
-    @InstallIn(SingletonComponent::class)
-    object StorageLowReceiverModule {
-        @Provides
-        @Singleton
-        fun storageLowReceiver(@ApplicationContext context: Context) = StorageLowReceiver(context)
-    }
-
-
-    val storageLow = MutableLiveData<Boolean>(false)
-
-    fun listen() {
-        Logger.log.fine("Listening for device storage low/OK broadcasts")
-        val filter = IntentFilter().apply {
-            addAction(Intent.ACTION_DEVICE_STORAGE_LOW)
-            addAction(Intent.ACTION_DEVICE_STORAGE_OK)
-        }
-        context.registerReceiver(this, filter)
-    }
-
-    override fun close() {
-        context.unregisterReceiver(this)
-    }
-
-
-    override fun onReceive(context: Context, intent: Intent) {
-        when (intent.action) {
-            Intent.ACTION_DEVICE_STORAGE_LOW -> onStorageLow()
-            Intent.ACTION_DEVICE_STORAGE_OK -> onStorageOk()
-        }
-    }
-
-    fun onStorageLow() {
-        Logger.log.warning("Low storage, sync will not be started by Android!")
-
-        storageLow.postValue(true)
-
-        val notify = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_SYNC_ERRORS)
-            .setSmallIcon(R.drawable.ic_storage_notify)
-            .setCategory(NotificationCompat.CATEGORY_ERROR)
-            .setContentTitle(context.getString(R.string.storage_low_notify_title))
-            .setContentText(context.getString(R.string.storage_low_notify_text))
-
-        val settingsIntent = Intent(Settings.ACTION_INTERNAL_STORAGE_SETTINGS)
-        if (settingsIntent.resolveActivity(context.packageManager) != null)
-            notify.setContentIntent(PendingIntent.getActivity(context, 0, settingsIntent, PendingIntent.FLAG_CANCEL_CURRENT or PendingIntent.FLAG_IMMUTABLE))
-
-        val nm = NotificationManagerCompat.from(context)
-        nm.notifyIfPossible(NotificationUtils.NOTIFY_LOW_STORAGE, notify.build())
-    }
-
-    fun onStorageOk() {
-        Logger.log.info("Storage OK again")
-
-        storageLow.postValue(false)
-
-        val nm = NotificationManagerCompat.from(context)
-        nm.cancel(NotificationUtils.NOTIFY_LOW_STORAGE)
-    }
-
-}

app/src/main/java/at/bitfire/davdroid/TasksWatcher.kt

@@ -1,31 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid
-
-import android.content.Context
-import android.content.Intent
-import at.bitfire.davdroid.syncadapter.SyncUtils.updateTaskSync
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-
-class TasksWatcher protected constructor(
-    context: Context
-): PackageChangedReceiver(context) {
-
-    companion object {
-
-        fun watch(context: Context) = TasksWatcher(context)
-
-    }
-
-
-    override fun onReceive(context: Context, intent: Intent) {
-        CoroutineScope(Dispatchers.Default).launch {
-            updateTaskSync(context)
-        }
-    }
-
-}

app/src/main/java/at/bitfire/davdroid/db/HomeSetDao.kt

@@ -1,51 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.db
-
-import androidx.lifecycle.LiveData
-import androidx.room.*
-
-@Dao
-interface HomeSetDao {
-
-    @Query("SELECT * FROM homeset WHERE id=:homesetId")
-    fun getById(homesetId: Long): HomeSet
-
-    @Query("SELECT * FROM homeset WHERE serviceId=:serviceId AND url=:url")
-    fun getByUrl(serviceId: Long, url: String): HomeSet?
-
-    @Query("SELECT * FROM homeset WHERE serviceId=:serviceId")
-    fun getByService(serviceId: Long): List<HomeSet>
-
-    @Query("SELECT * FROM homeset WHERE serviceId=:serviceId AND privBind")
-    fun getBindableByService(serviceId: Long): List<HomeSet>
-
-    @Query("SELECT COUNT(*) FROM homeset WHERE serviceId=:serviceId AND privBind")
-    fun hasBindableByServiceLive(serviceId: Long): LiveData<Boolean>
-
-    @Insert
-    fun insert(homeSet: HomeSet): Long
-
-    @Update
-    fun update(homeset: HomeSet)
-
-    /**
-     * Tries to insert new row, but updates existing row if already present.
-     * This method preserves the primary key, as opposed to using "@Insert(onConflict = OnConflictStrategy.REPLACE)"
-     * which will create a new row with incremented ID and thus breaks entity relationships!
-     *
-     * @return ID of the row, that has been inserted or updated. -1 If the insert fails due to other reasons.
-     */
-    @Transaction
-    fun insertOrUpdateByUrl(homeset: HomeSet): Long =
-        getByUrl(homeset.serviceId, homeset.url.toString())?.let { existingHomeset ->
-            update(homeset.copy(id = existingHomeset.id))
-            existingHomeset.id
-        } ?: insert(homeset)
-
-    @Delete
-    fun delete(homeset: HomeSet)
-
-}

app/src/main/java/at/bitfire/davdroid/db/WebDavMountDao.kt

@@ -1,31 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.db
-
-import androidx.lifecycle.LiveData
-import androidx.room.Dao
-import androidx.room.Delete
-import androidx.room.Insert
-import androidx.room.Query
-
-@Dao
-interface WebDavMountDao {
-
-    @Delete
-    fun delete(mount: WebDavMount)
-
-    @Query("SELECT * FROM webdav_mount ORDER BY name, url")
-    fun getAll(): List<WebDavMount>
-
-    @Query("SELECT * FROM webdav_mount ORDER BY name, url")
-    fun getAllLive(): LiveData<List<WebDavMount>>
-
-    @Query("SELECT * FROM webdav_mount WHERE id=:id")
-    fun getById(id: Long): WebDavMount
-
-    @Insert
-    fun insert(mount: WebDavMount): Long
-
-}

app/src/main/java/at/bitfire/davdroid/di/SyncComponent.kt

@@ -1,72 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.di
-
-import at.bitfire.davdroid.log.Logger
-import dagger.hilt.DefineComponent
-import dagger.hilt.components.SingletonComponent
-import java.lang.ref.WeakReference
-import javax.inject.Inject
-import javax.inject.Provider
-import javax.inject.Scope
-import javax.inject.Singleton
-
-@Scope
-@Retention(AnnotationRetention.BINARY)
-annotation class SyncScoped
-
-/**
- * Custom Hilt component for running syncs, lifetime managed by [SyncComponentManager].
- * Dependencies installed in this component and scoped with [SyncScoped] (like SyncValidators)
- * will have a lifetime of all active syncs.
- */
-@SyncScoped
-@DefineComponent(parent = SingletonComponent::class)
-interface SyncComponent
-
-@DefineComponent.Builder
-interface SyncComponentBuilder {
-    fun build(): SyncComponent
-}
-
-/**
- * Manages the lifecycle of [SyncComponent] by using [WeakReference].
- *
- * @sample at.bitfire.davdroid.syncadapter.LicenseValidator
- * @sample at.bitfire.davdroid.syncadapter.PaymentValidator
- */
-@Singleton
-class SyncComponentManager @Inject constructor(
-    val provider: Provider<SyncComponentBuilder>
-) {
-
-    private var componentRef: WeakReference<SyncComponent>? = null
-
-    /**
-     * Returns a [SyncComponent]. When there is already a known [SyncComponent],
-     * it will be used. Otherwise, a new one will be created and returned.
-     *
-     * It is then stored using a [WeakReference] – so as long as the component
-     * stays in memory, it will always be returned. When it's not used anymore
-     * by anyone, it can be removed by garbage collection. After this, it will be
-     * created again when [get] is called.
-     *
-     * @return singleton [SyncComponent] (will be garbage collected when not referenced anymore)
-     */
-    @Synchronized
-    fun get(): SyncComponent {
-        val component = componentRef?.get()
-
-        // check for cached component
-        if (component != null)
-            return component
-
-        // cached component not available, build new one
-        val newComponent = provider.get().build()
-        componentRef = WeakReference(newComponent)
-        return newComponent
-    }
-
-}

app/src/main/java/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/java/at/bitfire/davdroid/log/Logger.kt

@@ -1,144 +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.*
-import java.util.logging.FileHandler
-import java.util.logging.Level
-
-object Logger : SharedPreferences.OnSharedPreferenceChangeListener {
-
-    const val LOGGER_NAME = "davx5"
-    private 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 logDir = debugDir() ?: return
-            val logFile = File(logDir, "davx5-log.txt")
-            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)
-                    .withLogFile(logFile)
-                    .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.putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, LOG_TO_FILE)
-                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()
-        }
-    }
-
-
-    private 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
-    }
-
-}

app/src/main/java/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.*
-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/java/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/java/at/bitfire/davdroid/network/GoogleOAuth.kt

@@ -1,40 +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.net.Uri
-import at.bitfire.davdroid.BuildConfig
-import net.openid.appauth.AuthorizationRequest
-import net.openid.appauth.AuthorizationService
-import net.openid.appauth.AuthorizationServiceConfiguration
-import net.openid.appauth.ResponseTypeValues
-
-object GoogleOAuth {
-
-    // davx5integration@gmail.com
-    private const val CLIENT_ID = "1069050168830-eg09u4tk1cmboobevhm4k3bj1m4fav9i.apps.googleusercontent.com"
-
-    val SCOPES = arrayOf(
-        "https://www.googleapis.com/auth/calendar",     // CalDAV
-        "https://www.googleapis.com/auth/carddav"       // CardDAV
-    )
-
-    private val serviceConfig = AuthorizationServiceConfiguration(
-        Uri.parse("https://accounts.google.com/o/oauth2/v2/auth"),
-        Uri.parse("https://oauth2.googleapis.com/token")
-    )
-
-    fun authRequestBuilder() =
-        AuthorizationRequest.Builder(
-            serviceConfig,
-            CLIENT_ID,
-            ResponseTypeValues.CODE,
-            Uri.parse(BuildConfig.APPLICATION_ID + ":/oauth/redirect")
-        )
-
-    fun createAuthService(context: Context) = AuthorizationService(context)
-
-}

app/src/main/java/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.*
-
-/**
- * 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/java/at/bitfire/davdroid/resource/LocalAddress.kt

@@ -1,13 +0,0 @@
-/***************************************************************************************************
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- **************************************************************************************************/
-
-package at.bitfire.davdroid.resource
-
-import at.bitfire.vcard4android.Contact
-
-interface LocalAddress: LocalResource<Contact> {
-
-    fun resetDeleted()
-
-}