Bump version to 4.3.6.1

Fix bug where sync wasn't possible as soon there's any connection without INTERNET (bitfireAT/davx5#369)

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+
+github: bitfireAT
+liberapay: DAVx5
+custom: 'https://www.davx5.com/donate'

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: DAVx⁵ Community Support
+    url: https://github.com/bitfireAT/davx5-ose/discussions
+    about: Ask and answer questions (including feature requests and bug reports) here.

.github/workflows/codeql.yml

@@ -0,0 +1,55 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "dev-ose", main-ose ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "dev-ose" ]
+  schedule:
+    - cron: '22 10 * * 1'
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+    - uses: actions/setup-java@v3
+      with:
+        distribution: 'temurin'
+        java-version: 17
+    - uses: gradle/gradle-build-action@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    #- name: Autobuild
+    #  uses: github/codeql-action/autobuild@v2
+
+    - name: Build
+      run: ./gradlew --no-daemon app:assembleOseDebug
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/release.yml

@@ -0,0 +1,40 @@
+name: Create release
+on:
+  push:
+    tags:
+      - v*
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  build:
+    name: Create release
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 17
+      - uses: gradle/gradle-build-action@v2
+
+      - 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
+        env:
+          ANDROID_KEYSTORE: ${{ github.workspace }}/keystore.jks
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.android_keystore_password }}
+          ANDROID_KEY_ALIAS: ${{ secrets.android_key_alias }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.android_key_password }}
+
+      - name: Create Github release
+        uses: softprops/action-gh-release@v1
+        with:
+          prerelease: ${{ contains(github.ref_name, '-alpha') || contains(github.ref_name, '-beta') || contains(github.ref_name, '-rc') }}
+          files: app/build/outputs/apk/ose/release/*.apk
+          fail_on_unmatched_files: true

.github/workflows/test-dev.yml

@@ -0,0 +1,85 @@
+name: Development tests
+on: [push, pull_request]
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+
+  test:
+    name: Tests without emulator
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 17
+      - uses: gradle/gradle-build-action@v2
+
+      - name: Run lint and unit tests
+        run: ./gradlew app:check
+      - name: Archive results
+        uses: actions/upload-artifact@v2
+        with:
+          name: test-results
+          path: |
+            app/build/outputs/lint*
+            app/build/reports
+
+  test_on_emulator:
+    name: Tests with emulator
+    runs-on: ubuntu-latest-4-cores
+    strategy:
+      matrix:
+        api-level: [ 31 ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-java@v3
+        with:
+          distribution: temurin
+          java-version: 17
+      - uses: gradle/gradle-build-action@v2
+
+      - name: Enable KVM group perms
+        run: |
+          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+          sudo udevadm control --reload-rules
+          sudo udevadm trigger --name-match=kvm
+
+      - name: Cache AVD and APKs
+        uses: actions/cache@v3
+        id: avd-cache
+        with:
+          path: |
+            ~/.android/avd/*
+            ~/.android/adb*
+          key: avd-${{ matrix.api-level }}
+
+      - 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

.gitlab-ci.yml

@@ -1,31 +0,0 @@
-image: registry.gitlab.com/bitfireat/docker-android-emulator:latest
-
-before_script:
-  - git submodule update --init --recursive
-  - export GRADLE_USER_HOME=`pwd`/.gradle; chmod +x gradlew
-
-cache:
-  paths:
-     - .gradle/
-
-test:
-  tags:
-    - privileged
-  script:
-   - start-emulator.sh
-   - ./gradlew app:check app:connectedCheck
-  artifacts:
-    paths:
-      - app/build/outputs/lint-results-debug.html
-      - app/build/reports
-      - build/reports
-
-pages:
-  script:
-    - ./gradlew app:dokka
-    - mkdir public && mv app/build/dokka public
-  artifacts:
-    paths:
-      - public
-  only:
-    - master-ose

.gitmodules

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

.tx/config

@@ -0,0 +1,30 @@
+[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
+
+[o:bitfireAT:p:davx5:r:app]
+file_filter   = app/src/main/res/values-<lang>/strings.xml
+source_file   = app/src/main/res/values/strings.xml
+source_lang   = en
+type          = ANDROID
+minimum_perc  = 20
+resource_name = App strings (all flavors)
+
+
+# Attention: fastlane directories are like "en-us", not "en-rUS"!
+
+[o:bitfireAT:p:davx5:r:metadata-short-description]
+file_filter   = fastlane/metadata/android/<lang>/short_description.txt
+source_file   = fastlane/metadata/android/en-US/short_description.txt
+source_lang   = en
+type          = TXT
+minimum_perc  = 100
+resource_name = Metadata: short description
+
+[o:bitfireAT:p:davx5:r:metadata-full-description]
+file_filter   = fastlane/metadata/android/<lang>/full_description.txt
+source_file   = fastlane/metadata/android/en-US/full_description.txt
+source_lang   = en
+type          = TXT
+minimum_perc  = 100
+resource_name = Metadata: full description

AUTHORS

@@ -0,0 +1,11 @@
+# This is the list of significant contributors to DAVx5.
+#
+# This does not necessarily list everyone who has contributed work.
+# To see the full list of contributors, see the revision history in
+# source control.
+
+Ricki Hirner (bitfire.at)
+Bernhard Stockmann (bitfire.at)
+
+Sunik Kupfer (bitfire.at)
+Patrick Lang (techbee.at)

CONTRIBUTING.md

@@ -1,47 +1,117 @@
 
-Contributing to DAVx⁵
-=====================
-
 **Thank you for your interest in contributing to DAVx⁵!**
 
-Because you're reading this, you're probably interested in
-contributing to the DAVx⁵ code. [Other ways to contribute:
-see here.](https://www.davx5.com/donate#c306)
 
-To contribute:
+# Licensing
 
-1. It's good idea to have a look at the [DAVx⁵ Roadmap](https://gitlab.com/bitfireAT/davx5-ose/wikis/Roadmap)
-   to see whether the change is already planned. Maybe there's even a link to a
-   corresponding forum thread there.
-1. Determine which project the changes shall go to. There's
-   the DAVx⁵ main project (this repo), and the [related
-   libraries](README.md).
-1. Please post to the [DAVx⁵ development forum](https://www.davx5.com/forums)
-   before doing actual work (unless you do it only for yourself, of course).
-   This will help to coordinate activities and you'll also get hints
-   about where to start and possible pitfalls.
-1. Fork the repository.
-1. Do the changes in your repository.
-1. Submit a pull request to the original project.
-1. Post in the forum again (to make sure the pull request is being notified).
+All work in this repository is [licensed under the GPLv3](LICENSE).
+
+We (bitfire.at, initial and main contributors) are also asking you to give us
+permission to use your contribution for related non-open source projects
+like [Managed DAVx⁵](https://www.davx5.com/organizations/managed-davx5).
+
+If you send us a pull request, our CLA bot will ask you to sign the
+Contributor's License Agreement so that we can use your contribution.
 
 
-Questions, discussion
-=====================
+# Copyright
 
-We're happy to see questions, discussions etc. in the
-[DAVx⁵ development forum](https://www.davx5.com/forums)!
+Make sure that every file that contains significant work (at least every code file)
+starts with the copyright header:
+
+```
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+```
+
+You can set this in Android Studio:
+
+1. Settings / Editor / Copyright / Copyright Profiles
+2. Paste the text above (without the stars).
+3. Set Formatting so that the preview exactly looks like above; one blank line after the block.
+4. Set this copyright profile as the default profile for the project.
+5. Apply copyright: right-click in file tree / Update copyright.
 
 
-Licensing
-=========
+# Style guide
 
-All code has to be licensed under the GPL.
+Please adhere to the [Kotlin style guide](https://developer.android.com/kotlin/style-guide) and
+the following hints to make the source code uniform.
 
-We (bitfire.at, initial developers) are also asking you to double-license the
-code so that we can also use it for related non-open source projects like
-[Managed DAVx⁵](https://www.davx5.com/organizations/managed-davx5).
+**Have a look at similar files and copy their style if you're not certain.**
 
-Please find more about this in the Contributor's License Agreement (CLA)
-we'll send to you if you want to contribute.
+Sample file (pay attention to blank lines and other formatting):
+
+```
+<Copyright header, see above>
+
+class MyClass(int arg1) : SuperClass() {
+
+    companion object {
+
+        const val CONSTANT_STRING = "Constant String";
+
+        fun staticMethod() {	// Use static methods when you don't need the object context.
+            // …
+        }
+
+    }
+
+    var someProperty: String = "12345"
+    var someRelatedProperty: Int = 12345
+
+    init {
+        // constructor
+    }
+
+
+    /**
+     * Use KDoc to document important methods. Don't use it dogmatically, but writing proper documentation
+     * (not just the method name with spaces) helps you to re-think what the method shall really do.
+     */
+    fun aFun1() {		// Group methods by some logic (for instance, the order in which they will be called)
+    }				// and alphabetically within a group.
+
+    fun anotherFun() {
+        // …
+    }
+
+
+    fun somethingCompletelyDifferent() {	// two blank lines to separate groups
+    }
+
+    fun helperForSomethingCompletelyDifferent() {
+        someCall(arg1, arg2, arg3, arg4)	// function calls: stick to one line unless it becomes confusing
+    }
+
+
+    class Model(				// two blank lines before inner classes
+        someArgument: SomeLongClass,		// arguments in multiple lines when they're too long for one line
+        anotherArgument: AnotherLongType,
+        thirdArgument: AnotherLongTypeName
+    ) : ViewModel() {
+
+        fun abc() {
+        }
+
+    }
+
+}
+```
+
+In general, use one blank line to separate things within one group of things, and two blank lines
+to separate groups. In rare cases, when methods are tightly coupled and are only helpers for another
+method, they may follow the calling method without separating blank lines.
+
+## Tests
+
+Test classes should be in the appropriate directory (see existing tests) and in the same package as the
+tested class. Tests are usually be named like `methodToBeTested_Condition()`, see
+[Test apps on Android](https://developer.android.com/training/testing/).
+
+
+# Authors
+
+If you make significant contributions, feel free to add yourself to the [AUTHORS file](AUTHORS).
 

README.md

@@ -1,37 +1,46 @@
+
+[![Website](https://img.shields.io/website?style=flat-square&up_color=%237cb342&url=https%3A%2F%2Fwww.davx5.com)](https://www.davx5.com/)
+[![F-Droid](https://img.shields.io/f-droid/v/at.bitfire.davdroid?style=flat-square)](https://f-droid.org/packages/at.bitfire.davdroid/)
+[![License](https://img.shields.io/github/license/bitfireAT/davx5-ose?style=flat-square)](https://github.com/bitfireAT/davx5-ose/blob/main/LICENSE)
+[![Follow @davx5app@fosstodon.org](https://img.shields.io/mastodon/follow/109598783742737223?domain=https%3A%2F%2Ffosstodon.org&style=flat-square)](https://fosstodon.org/@davx5app)
+[![Development tests](https://github.com/bitfireAT/davx5-ose/actions/workflows/test-dev.yml/badge.svg)](https://github.com/bitfireAT/davx5-ose/actions/workflows/test-dev.yml)
+
 ![DAVx⁵ logo](app/src/main/res/mipmap-xxxhdpi/ic_launcher.png)
 
+
 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](https://twitter.com/davx5app) on Twitter
+News and updates: 
 
-Help, discussion, feature requests, bug reports and "issues": [DAVx⁵ forums](https://www.davx5.com/forums)
+* [@davx5app@fosstodon.org](https://fosstodon.org/@davx5app) on Mastodon
 
-**If you want to support DAVx⁵, please consider [donating to DAVx⁵](https://www.davx5.com/donate)
-or [purchasing it](https://www.davx5.com/download).**
-
-Generated KDoc: https://bitfireAT.gitlab.io/davx5-ose/dokka/app/
+**Help, feature requests, bug reports: [DAVx⁵ discussions](https://github.com/bitfireAT/davx5-ose/discussions)**
 
 Parts of DAVx⁵ have been outsourced into these libraries:
 
-* [cert4android](https://gitlab.com/bitfireAT/cert4android) – custom certificate management
-* [dav4jvm](https://gitlab.com/bitfireAT/dav4jvm) – WebDAV/CalDav/CardDAV framework
-* [ical4android](https://gitlab.com/bitfireAT/ical4android) – iCalendar processing and Calendar Provider access
-* [vcard4android](https://gitlab.com/bitfireAT/vcard4android) – vCard processing and Contacts Provider access
+* [cert4android](https://github.com/bitfireAT/cert4android) – custom certificate management
+* [dav4jvm](https://github.com/bitfireAT/dav4jvm) – WebDAV/CalDav/CardDAV framework
+* [ical4android](https://github.com/bitfireAT/ical4android) – iCalendar processing and Calendar Provider access
+* [vcard4android](https://github.com/bitfireAT/vcard4android) – vCard processing and Contacts Provider access
+
+**If you want to support DAVx⁵, please consider [donating to DAVx⁵](https://www.davx5.com/donate)
+or [purchasing it](https://www.davx5.com/download).**
 
 
 USED THIRD-PARTY LIBRARIES
 ==========================
 
-Those libraries are used by DAVx⁵ (alphabetically):
+The most important libraries which are used by DAVx⁵ (alphabetically):
 
-* [Color Picker](https://github.com/jaredrummler/ColorPicker) – [Apache License, Version 2.0](https://github.com/jaredrummler/ColorPicker/LICENSE)
-* [dnsjava](http://www.xbill.org/dnsjava/) – [BSD License](http://www.xbill.org/dnsjava/dnsjava-current/LICENSE)
-* [ez-vcard](https://github.com/mangstadt/ez-vcard) – [New BSD License](http://opensource.org/licenses/BSD-3-Clause)
-* [iCal4j](https://github.com/ical4j/ical4j) – [New BSD License](http://sourceforge.net/p/ical4j/ical4j/ci/default/tree/LICENSE)
+* [dnsjava](https://github.com/dnsjava/dnsjava) – [BSD License](https://github.com/dnsjava/dnsjava/blob/master/LICENSE)
+* [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.

SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please report security vulnerabilities using our [secure support form](https://www.davx5.com/support) or via email to support-en@davx5.com.

app/build.gradle

@@ -1,143 +1,211 @@
-/*
- * Copyright (c) Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
-apply plugin: 'com.android.application'
-apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
-apply plugin: 'kotlin-kapt'
-apply plugin: 'org.jetbrains.dokka'
+plugins {
+    id 'com.android.application'
+    id 'com.google.devtools.ksp'
+    id 'com.mikepenz.aboutlibraries.plugin'
+    id 'dagger.hilt.android.plugin'
+    id 'kotlin-android'
+    id 'kotlin-kapt'     // remove as soon as Hilt supports KSP [https://issuetracker.google.com/179057202]
+}
 
+// Android configuration
 android {
-    compileSdkVersion 29
-    buildToolsVersion '29.0.2'
+    compileSdk 34
 
     defaultConfig {
         applicationId "at.bitfire.davdroid"
 
-        versionCode 312
-        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
-        buildConfigField "boolean", "customCerts", "true"
+        versionCode 403060100
+        versionName '4.3.6.1'
 
-        minSdkVersion 19        // Android 4.4
-        targetSdkVersion 29     // Android 10.0
-        multiDexEnabled true    // >64k methods for Android 4.4
+        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
+
+        setProperty "archivesBaseName", "davx5-ose-" + getVersionName()
+
+        minSdkVersion 21        // Android 5
+        targetSdkVersion 33     // Android 13
 
         buildConfigField "String", "userAgent", "\"DAVx5\""
 
-        // when using this, make sure that notification icons are real bitmaps
-        vectorDrawables.useSupportLibrary = true
+        testInstrumentationRunner "at.bitfire.davdroid.CustomTestRunner"
     }
 
     compileOptions {
-        sourceCompatibility JavaVersion.VERSION_1_8
-        targetCompatibility JavaVersion.VERSION_1_8
+        // enable because ical4android requires desugaring
+        coreLibraryDesugaringEnabled true
+
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
     }
 
-    dataBinding.enabled = true
+    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.5.1"
+    }
 
-    flavorDimensions "distribution"
+    // Java namespace for our classes (not to be confused with Android package ID)
+    namespace 'at.bitfire.davdroid'
+
+    flavorDimensions = [ "distribution" ]
     productFlavors {
-        standard {
-            versionName "2.6.1-beta4-ose"
+        ose {
+            dimension "distribution"
+            versionNameSuffix "-ose"
+        }
+    }
+
+    sourceSets {
+        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 {
-            minifyEnabled false
         }
         release {
             minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules-release.pro'
+
+            shrinkResources true
+
+            signingConfig signingConfigs.bitfire
         }
     }
 
-    lintOptions {
-        disable 'GoogleAppIndexingWarning'      // we don't need Google indexing, thanks
-        disable 'ImpliedQuantity', 'MissingQuantity'		// quantities from Transifex may vary
-        disable 'MissingTranslation', 'ExtraTranslation'	// translations from Transifex are not always up to date
-        disable 'RtlEnabled'
-        disable 'RtlHardcoded'
-        disable 'Typos'
+    lint {
+        disable 'GoogleAppIndexingWarning', 'ImpliedQuantity', 'MissingQuantity', 'MissingTranslation', 'ExtraTranslation', 'RtlEnabled', 'RtlHardcoded', 'Typos', 'NullSafeMutableLiveData'
     }
+
     packagingOptions {
-        exclude 'META-INF/DEPENDENCIES'
-        exclude 'META-INF/LICENSE'
+        resources {
+            excludes += ['META-INF/*.md']
+        }
     }
 
-    defaultConfig {
-        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    androidResources {
+        generateLocaleConfig true
     }
+}
 
-    dokka.configuration {
-        sourceLink { url = "https://gitlab.com/bitfireAT/davx5-ose/tree/master-ose/" }
-        jdkVersion = 7
+ksp {
+    arg("room.schemaLocation", "$projectDir/schemas")
+}
 
-        externalDocumentationLink {
-            url = new URL("https://bitfireat.gitlab.io/cert4android/dokka/cert4android/")
-            packageListUrl = new URL("https://bitfireat.gitlab.io/cert4android/dokka/cert4android/package-list")
-        }
-        externalDocumentationLink {
-            url = new URL("https://bitfireat.gitlab.io/dav4jvm/dokka/dav4jvm/")
-            packageListUrl = new URL("https://bitfireat.gitlab.io/dav4jvm/dokka/dav4jvm/package-list")
-        }
-        externalDocumentationLink {
-            url = new URL("https://bitfireat.gitlab.io/ical4android/dokka/ical4android/")
-            packageListUrl = new URL("https://bitfireat.gitlab.io/ical4android/dokka/ical4android/package-list")
-        }
-        externalDocumentationLink {
-            url = new URL("https://bitfireat.gitlab.io/vcard4android/dokka/vcard4android/")
-            packageListUrl = new URL("https://bitfireat.gitlab.io/vcard4android/dokka/vcard4android/package-list")
-        }
+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 {
-    implementation project(':cert4android')
-    implementation project(':ical4android')
-    implementation project(':vcard4android')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:${versions.kotlin}"
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.3'
+    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:2.0.3'
 
-    implementation 'androidx.multidex:multidex:2.0.1'
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:${versions.kotlin}"
+    implementation "com.google.dagger:hilt-android:${versions.hilt}"
+    kapt "com.google.dagger:hilt-android-compiler:${versions.hilt}"     // replace by KSP when ready [https://issuetracker.google.com/179057202]
 
-    implementation 'androidx.appcompat:appcompat:1.1.0'
+    // support libs
+    implementation 'androidx.appcompat:appcompat:1.6.1'
+    implementation 'androidx.browser:browser:1.6.0'
     implementation 'androidx.cardview:cardview:1.0.0'
-    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
-    implementation 'androidx.fragment:fragment-ktx:1.1.0'
-    implementation 'androidx.lifecycle:lifecycle-extensions:2.1.0'
-    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.1.0'
-    implementation 'androidx.paging:paging-runtime-ktx:2.1.0'
-    implementation 'androidx.preference:preference:1.1.0'
-    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0-alpha03'
-    implementation 'com.google.android:flexbox:1.1.0'
-    implementation 'com.google.android.material:material:1.1.0-beta02'
+    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.1'
+    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.2.0'
+    implementation 'androidx.preference:preference-ktx:1.2.1'
+    implementation 'androidx.security:security-crypto:1.1.0-alpha06'
+    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
+    implementation "androidx.work:work-runtime-ktx:${versions.workManager}"
+    implementation 'com.google.android.flexbox:flexbox:3.0.0'
+    implementation 'com.google.android.material:material:1.9.0'
 
-    def room_version = '2.2.1'
-    implementation "androidx.room:room-runtime:$room_version"
-    implementation "androidx.room:room-ktx:$room_version"
-    kapt "androidx.room:room-compiler:$room_version"
+    // Jetpack Compose
+    implementation platform("androidx.compose:compose-bom:${versions.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'
 
-    implementation 'com.gitlab.bitfireAT:dav4jvm:214d9178'
+    // Jetpack Room
+    implementation "androidx.room:room-runtime:${versions.room}"
+    implementation "androidx.room:room-ktx:${versions.room}"
+    implementation "androidx.room:room-paging:${versions.room}"
+    ksp "androidx.room:room-compiler:${versions.room}"
+    androidTestImplementation "androidx.room:room-testing:${versions.room}"
+
+    // own libraries
+    implementation "com.github.bitfireAT:cert4android:${versions.cert4android}"
+    implementation "com.github.bitfireAT:ical4android:${versions.ical4android}"
+    implementation "com.github.bitfireAT:vcard4android:${versions.vcard4android}"
+
+    // third-party libs
     implementation 'com.jaredrummler:colorpicker:1.1.0'
-    implementation 'com.mikepenz:aboutlibraries:6.2.3'
+    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}"
-    implementation 'commons-io:commons-io:2.6'
+    //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'
-    implementation 'org.apache.commons:commons-collections4:4.4'
-    implementation 'org.apache.commons:commons-lang3:3.9'
+    implementation 'net.openid:appauth:0.11.1'
+    //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 'androidx.test:runner:1.2.0'
-    androidTestImplementation 'androidx.test:rules:1.2.0'
-    androidTestImplementation 'junit:junit:4.12'
-    androidTestImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
+    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:${versions.workManager}"
+    androidTestImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
+    androidTestImplementation 'io.mockk:mockk-android:1.13.7'
+    androidTestImplementation 'junit:junit:4.13.2'
 
-    testImplementation 'junit:junit:4.12'
     testImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
+    testImplementation 'junit:junit:4.13.2'
 }

app/proguard-rules-release.pro

@@ -0,0 +1,47 @@
+
+# R8 usage for DAVx⁵:
+#    shrinking        yes (only in release builds)
+#    optimization     yes (on by R8 defaults)
+#    obfuscation      no (open-source)
+
+-dontobfuscate
+-printusage build/reports/r8-usage.txt
+
+# ez-vcard: keep all vCard properties/parameters (used via reflection)
+-keep class ezvcard.io.scribe.** { *; }
+-keep class ezvcard.property.** { *; }
+-keep class ezvcard.parameter.** { *; }
+
+# ical4j: keep all iCalendar properties/parameters (used via reflection)
+-keep class net.fortuna.ical4j.** { *; }
+
+# XmlPullParser
+-keep class org.xmlpull.** { *; }
+
+# DAVx⁵ + libs
+-keep class at.bitfire.** { *; }       # all DAVx⁵ code is required
+
+# we use enum classes (https://www.guardsquare.com/en/products/proguard/manual/examples#enumerations)
+-keepclassmembers,allowoptimization enum * {
+    public static **[] values();
+    public static ** valueOf(java.lang.String);
+}
+
+# Additional rules which are now required since missing classes can't be ignored in R8 anymore.
+# [https://developer.android.com/build/releases/past-releases/agp-7-0-0-release-notes#r8-missing-class-warning]
+-dontwarn com.android.org.conscrypt.SSLParametersImpl
+-dontwarn groovy.**
+-dontwarn java.beans.Transient
+-dontwarn junit.textui.TestRunner
+-dontwarn org.apache.harmony.xnet.provider.jsse.SSLParametersImpl
+-dontwarn org.bouncycastle.jsse.**
+-dontwarn org.codehaus.groovy.**
+-dontwarn org.joda.**
+-dontwarn org.json.*
+-dontwarn org.jsoup.**
+-dontwarn org.openjsse.javax.net.ssl.SSLParameters
+-dontwarn org.openjsse.javax.net.ssl.SSLSocket
+-dontwarn org.openjsse.net.ssl.OpenJSSE
+-dontwarn org.xmlpull.**
+-dontwarn sun.net.spi.nameservice.NameService
+-dontwarn sun.net.spi.nameservice.NameServiceDescriptor

app/proguard-rules.txt

@@ -1,50 +0,0 @@
-
-# ProGuard usage for DAVx⁵:
-#       shrinking        yes (main reason for using ProGuard)
-#       optimization     yes
-#       obfuscation      no (DAVx⁵ is open-source)
-#       preverification  no
-
--dontobfuscate
-
--optimizations !code/simplification/arithmetic,!code/simplification/cast,!field/*,!class/merging/*
--optimizationpasses 5
--allowaccessmodification
--dontpreverify
-
-# Kotlin
--dontwarn kotlin.**
-
-# https://github.com/material-components/material-components-android/issues/387
--keep class com.google.android.material.tabs.** {*;}
-
-# Apache Commons
--dontwarn javax.script.**
-
-# ez-vcard
--dontwarn ezvcard.io.json.**            # JSON serializer (for jCards) not used
--dontwarn freemarker.**                 # freemarker templating library (for creating hCards) not used
--dontwarn org.jsoup.**                  # jsoup library (for hCard parsing) not used
--keep class ezvcard.property.** { *; }  # keep all vCard properties (created at runtime)
-
-# ical4j: ignore unused dynamic libraries
--dontwarn aQute.**
--dontwarn groovy.**                       # Groovy-based ContentBuilder not used
--dontwarn javax.cache.**                  # no JCache support in Android
--dontwarn net.fortuna.ical4j.model.**
--dontwarn org.codehaus.groovy.**
--dontwarn org.apache.log4j.**             # ignore warnings from log4j dependency
--keep class net.fortuna.ical4j.** { *; }  # keep all model classes (properties/factories, created at runtime)
--keep class org.threeten.bp.** { *; }     # keep ThreeTen (for time zone processing)
-
-# okhttp
--dontwarn javax.annotation.**
--dontwarn okio.**
--dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
--dontwarn org.conscrypt.**
-
-# dnsjava
--dontwarn sun.net.spi.nameservice.**   # not available on Android
-
-# DAVx⁵ + libs
--keep class at.bitfire.** { *; }       # all DAVx⁵ code is required

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

@@ -0,0 +1,398 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 10,
+    "identityHash": "6fcabe50cbd00a4215dbe536a565dd2a",
+    "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "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, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `owner` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, 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 )",
+        "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": "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": "owner",
+            "columnName": "owner",
+            "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "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"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          },
+          {
+            "name": "index_collection_url",
+            "unique": false,
+            "columnNames": [
+              "url"
+            ],
+            "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"
+            ]
+          }
+        ]
+      },
+      {
+        "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_syncstats_collectionId_authority",
+            "unique": true,
+            "columnNames": [
+              "collectionId",
+              "authority"
+            ],
+            "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_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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "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, '6fcabe50cbd00a4215dbe536a565dd2a')"
+    ]
+  }
+}

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

@@ -0,0 +1,536 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 11,
+    "identityHash": "223aa7f0fd53730921ca212a663585d8",
+    "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "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, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `owner` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, 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 )",
+        "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": "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": "owner",
+            "columnName": "owner",
+            "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "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"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          },
+          {
+            "name": "index_collection_url",
+            "unique": false,
+            "columnNames": [
+              "url"
+            ],
+            "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"
+            ]
+          }
+        ]
+      },
+      {
+        "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_syncstats_collectionId_authority",
+            "unique": true,
+            "columnNames": [
+              "collectionId",
+              "authority"
+            ],
+            "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_webdav_document_mountId_parentId_name",
+            "unique": true,
+            "columnNames": [
+              "mountId",
+              "parentId",
+              "name"
+            ],
+            "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "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, '223aa7f0fd53730921ca212a663585d8')"
+    ]
+  }
+}

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

@@ -0,0 +1,615 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 12,
+    "identityHash": "67fafceecee2d97cac6a62d46fa2c3e2",
+    "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, 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
+          }
+        ],
+        "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, '67fafceecee2d97cac6a62d46fa2c3e2')"
+    ]
+  }
+}

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

@@ -0,0 +1,298 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 8,
+    "identityHash": "b8699ef3cc4c62e8851df4360fb69e00",
+    "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "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, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `owner` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, 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 )",
+        "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": "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": "owner",
+            "columnName": "owner",
+            "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "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"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "homeset",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "homeSetId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      }
+    ],
+    "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, 'b8699ef3cc4c62e8851df4360fb69e00')"
+    ]
+  }
+}

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

@@ -0,0 +1,366 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 9,
+    "identityHash": "7e4bfdf7f9fa3529c333cf9485f8cf50",
+    "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "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, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `owner` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, 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 )",
+        "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": "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": "owner",
+            "columnName": "owner",
+            "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
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "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"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          },
+          {
+            "name": "index_collection_url",
+            "unique": false,
+            "columnNames": [
+              "url"
+            ],
+            "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"
+            ]
+          }
+        ]
+      },
+      {
+        "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": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_syncstats_collectionId_authority",
+            "unique": true,
+            "columnNames": [
+              "collectionId",
+              "authority"
+            ],
+            "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"
+            ]
+          }
+        ]
+      }
+    ],
+    "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, '7e4bfdf7f9fa3529c333cf9485f8cf50')"
+    ]
+  }
+}

app/src/androidTest/AndroidManifest.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    android:installLocation="internalOnly">
+
+    <!-- account management permissions not required for own accounts since API level 22 -->
+    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" android:maxSdkVersion="22"/>
+    <uses-permission android:name="android.permission.GET_ACCOUNTS" android:maxSdkVersion="22"/>
+    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" android:maxSdkVersion="22"/>
+
+</manifest>

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

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

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

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

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

@@ -0,0 +1,81 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid
+
+import android.content.Context
+import androidx.lifecycle.LiveData
+import androidx.lifecycle.Observer
+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
+
+object TestUtils {
+
+    fun assertWithin(expected: Long, actual: Long, tolerance: Long) {
+        val absDifference = Math.abs(expected - actual)
+        assertTrue(
+            "$actual not within ($expected ± $tolerance)",
+            absDifference <= tolerance
+        )
+    }
+
+    @TestOnly
+    fun workScheduledOrRunning(context: Context, workerName: String): Boolean =
+        workInStates(context, workerName, listOf(
+            WorkInfo.State.ENQUEUED,
+            WorkInfo.State.RUNNING
+        ))
+
+    @TestOnly
+    fun workScheduledOrRunningOrSuccessful(context: Context, workerName: String): Boolean =
+        workInStates(context, workerName, listOf(
+            WorkInfo.State.ENQUEUED,
+            WorkInfo.State.RUNNING,
+            WorkInfo.State.SUCCEEDED
+        ))
+
+    @TestOnly
+    fun workInStates(context: Context, workerName: String, states: List<WorkInfo.State>): Boolean =
+        WorkManager.getInstance(context).getWorkInfos(WorkQuery.Builder
+            .fromUniqueWorkNames(listOf(workerName))
+            .addStates(states)
+            .build()
+        ).get().isNotEmpty()
+
+
+    /* Copyright 2019 Google LLC.
+    SPDX-License-Identifier: Apache-2.0 */
+    @TestOnly
+    fun <T> LiveData<T>.getOrAwaitValue(
+        time: Long = 2,
+        timeUnit: TimeUnit = TimeUnit.SECONDS
+    ): T {
+        var data: T? = null
+        val latch = CountDownLatch(1)
+        val observer = object : Observer<T> {
+            override fun onChanged(value: T) {
+                data = value
+                latch.countDown()
+                this@getOrAwaitValue.removeObserver(this)
+            }
+        }
+
+        this.observeForever(observer)
+
+        // Don't wait indefinitely if the LiveData is not set.
+        if (!latch.await(time, timeUnit)) {
+            throw TimeoutException("LiveData value was never set.")
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        return data as T
+    }
+
+}

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

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

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

@@ -1,34 +1,51 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
-package at.bitfire.davdroid.model
+package at.bitfire.davdroid.db
 
-import android.content.ContentValues
+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.davdroid.HttpClient
-import okhttp3.HttpUrl
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import org.junit.After
 import org.junit.Assert.*
+import org.junit.Assume
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
+import javax.inject.Inject
 
+@HiltAndroidTest
 class CollectionTest {
 
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
     private lateinit var httpClient: HttpClient
     private val server = MockWebServer()
 
     @Before
     fun setUp() {
-        httpClient = HttpClient.Builder().build()
+        httpClient = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build()
+        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
     }
 
     @After
@@ -129,7 +146,7 @@ class CollectionTest {
                 }
         assertEquals(Collection.TYPE_WEBCAL, info.type)
         assertEquals("Sample Subscription", info.displayName)
-        assertEquals(HttpUrl.get("https://example.com/1.ics"), info.source)
+        assertEquals("https://example.com/1.ics".toHttpUrl(), info.source)
     }
 
 }

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

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

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

@@ -0,0 +1,33 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import android.content.Context
+import androidx.room.Room
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import dagger.hilt.testing.TestInstallIn
+import javax.inject.Singleton
+
+@Module
+@TestInstallIn(
+    components = [ SingletonComponent::class ],
+    replaces = [
+        AppDatabase.AppDatabaseModule::class
+    ]
+)
+class MemoryDbModule {
+
+    @Provides
+    @Singleton
+    fun inMemoryDatabase(@ApplicationContext context: Context): AppDatabase =
+        Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java)
+            // auto-migrations that need to be specified explicitly
+            .addAutoMigrationSpec(AppDatabase.AutoMigration11_12(context))
+            .build()
+
+}

app/src/androidTest/java/at/bitfire/davdroid/model/DaoToolsTest.kt

@@ -1,63 +0,0 @@
-package at.bitfire.davdroid.model
-
-import androidx.room.Room
-import androidx.test.platform.app.InstrumentationRegistry
-import okhttp3.HttpUrl
-import org.junit.After
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.Test
-
-class DaoToolsTest {
-
-    private lateinit var db: AppDatabase
-
-    @Before
-    fun createDb() {
-        val context = InstrumentationRegistry.getInstrumentation().context
-        db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java).build()
-    }
-
-    @After
-    fun closeDb() {
-        db.close()
-    }
-
-    @Test
-    fun testSyncAll() {
-        val serviceDao = db.serviceDao()
-        val service = Service(id=0, accountName="test", type=Service.TYPE_CALDAV, principal = null)
-        service.id = serviceDao.insertOrReplace(service)
-
-        val homeSetDao = db.homeSetDao()
-        val entry1 = HomeSet(id=1, serviceId=service.id, url=HttpUrl.get("https://example.com/1"))
-        val entry3 = HomeSet(id=3, serviceId=service.id, url=HttpUrl.get("https://example.com/3"))
-        val oldItems = listOf(
-                entry1,
-                HomeSet(id=2, serviceId=service.id, url=HttpUrl.get("https://example.com/2")),
-                entry3
-        )
-        homeSetDao.insert(oldItems)
-
-        val newItems = mutableMapOf<HttpUrl, HomeSet>()
-        newItems[entry1.url] = entry1
-
-        // no id, because identity is given by the url
-        val updated = HomeSet(id=0, serviceId=service.id,
-                url=HttpUrl.get("https://example.com/2"), displayName="Updated Entry")
-        newItems[updated.url] = updated
-
-        val created = HomeSet(id=4, serviceId=service.id, url=HttpUrl.get("https://example.com/4"))
-        newItems[created.url] = created
-
-        DaoTools(homeSetDao).syncAll(oldItems, newItems, { it.url })
-
-        val afterSync = homeSetDao.getByService(service.id)
-        assertEquals(afterSync.size, 3)
-        assertFalse(afterSync.contains(entry3))
-        assertTrue(afterSync.contains(entry1))
-        assertTrue(afterSync.contains(updated))
-        assertTrue(afterSync.contains(created))
-    }
-
-}

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

@@ -0,0 +1,35 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.network
+
+import android.os.Build
+import androidx.test.filters.SdkSuppress
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.xbill.DNS.ARecord
+import org.xbill.DNS.Lookup
+import org.xbill.DNS.Type
+import java.net.Inet4Address
+import java.net.InetAddress
+
+class Android10ResolverTest {
+
+    val FQDN_DAVX5 = "www.davx5.com"
+
+    @Test
+    @SdkSuppress(minSdkVersion = Build.VERSION_CODES.Q)
+    fun testResolveA() {
+        val www = InetAddress.getAllByName(FQDN_DAVX5).filterIsInstance(Inet4Address::class.java).first()
+
+        val srvLookup = Lookup(FQDN_DAVX5, Type.A)
+        srvLookup.setResolver(Android10Resolver)
+        val resultGeneric = srvLookup.run()
+        assertEquals(1, resultGeneric.size)
+
+        val result = resultGeneric.first() as ARecord
+        assertEquals(www, result.address)
+    }
+
+}

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

@@ -1,30 +1,38 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
-package at.bitfire.davdroid
+package at.bitfire.davdroid.network
 
+import android.security.NetworkSecurityPolicy
+import androidx.test.platform.app.InstrumentationRegistry
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
 import okhttp3.Request
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import org.junit.After
 import org.junit.Assert.assertEquals
 import org.junit.Assert.assertNull
+import org.junit.Assume
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
 
+@HiltAndroidTest
 class HttpClientTest {
 
     lateinit var server: MockWebServer
     lateinit var httpClient: HttpClient
 
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
     @Before
     fun setUp() {
-        httpClient = HttpClient.Builder().build()
+        hiltRule.inject()
+
+        httpClient = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build()
 
         server = MockWebServer()
         server.start(30000)
@@ -39,6 +47,7 @@ class HttpClientTest {
 
     @Test
     fun testCookies() {
+        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
         val url = server.url("/test")
 
         // set cookie for root path (/) and /test path in first response

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

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

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

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

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

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

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

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

@@ -0,0 +1,38 @@
+/***************************************************************************************************
+ * 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/resource/contactrow/CachedGroupMembershipHandlerTest.kt

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

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

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

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

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

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

@@ -0,0 +1,32 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.resource.contactrow
+
+import android.net.Uri
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class UnknownPropertiesBuilderTest {
+
+    @Test
+    fun testUnknownProperties_None() {
+        UnknownPropertiesBuilder(Uri.EMPTY, null, Contact(), false).build().also { result ->
+            assertEquals(0, result.size)
+        }
+    }
+
+    @Test
+    fun testUnknownProperties_Properties() {
+        UnknownPropertiesBuilder(Uri.EMPTY, null, Contact().apply {
+            unknownProperties = "X-TEST:12345"
+        }, false).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals(UnknownProperties.CONTENT_ITEM_TYPE, result[0].values[UnknownProperties.MIMETYPE])
+            assertEquals("X-TEST:12345", result[0].values[UnknownProperties.UNKNOWN_PROPERTIES])
+        }
+    }
+
+}

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

@@ -0,0 +1,33 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.resource.contactrow
+
+import android.content.ContentValues
+import at.bitfire.vcard4android.Contact
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+class UnknownPropertiesHandlerTest {
+
+    @Test
+    fun testUnknownProperties_Empty() {
+        val contact = Contact()
+        UnknownPropertiesHandler.handle(ContentValues().apply {
+            putNull(UnknownProperties.UNKNOWN_PROPERTIES)
+        }, contact)
+        assertNull(contact.unknownProperties)
+    }
+
+    @Test
+    fun testUnknownProperties_Values() {
+        val contact = Contact()
+        UnknownPropertiesHandler.handle(ContentValues().apply {
+            put(UnknownProperties.UNKNOWN_PROPERTIES, "X-TEST:12345")
+        }, contact)
+        assertEquals("X-TEST:12345", contact.unknownProperties)
+    }
+
+}

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

@@ -1,35 +1,53 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
-package at.bitfire.davdroid.ui.setup
+package at.bitfire.davdroid.servicedetection
 
-import android.app.Application
+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.HttpClient
+import at.bitfire.davdroid.db.Credentials
 import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.Credentials
-import at.bitfire.davdroid.ui.setup.DavResourceFinder.Configuration.ServiceInfo
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.servicedetection.DavResourceFinder.Configuration.ServiceInfo
+import at.bitfire.davdroid.settings.SettingsManager
+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.After
-import org.junit.Assert.*
+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 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"
@@ -45,22 +63,21 @@ class DavResourceFinderTest {
 
     lateinit var finder: DavResourceFinder
     lateinit var client: HttpClient
-    lateinit var loginModel: LoginModel
 
     @Before
     fun initServerAndClient() {
-        server.setDispatcher(TestDispatcher())
+        server.dispatcher = TestDispatcher()
         server.start()
 
-        val application = InstrumentationRegistry.getInstrumentation().targetContext.applicationContext as Application
-        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()
-                .addAuthentication(null, loginModel.credentials!!)
+        finder = DavResourceFinder(InstrumentationRegistry.getInstrumentation().targetContext, baseURI, credentials)
+        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
+                .addAuthentication(null, credentials)
                 .build()
+
+        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
     }
 
     @After
@@ -76,7 +93,7 @@ class DavResourceFinderTest {
         var info = ServiceInfo()
         DavResource(client.okHttpClient, server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL))
                 .propfind(0, AddressbookHomeSet.NAME) { response, _ ->
-            finder.scanCardDavResponse(response, info)
+            finder.scanResponse(ResourceType.ADDRESSBOOK, response, info)
         }
         assertEquals(0, info.collections.size)
         assertEquals(1, info.homeSets.size)
@@ -86,7 +103,7 @@ class DavResourceFinderTest {
         info = ServiceInfo()
         DavResource(client.okHttpClient, server.url(PATH_CARDDAV + SUBPATH_ADDRESSBOOK))
                 .propfind(0, ResourceType.NAME) { response, _ ->
-            finder.scanCardDavResponse(response, info)
+            finder.scanResponse(ResourceType.ADDRESSBOOK, response, info)
         }
         assertEquals(1, info.collections.size)
         assertEquals(server.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"), info.collections.keys.first())
@@ -126,21 +143,31 @@ class DavResourceFinderTest {
         assertNull(finder.getCurrentUserPrincipal(server.url(PATH_CARDDAV), DavResourceFinder.Service.CALDAV))
     }
 
+    @Test
+    fun testQueryEmailAddress() {
+        var info = ServiceInfo()
+        assertArrayEquals(
+                arrayOf("email1@example.com", "email2@example.com"),
+                finder.queryEmailAddress(server.url(PATH_CALDAV + SUBPATH_PRINCIPAL)).toTypedArray()
+        )
+        assertTrue(finder.queryEmailAddress(server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL)).isEmpty())
+    }
+
 
     // mock server
 
     class TestDispatcher: Dispatcher() {
 
-        override fun dispatch(rq: RecordedRequest): MockResponse {
-            if (!checkAuth(rq)) {
+        override fun dispatch(request: RecordedRequest): MockResponse {
+            if (!checkAuth(request)) {
                 val authenticate = MockResponse().setResponseCode(401)
                 authenticate.setHeader("WWW-Authenticate", "Basic realm=\"test\"")
                 return authenticate
             }
 
-            val path = rq.path
+            val path = request.path!!
 
-            if (rq.method.equals("OPTIONS", true)) {
+            if (request.method.equals("OPTIONS", true)) {
                 val dav = when {
                     path.startsWith(PATH_CALDAV) -> "calendar-access"
                     path.startsWith(PATH_CARDDAV) -> "addressbook"
@@ -151,7 +178,7 @@ class DavResourceFinderTest {
                 if (dav != null)
                     response.addHeader("DAV", dav)
                 return response
-            } else if (rq.method.equals("PROPFIND", true)) {
+            } else if (request.method.equals("PROPFIND", true)) {
                 val props: String?
                 when (path) {
                     PATH_CALDAV,
@@ -169,14 +196,21 @@ class DavResourceFinderTest {
                                 "   <CARD:addressbook/>" +
                                 "</resourcetype>"
 
+                    PATH_CALDAV + SUBPATH_PRINCIPAL ->
+                        props = "<CAL:calendar-user-address-set>" +
+                                "  <href>urn:unknown-entry</href>" +
+                                "  <href>mailto:email1@example.com</href>" +
+                                "  <href>mailto:email2@example.com</href>" +
+                                "</CAL:calendar-user-address-set>"
+
                     else -> props = null
                 }
                 Logger.log.info("Sending props: $props")
                 return MockResponse()
                         .setResponseCode(207)
-                        .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav'>" +
+                        .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
                                 "<response>" +
-                                "   <href>${rq.path}</href>" +
+                                "   <href>${request.path}</href>" +
                                 "   <propstat><prop>$props</prop></propstat>" +
                                 "</response>" +
                                 "</multistatus>")

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

@@ -0,0 +1,771 @@
+/***************************************************************************************************
+ * 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.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.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.every
+import io.mockk.mockk
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+import org.apache.commons.lang3.StringUtils
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assume
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import java.net.URI
+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
+
+    companion object {
+        private const val PATH_CALDAV = "/caldav"
+        private const val PATH_CARDDAV = "/carddav"
+
+        private const val SUBPATH_PRINCIPAL = "/principal"
+        private const val SUBPATH_PRINCIPAL_INACCESSIBLE = "/inaccessible-principal"
+        private const val SUBPATH_PRINCIPAL_WITHOUT_COLLECTIONS = "/principal2"
+        private const val SUBPATH_ADDRESSBOOK_HOMESET = "/addressbooks-homeset"
+        private const val SUBPATH_ADDRESSBOOK_HOMESET_EMPTY = "/addressbooks-homeset-empty"
+        private const val SUBPATH_ADDRESSBOOK = "/addressbooks/my-contacts"
+        private const val SUBPATH_ADDRESSBOOK_INACCESSIBLE = "/addressbooks/inaccessible-contacts"
+    }
+
+    @Inject
+    lateinit var db: AppDatabase
+
+    @Inject
+    lateinit var settings: SettingsManager
+
+    var mockServer =  MockWebServer()
+
+    lateinit var client: HttpClient
+    lateinit var loginModel: LoginModel
+
+    @Before
+    fun mockServerSetup() {
+        // Start mock web server
+        mockServer.dispatcher = TestDispatcher()
+        mockServer.start()
+
+        loginModel = LoginModel()
+        loginModel.baseURI = URI.create("/")
+        loginModel.credentials = Credentials("mock", "12345")
+
+        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
+            .addAuthentication(null, loginModel.credentials!!)
+            .build()
+
+        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
+    }
+
+    @After
+    fun cleanUp() {
+        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() {
+        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)
+
+        // Check home sets have been saved to database
+        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET/"), db.homeSetDao().getByService(service.id).first().url)
+        assertEquals(1, db.homeSetDao().getByService(service.id).size)
+    }
+
+
+    // refreshHomesetsAndTheirCollections
+
+    @Test
+    fun refreshHomesetsAndTheirCollections_addsNewCollection() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // save homeset in DB
+        val homesetId = db.homeSetDao().insert(
+            HomeSet(id=0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        // Refresh
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomesetsAndTheirCollections()
+
+        // Check the collection defined in homeset is now in the database
+        assertEquals(
+            Collection(
+                1,
+                service.id,
+                homesetId,
+                1, // will have gotten an owner too
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+                displayName = "My Contacts",
+                description = "My Contacts Description"
+            ),
+            db.collectionDao().getByService(service.id).first()
+        )
+    }
+
+    @Test
+    fun refreshHomesetsAndTheirCollections_updatesExistingCollection() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // save "old" collection in DB
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+                displayName = "My Contacts",
+                description = "My Contacts Description"
+            )
+        )
+
+        // Refresh
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomesetsAndTheirCollections()
+
+        // Check the collection got updated
+        assertEquals(
+            Collection(
+                collectionId,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+                displayName = "My Contacts",
+                description = "My Contacts Description"
+            ),
+            db.collectionDao().get(collectionId)
+        )
+    }
+
+    @Test
+    fun refreshHomesetsAndTheirCollections_preservesCollectionFlags() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // save "old" collection in DB - with set flags
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+                displayName = "My Contacts",
+                description = "My Contacts Description",
+                forceReadOnly = true,
+                sync = true
+            )
+        )
+
+        // Refresh
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomesetsAndTheirCollections()
+
+        // Check the collection got updated
+        assertEquals(
+            Collection(
+                collectionId,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+                displayName = "My Contacts",
+                description = "My Contacts Description",
+                forceReadOnly = true,
+                sync = true
+            ),
+            db.collectionDao().get(collectionId)
+        )
+    }
+
+    @Test
+    fun refreshHomesetsAndTheirCollections_marksRemovedCollectionsAsHomeless() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // save homeset in DB - which is empty (zero address books) on the serverside
+        val homesetId = db.homeSetDao().insert(
+            HomeSet(id=0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET_EMPTY"))
+        )
+
+        // place collection in DB - as part of the homeset
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                homesetId,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+            )
+        )
+
+        // Refresh - should mark collection as homeless, because serverside homeset is empty
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomesetsAndTheirCollections()
+
+        // Check the collection, is now marked as homeless
+        assertEquals(null, db.collectionDao().get(collectionId)!!.homeSetId)
+    }
+
+    @Test
+    fun refreshHomesetsAndTheirCollections_addsOwnerUrls() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // save a homeset in DB
+        val homesetId = db.homeSetDao().insert(
+            HomeSet(id=0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        // place collection in DB - as part of the homeset
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                homesetId, // part of above home set
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+            )
+        )
+
+        // Refresh - homesets and their collections
+        assertEquals(0, db.principalDao().getByService(service.id).size)
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomesetsAndTheirCollections()
+
+        // Check principal saved and the collection was updated with its reference
+        val principals = db.principalDao().getByService(service.id)
+        assertEquals(1, principals.size)
+        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), principals[0].url)
+        assertEquals(null, principals[0].displayName)
+        assertEquals(
+            principals[0].id,
+            db.collectionDao().get(collectionId)!!.ownerId
+        )
+    }
+
+
+    // refreshHomelessCollections
+
+    @Test
+    fun refreshHomelessCollections_updatesExistingCollection() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // place homeless collection in DB
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+            )
+        )
+
+        // Refresh
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomelessCollections()
+
+        // Check the collection got updated - with display name and description
+        assertEquals(
+            Collection(
+                collectionId,
+                service.id,
+                null,
+                1, // will have gotten an owner too
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+                displayName = "My Contacts",
+                description = "My Contacts Description"
+            ),
+            db.collectionDao().get(collectionId)
+        )
+    }
+
+    @Test
+    fun refreshHomelessCollections_deletesInaccessibleCollections() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // place homeless collection in DB - it is also inaccessible
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_INACCESSIBLE")
+            )
+        )
+
+        // Refresh - should delete collection
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomelessCollections()
+
+        // Check the collection got deleted
+        assertEquals(null, db.collectionDao().get(collectionId))
+    }
+
+    @Test
+    fun refreshHomelessCollections_addsOwnerUrls() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // place homeless collection in DB
+        val collectionId = db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                null,
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"),
+            )
+        )
+
+        // Refresh homeless collections
+        assertEquals(0, db.principalDao().getByService(service.id).size)
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshHomelessCollections()
+
+        // Check principal saved and the collection was updated with its reference
+        val principals = db.principalDao().getByService(service.id)
+        assertEquals(1, principals.size)
+        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), principals[0].url)
+        assertEquals(null, principals[0].displayName)
+        assertEquals(
+            principals[0].id,
+            db.collectionDao().get(collectionId)!!.ownerId
+        )
+    }
+
+
+    // refreshPrincipals
+
+    @Test
+    fun refreshPrincipals_inaccessiblePrincipal() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // place principal without display name in db
+        val principalId = db.principalDao().insert(
+            Principal(
+                0,
+                service.id,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL_INACCESSIBLE"), // no trailing slash
+                null // no display name for now
+            )
+        )
+        // add an associated collection - as the principal is rightfully removed otherwise
+        db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                principalId, // create association with principal
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"), // with trailing slash
+            )
+        )
+
+        // Refresh principals
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshPrincipals()
+
+        // Check principal was not updated
+        val principals = db.principalDao().getByService(service.id)
+        assertEquals(1, principals.size)
+        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL_INACCESSIBLE"), principals[0].url)
+        assertEquals(null, principals[0].displayName)
+    }
+
+    @Test
+    fun refreshPrincipals_updatesPrincipal() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // place principal without display name in db
+        val principalId = db.principalDao().insert(
+            Principal(
+                0,
+                service.id,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), // no trailing slash
+                null // no display name for now
+            )
+        )
+        // add an associated collection - as the principal is rightfully removed otherwise
+        db.collectionDao().insertOrUpdateByUrl(
+            Collection(
+                0,
+                service.id,
+                null,
+                principalId, // create association with principal
+                Collection.TYPE_ADDRESSBOOK,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"), // with trailing slash
+            )
+        )
+
+        // Refresh principals
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshPrincipals()
+
+        // Check principal now got a display name
+        val principals = db.principalDao().getByService(service.id)
+        assertEquals(1, principals.size)
+        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL"), principals[0].url)
+        assertEquals("Mr. Wobbles", principals[0].displayName)
+    }
+
+    @Test
+    fun refreshPrincipals_deletesPrincipalsWithoutCollections() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        // place principal without collections in DB
+        db.principalDao().insert(
+            Principal(
+                0,
+                service.id,
+                mockServer.url("$PATH_CARDDAV$SUBPATH_PRINCIPAL_WITHOUT_COLLECTIONS/")
+            )
+        )
+
+        // Refresh principals - detecting it does not own collections
+        RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+            .refreshPrincipals()
+
+        // Check principal was deleted
+        val principals = db.principalDao().getByService(service.id)
+        assertEquals(0, principals.size)
+    }
+
+    // Others
+
+    @Test
+    fun shouldPreselect_none() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        val settings = mockk<SettingsManager>()
+        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_NONE
+        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+        val collection = Collection(
+            0,
+            service.id,
+            0,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+        )
+        val homesets = listOf(
+            HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+        assertFalse(refresher.shouldPreselect(collection, homesets))
+    }
+
+    @Test
+    fun shouldPreselect_all() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        val settings = mockk<SettingsManager>()
+        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_ALL
+        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+        val collection = Collection(
+            0,
+            service.id,
+            0,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+        )
+        val homesets = listOf(
+            HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+        assertTrue(refresher.shouldPreselect(collection, homesets))
+    }
+
+    @Test
+    fun shouldPreselect_all_blacklisted() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+        val url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+
+        val settings = mockk<SettingsManager>()
+        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_ALL
+        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns url.toString()
+
+        val collection = Collection(
+            0,
+            service.id,
+            0,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = url
+        )
+        val homesets = listOf(
+            HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+        assertFalse(refresher.shouldPreselect(collection, homesets))
+    }
+
+    @Test
+    fun shouldPreselect_personal_notPersonal() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        val settings = mockk<SettingsManager>()
+        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
+        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+        val collection = Collection(
+            0,
+            service.id,
+            0,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+        )
+        val homesets = listOf(
+            HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+        assertFalse(refresher.shouldPreselect(collection, homesets))
+    }
+
+    @Test
+    fun shouldPreselect_personal_isPersonal() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        val settings = mockk<SettingsManager>()
+        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
+        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+        val collection = Collection(
+            0,
+            service.id,
+            0,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+        )
+        val homesets = listOf(
+            HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+        assertTrue(refresher.shouldPreselect(collection, homesets))
+    }
+
+    @Test
+    fun shouldPreselect_personal_isPersonalButBlacklisted() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+        val collectionUrl = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+
+        val settings = mockk<SettingsManager>()
+        every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
+        every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns collectionUrl.toString()
+
+        val collection = Collection(
+            0,
+            service.id,
+            0,
+            type = Collection.TYPE_ADDRESSBOOK,
+            url = collectionUrl
+        )
+        val homesets = listOf(
+            HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+        )
+
+        val refresher = RefreshCollectionsWorker.Refresher(db, service, settings, client.okHttpClient)
+        assertFalse(refresher.shouldPreselect(collection, homesets))
+    }
+
+    // Test helpers and dependencies
+    
+    private fun createTestService(serviceType: String) : Service? {
+        val service = Service(id=0, accountName="test", type=serviceType, principal = null)
+        val serviceId = db.serviceDao().insertOrReplace(service)
+        return db.serviceDao().get(serviceId)
+    }
+
+    class TestDispatcher: Dispatcher() {
+
+        override fun dispatch(request: RecordedRequest): MockResponse {
+            val path = StringUtils.removeEnd(request.path!!, "/")
+
+            if (request.method.equals("PROPFIND", true)) {
+                val properties = when (path) {
+                    PATH_CALDAV,
+                    PATH_CARDDAV ->
+                        "<current-user-principal>" +
+                        "   <href>$path${SUBPATH_PRINCIPAL}</href>" +
+                        "</current-user-principal>"
+
+                    PATH_CARDDAV + SUBPATH_PRINCIPAL ->
+                        "<resourcetype><principal/></resourcetype>" +
+                        "<displayname>Mr. Wobbles</displayname>" +
+                        "<CARD:addressbook-home-set>" +
+                        "   <href>${PATH_CARDDAV}${SUBPATH_ADDRESSBOOK_HOMESET}</href>" +
+                        "</CARD:addressbook-home-set>"
+
+                    PATH_CARDDAV + SUBPATH_PRINCIPAL_WITHOUT_COLLECTIONS ->
+                        "<CARD:addressbook-home-set>" +
+                        "   <href>${PATH_CARDDAV}${SUBPATH_ADDRESSBOOK_HOMESET_EMPTY}</href>" +
+                        "</CARD:addressbook-home-set>" +
+                        "<displayname>Mr. Wobbles Jr.</displayname>"
+
+                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK,
+                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK_HOMESET ->
+                        "<resourcetype>" +
+                        "   <collection/>" +
+                        "   <CARD:addressbook/>" +
+                        "</resourcetype>" +
+                        "<displayname>My Contacts</displayname>" +
+                        "<CARD:addressbook-description>My Contacts Description</CARD:addressbook-description>" +
+                        "<owner>" +
+                        "   <href>${PATH_CARDDAV + SUBPATH_PRINCIPAL}</href>" +
+                        "</owner>"
+
+                    PATH_CALDAV + SUBPATH_PRINCIPAL ->
+                        "<CAL:calendar-user-address-set>" +
+                        "  <href>urn:unknown-entry</href>" +
+                        "  <href>mailto:email1@example.com</href>" +
+                        "  <href>mailto:email2@example.com</href>" +
+                        "</CAL:calendar-user-address-set>"
+
+                    SUBPATH_ADDRESSBOOK_HOMESET_EMPTY -> ""
+
+                    else -> ""
+                }
+
+                var responseBody = ""
+                var responseCode = 207
+                when (path) {
+                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK_HOMESET ->
+                        responseBody =
+                            "<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
+                            "<response>" +
+                            "   <href>${PATH_CARDDAV + SUBPATH_ADDRESSBOOK}</href>" +
+                            "   <propstat><prop>" +
+                                    properties +
+                            "   </prop></propstat>" +
+                            "   <status>HTTP/1.1 200 OK</status>" +
+                            "</response>" +
+                            "</multistatus>"
+
+                    PATH_CARDDAV + SUBPATH_PRINCIPAL_INACCESSIBLE,
+                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK_INACCESSIBLE ->
+                        responseCode = 404
+
+                    else ->
+                        responseBody =
+                            "<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
+                            "<response>" +
+                            "   <href>$path</href>" +
+                            "   <propstat><prop>"+
+                                    properties +
+                            "   </prop></propstat>" +
+                            "</response>" +
+                            "</multistatus>"
+                }
+
+                Logger.log.info("Queried: $path")
+                Logger.log.info("Response: $responseBody")
+                return MockResponse()
+                    .setResponseCode(responseCode)
+                    .setBody(responseBody)
+            }
+
+            return MockResponse().setResponseCode(404)
+        }
+
+    }
+}

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

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

@@ -1,38 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Test
-
-class DefaultsSettingsProviderTest {
-
-    private val provider: SettingsProvider = DefaultsProvider()
-
-    @Test
-    fun testHas() {
-        assertEquals(Pair(false, true), provider.has("notExisting"))
-        assertEquals(Pair(true, true), provider.has(Settings.OVERRIDE_PROXY))
-    }
-
-    @Test
-    fun testGet() {
-        assertEquals(Pair("localhost", true), provider.getString(Settings.OVERRIDE_PROXY_HOST))
-        assertEquals(Pair(8118, true), provider.getInt(Settings.OVERRIDE_PROXY_PORT))
-    }
-
-    @Test
-    fun testPutRemove() {
-        assertEquals(Pair(false, true), provider.isWritable(Settings.OVERRIDE_PROXY))
-        assertFalse(provider.putBoolean(Settings.OVERRIDE_PROXY, true))
-        assertFalse(provider.remove(Settings.OVERRIDE_PROXY))
-    }
-
-}

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

@@ -0,0 +1,41 @@
+/***************************************************************************************************
+ * 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/settings/SettingsTest.kt

@@ -1,34 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-
-class SettingsTest {
-
-    lateinit var settings: Settings
-
-    @Before
-    fun initialize() {
-        settings = Settings.getInstance(InstrumentationRegistry.getInstrumentation().targetContext)
-    }
-
-    @Test
-    fun testHas() {
-        assertFalse(settings.has("notExisting"))
-
-        // provided by DefaultsProvider
-        assertTrue(settings.has(Settings.OVERRIDE_PROXY))
-    }
-
-}

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

@@ -0,0 +1,13 @@
+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/DebugInfoActivityTest.kt

@@ -0,0 +1,37 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.ui
+
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class DebugInfoActivityTest {
+
+    @Test
+    fun testIntentBuilder_LargeLocalResource() {
+        val a = 'A'.code.toByte()
+        val intent = DebugInfoActivity.IntentBuilder(InstrumentationRegistry.getInstrumentation().context)
+            .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("...")
+        assertEquals(expected.toString(), intent.getStringExtra("localResource"))
+    }
+
+    @Test
+    fun testIntentBuilder_LargeLogs() {
+        val a = 'A'.code.toByte()
+        val intent = DebugInfoActivity.IntentBuilder(InstrumentationRegistry.getInstrumentation().context)
+            .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("...")
+        assertEquals(expected.toString(), intent.getStringExtra("logs"))
+    }
+
+}

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

@@ -0,0 +1,222 @@
+/***************************************************************************************************
+ * 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
+
+// COMMENTED OUT because it doesn't run reliably [see https://github.com/bitfireAT/davx5/pull/320]
+/*@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() {
+        try {
+            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 will try to start an initial collection refresh, which we don't need, so we mockk it
+            mockkObject(RefreshCollectionsWorker.Companion)
+            every { RefreshCollectionsWorker.refreshCollections(any(), any()) } returns ""
+
+            // 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
+            }
+        } catch (e: InterruptedException) {
+            // The sync adapter framework will start a sync, which can get interrupted. We don't care
+            // about being interrupted. If it happens the test is not too important.
+        }
+    }
+
+}*/

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

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

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

@@ -0,0 +1,255 @@
+/***************************************************************************************************
+ * 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 dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import okhttp3.CookieJar
+import okhttp3.mockwebserver.Dispatcher
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import okhttp3.mockwebserver.RecordedRequest
+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 java.net.URI
+import javax.inject.Inject
+
+@HiltAndroidTest
+class DavDocumentsProviderTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
+
+    @Inject lateinit var db: AppDatabase
+
+    @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.start()
+
+        loginModel = LoginModel()
+        loginModel.baseURI = URI.create("/")
+        loginModel.credentials = Credentials("mock", "12345")
+
+        client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
+            .addAuthentication(null, loginModel.credentials!!)
+            .build()
+
+        // mock server delivers HTTP without encryption
+        assertTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
+    }
+
+    @After
+    fun cleanUp() {
+        mockServer.shutdown()
+        db.close()
+    }
+
+
+    @Test
+    fun testDoQueryChildren_insert() {
+        // Create parent and root in database
+        val id = db.webDavMountDao().insert(WebDavMount(0, "Cat food storage", mockServer.url(PATH_WEBDAV_ROOT)))
+        val webDavMount = db.webDavMountDao().getById(id)
+        val parent = db.webDavDocumentDao().getOrCreateRoot(webDavMount)
+        val cookieStore = mutableMapOf<Long, CookieJar>()
+
+        // Query
+        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+            .queryChildren(parent)
+
+        // Assert new children were inserted into db
+        assertEquals(3, db.webDavDocumentDao().getChildren(parent.id).size)
+        assertEquals("Secret_Document.pages", db.webDavDocumentDao().getChildren(parent.id)[0].displayName)
+        assertEquals("MeowMeow_Cats.docx", db.webDavDocumentDao().getChildren(parent.id)[1].displayName)
+        assertEquals("Library", db.webDavDocumentDao().getChildren(parent.id)[2].displayName)
+    }
+
+    @Test
+    fun testDoQueryChildren_update() {
+        // Create parent and root in database
+        val mountId = db.webDavMountDao().insert(WebDavMount(0, "Cat food storage", mockServer.url(PATH_WEBDAV_ROOT)))
+        val webDavMount = db.webDavMountDao().getById(mountId)
+        val parent = db.webDavDocumentDao().getOrCreateRoot(webDavMount)
+        val cookieStore = mutableMapOf<Long, CookieJar>()
+        assertEquals("Cat food storage", db.webDavDocumentDao().get(parent.id)!!.displayName)
+
+        // Create a folder
+        val folderId = db.webDavDocumentDao().insert(
+            WebDavDocument(
+                0,
+                mountId,
+                parent.id,
+                "My_Books",
+                true,
+                "My Books",
+            )
+        )
+        assertEquals("My_Books", db.webDavDocumentDao().get(folderId)!!.name)
+        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))
+            .queryChildren(parent)
+
+        // Assert parent and children were updated in database
+        assertEquals("Cats WebDAV", db.webDavDocumentDao().get(parent.id)!!.displayName)
+        assertEquals("Library", db.webDavDocumentDao().getChildren(parent.id)[2].name)
+        assertEquals("Library", db.webDavDocumentDao().getChildren(parent.id)[2].displayName)
+
+    }
+
+    @Test
+    fun testDoQueryChildren_delete() {
+        // Create parent and root in database
+        val mountId = db.webDavMountDao().insert(WebDavMount(0, "Cat food storage", mockServer.url(PATH_WEBDAV_ROOT)))
+        val webDavMount = db.webDavMountDao().getById(mountId)
+        val parent = db.webDavDocumentDao().getOrCreateRoot(webDavMount)
+        val cookieStore = mutableMapOf<Long, CookieJar>()
+
+        // Create a folder
+        val folderId = db.webDavDocumentDao().insert(
+            WebDavDocument(0, mountId, parent.id, "deleteme", true, "Should be deleted")
+        )
+        assertEquals("deleteme", db.webDavDocumentDao().get(folderId)!!.name)
+
+        // Query - discovers serverside deletion
+        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+            .queryChildren(parent)
+
+        // Assert folder got deleted
+        assertEquals(null, db.webDavDocumentDao().get(folderId))
+    }
+
+    @Test
+    fun testDoQueryChildren_updateTwoParentsSimultaneous() {
+        // Create root in database
+        val mountId = db.webDavMountDao().insert(WebDavMount(0, "Cat food storage", mockServer.url(PATH_WEBDAV_ROOT)))
+        val webDavMount = db.webDavMountDao().getById(mountId)
+        val root = db.webDavDocumentDao().getOrCreateRoot(webDavMount)
+        val cookieStore = mutableMapOf<Long, CookieJar>()
+
+        // Create two parents
+        val parent1Id = db.webDavDocumentDao().insert(WebDavDocument(0, mountId, root.id, "parent1", true))
+        val parent2Id = db.webDavDocumentDao().insert(WebDavDocument(0, mountId, root.id, "parent2", true))
+        val parent1 = db.webDavDocumentDao().get(parent1Id)!!
+        val parent2 = db.webDavDocumentDao().get(parent2Id)!!
+        assertEquals("parent1", parent1.name)
+        assertEquals("parent2", parent2.name)
+
+        // Query - find children of two nodes simultaneously
+        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+            .queryChildren(parent1)
+        DavDocumentsProvider.DavDocumentsActor(context, db, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+            .queryChildren(parent2)
+
+        // Assert the two folders names have changed
+        assertEquals("childOne.txt", db.webDavDocumentDao().getChildren(parent1Id)[0].name)
+        assertEquals("childTwo.txt", db.webDavDocumentDao().getChildren(parent2Id)[0].name)
+    }
+
+
+    // mock server
+
+    class TestDispatcher: Dispatcher() {
+
+        data class Resource(
+            val name: String,
+            val props: String
+        )
+
+        override fun dispatch(request: RecordedRequest): MockResponse {
+            val requestPath = request.path!!.trimEnd('/')
+
+            if (request.method.equals("PROPFIND", true)) {
+
+                val propsMap = mutableMapOf(
+                    PATH_WEBDAV_ROOT to arrayOf(
+                        Resource("",
+                            "<resourcetype><collection/></resourcetype>" +
+                            "<displayname>Cats WebDAV</displayname>"
+                        ),
+                        Resource("Secret_Document.pages",
+                            "<displayname>Secret_Document.pages</displayname>",
+                        ),
+                        Resource("MeowMeow_Cats.docx",
+                            "<displayname>MeowMeow_Cats.docx</displayname>"
+                        ),
+                        Resource("Library",
+                            "<resourcetype><collection/></resourcetype>" +
+                            "<displayname>Library</displayname>"
+                        )
+                    ),
+
+                    "$PATH_WEBDAV_ROOT/parent1" to arrayOf(
+                        Resource("childOne.txt",
+                            "<displayname>childOne.txt</displayname>"
+                        ),
+                    ),
+                    "$PATH_WEBDAV_ROOT/parent2" to arrayOf(
+                        Resource("childTwo.txt",
+                            "<displayname>childTwo.txt</displayname>"
+                        )
+                    )
+                )
+
+                val responses = propsMap[requestPath]?.joinToString { resource ->
+                    "<response><href>$requestPath/${resource.name}</href><propstat><prop>" +
+                            resource.props +
+                    "</prop></propstat></response>"
+                }
+
+                val multistatus =
+                    "<multistatus xmlns='DAV:' " +
+                        "xmlns:CARD='urn:ietf:params:xml:ns:carddav' " +
+                        "xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
+                        responses +
+                    "</multistatus>"
+
+                Logger.log.info("Query path: $requestPath")
+                Logger.log.info("Response: $multistatus")
+                return MockResponse()
+                    .setResponseCode(207)
+                    .setBody(multistatus)
+            }
+
+            return MockResponse().setResponseCode(404)
+        }
+
+    }
+
+}

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

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

@@ -0,0 +1,159 @@
+/***************************************************************************************************
+ * 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/res/values/strings.xml

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

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

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

app/src/androidTestOse/java/at/bitfire/davdroid/OkhttpClientTest.kt

@@ -0,0 +1,44 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid
+
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import okhttp3.Request
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class OkhttpClientTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testIcloudWithSettings() {
+        val client = HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext)
+                .build()
+        client.okHttpClient.newCall(Request.Builder()
+                .get()
+                .url("https://icloud.com")
+                .build())
+                .execute()
+    }
+
+}

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

@@ -0,0 +1,59 @@
+/***************************************************************************************************
+ * 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.os.Bundle
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Assert.assertEquals
+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
+class AccountUtilsTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    @Before
+    fun inject() {
+        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/\"-")
+        try {
+            assertTrue(AccountUtils.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))
+        }
+    }
+
+}

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

@@ -0,0 +1,42 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.syncadapter
+
+import at.bitfire.davdroid.db.SyncState
+import at.bitfire.davdroid.resource.LocalCollection
+
+class LocalTestCollection: LocalCollection<LocalTestResource> {
+
+    override val tag = "LocalTestCollection"
+    override val title = "Local Test Collection"
+
+    override var lastSyncState: SyncState? = null
+
+    val entries = mutableListOf<LocalTestResource>()
+
+    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 markNotDirty(flags: Int): Int {
+        var updated = 0
+        for (dirty in findDirty()) {
+            dirty.flags = flags
+            updated++
+        }
+        return updated
+    }
+
+    override fun removeNotDirtyMarked(flags: Int): Int {
+        val numBefore = entries.size
+        entries.removeIf { !it.dirty && it.flags == flags }
+        return numBefore - entries.size
+    }
+
+    override fun forgetETags() {
+    }
+
+}

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

@@ -0,0 +1,38 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.syncadapter
+
+import at.bitfire.davdroid.resource.LocalResource
+
+class LocalTestResource: LocalResource<Any> {
+
+    override val id: Long? = null
+    override var fileName: String? = null
+    override var eTag: String? = null
+    override var scheduleTag: String? = null
+    override var flags: Int = 0
+
+    var deleted = false
+    var dirty = false
+
+    override fun prepareForUpload() = "generated-file.txt"
+
+    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
+        dirty = false
+        if (fileName != null)
+            this.fileName = fileName
+        this.eTag = eTag
+        this.scheduleTag = scheduleTag
+    }
+
+    override fun updateFlags(flags: Int) {
+        this.flags = flags
+    }
+
+    override fun add() = throw NotImplementedError()
+    override fun update(data: Any) = throw NotImplementedError()
+    override fun delete() = throw NotImplementedError()
+
+}

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

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

@@ -0,0 +1,528 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.syncadapter
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.Context
+import android.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.R
+import at.bitfire.davdroid.TestUtils.assertWithin
+import at.bitfire.davdroid.db.Credentials
+import at.bitfire.davdroid.db.SyncState
+import at.bitfire.davdroid.network.HttpClient
+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 okhttp3.Protocol
+import okhttp3.internal.http.StatusLine
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.After
+import org.junit.AfterClass
+import org.junit.Assert.assertEquals
+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.time.Instant
+import java.util.concurrent.TimeUnit
+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()
+        }
+
+    }
+
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
+
+    @Inject
+    lateinit var workerFactory: HiltWorkerFactory
+
+    val server = MockWebServer()
+
+    @Before
+    fun inject() {
+        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)
+    }
+
+
+    private fun syncManager(collection: LocalTestCollection, syncResult: SyncResult = SyncResult()) =
+            TestSyncManager(
+                    context,
+                    account,
+                    arrayOf(),
+                    "TestAuthority",
+                    HttpClient.Builder(InstrumentationRegistry.getInstrumentation().targetContext).build(),
+                    syncResult,
+                    collection,
+                    server
+            )
+
+    @Before
+    fun startServer() {
+        server.start()
+    }
+
+    @After
+    fun stopServer() {
+        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
+    }
+
+    @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
+    fun testPerformSync_FirstSync_Empty() {
+        val collection = LocalTestCollection() /* no last known ctag */
+        server.enqueue(queryCapabilitiesResponse())
+
+        val syncManager = syncManager(collection)
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertTrue(collection.entries.isEmpty())
+    }
+
+    @Test
+    fun testPerformSync_UploadNewMember_ETagOnPut() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 204 No Content
+        server.enqueue(MockResponse()
+                .setResponseCode(204)
+                .setHeader("ETag", "etag-from-put"))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/generated-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"etag-from-put\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("etag-from-put", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_UploadModifiedMember_ETagOnPut() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "existing-file.txt"
+                eTag = "old-etag-like-on-server"
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 204 No Content
+        server.enqueue(MockResponse()
+                .setResponseCode(204)
+                .addHeader("ETag", "etag-from-put"))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/existing-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("etag-from-put")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/existing-file.txt"), "etag-from-put"))
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("etag-from-put", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_UploadModifiedMember_NoETagOnPut() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "existing-file.txt"
+                eTag = "old-etag-like-on-server"
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 204 No Content
+        server.enqueue(MockResponse().setResponseCode(204))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/existing-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("etag-from-propfind")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/existing-file.txt"), "etag-from-propfind"))
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("etag-from-propfind", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_UploadModifiedMember_412PreconditionFailed() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "existing-file.txt"
+                eTag = "etag-that-has-been-changed-on-server-in-the-meanwhile"
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 412 Precondition Failed
+        server.enqueue(MockResponse()
+                .setResponseCode(412))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/existing-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("changed-etag-from-server")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/existing-file.txt"), "changed-etag-from-server"))
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("changed-etag-from-server", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_NoopOnMemberWithSameETag() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "ctag1")
+            entries += LocalTestResource().apply {
+                fileName = "downloaded-member.txt"
+                eTag = "MemberETag1"
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/downloaded-member.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"MemberETag1\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+        }
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("MemberETag1", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_DownloadNewMember() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+        }
+        server.enqueue(queryCapabilitiesResponse(cTag = "new-ctag"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/new-member.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"NewMemberETag1\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                    )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/new-member.txt"), "NewMemberETag1"))
+        }
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("NewMemberETag1", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_DownloadUpdatedMember() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "downloaded-member.txt"
+                eTag = "MemberETag1"
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse(cTag = "new-ctag"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/downloaded-member.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"MemberETag2\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/downloaded-member.txt"), "MemberETag2"))
+        }
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("MemberETag2", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_RemoveVanishedMember() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "downloaded-member.txt"
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse(cTag = "new-ctag"))
+
+        val syncManager = syncManager(collection)
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertTrue(collection.entries.isEmpty())
+    }
+
+    @Test
+    fun testPerformSync_CTagDidntChange() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "ctag1")
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        val syncManager = syncManager(collection)
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertFalse(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertTrue(collection.entries.isEmpty())
+    }
+
+}

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

@@ -0,0 +1,159 @@
+/***************************************************************************************************
+ * 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.network.ConnectionUtils
+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(ConnectionUtils)
+        every { ConnectionUtils.wifiAvailable(any()) } returns true
+        mockkObject(SyncWorker.Companion)
+        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(ConnectionUtils)
+        every { ConnectionUtils.wifiAvailable(any()) } returns false
+        mockkObject(SyncWorker.Companion)
+        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

@@ -0,0 +1,73 @@
+/***************************************************************************************************
+ * 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/androidTestOse/java/at/bitfire/davdroid/syncadapter/TestSyncManager.kt

@@ -0,0 +1,104 @@
+/***************************************************************************************************
+ * 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.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.davdroid.db.SyncState
+import at.bitfire.davdroid.resource.LocalResource
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.util.DavUtils
+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) {
+
+    override fun prepare(): Boolean {
+        collectionURL = mockWebServer.url("/")
+        davCollection = DavCollection(httpClient.okHttpClient, collectionURL)
+        return true
+    }
+
+    var didQueryCapabilities = false
+    override fun queryCapabilities(): SyncState? {
+        if (didQueryCapabilities)
+            throw IllegalStateException("queryCapabilities() must not be called twice")
+        didQueryCapabilities = true
+
+        var cTag: SyncState? = null
+        davCollection.propfind(0, GetCTag.NAME) { response, rel ->
+            if (rel == Response.HrefRelation.SELF)
+                response[GetCTag::class.java]?.cTag?.let {
+                    cTag = SyncState(SyncState.Type.CTAG, it)
+                }
+        }
+
+        return cTag
+    }
+
+    var didGenerateUpload = false
+    override fun generateUpload(resource: LocalTestResource): RequestBody {
+        didGenerateUpload = true
+        return resource.toString().toRequestBody()
+    }
+
+    override fun syncAlgorithm() = SyncAlgorithm.PROPFIND_REPORT
+
+    var listAllRemoteResult = emptyList<Pair<Response, Response.HrefRelation>>()
+    var didListAllRemote = false
+    override fun listAllRemote(callback: MultiResponseCallback) {
+        if (didListAllRemote)
+            throw IllegalStateException("listAllRemote() must not be called twice")
+        didListAllRemote = true
+        for (result in listAllRemoteResult)
+            callback.onResponse(result.first, result.second)
+    }
+
+    var assertDownloadRemote = emptyMap<HttpUrl, String>()
+    var didDownloadRemote = false
+    override fun downloadRemote(bunch: List<HttpUrl>) {
+        didDownloadRemote = true
+        assertEquals(assertDownloadRemote.keys.toList(), bunch)
+
+        for ((url, eTag) in assertDownloadRemote) {
+            val fileName = DavUtils.lastSegmentOfUrl(url)
+            var localEntry = localCollection.entries.filter { it.fileName == fileName }.firstOrNull()
+            if (localEntry == null) {
+                val newEntry = LocalTestResource().also {
+                    it.fileName = fileName
+                }
+                localCollection.entries += newEntry
+                localEntry = newEntry
+            }
+            localEntry.eTag = eTag
+            localEntry.flags = LocalResource.FLAG_REMOTELY_PRESENT
+        }
+    }
+
+    override fun postProcess() {
+    }
+
+    override fun notifyInvalidResourceTitle() =
+        throw NotImplementedError()
+
+}

app/src/main/AndroidManifest.xml

@@ -1,16 +1,18 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest package="at.bitfire.davdroid"
-          xmlns:android="http://schemas.android.com/apk/res/android"
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
           xmlns:tools="http://schemas.android.com/tools"
           android:installLocation="internalOnly">
 
     <!-- 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"/>
     <uses-permission android:name="android.permission.READ_SYNC_STATS"/>
     <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
     <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
 
     <!-- account management permissions not required for own accounts since API level 22 -->
@@ -29,28 +31,49 @@
     <!-- android.permission-group.LOCATION -->
     <!-- getting the WiFi name (for "sync in Wifi only") requires
       - coarse location (Android 8.1)
-      - fine location (Android 10)  -->
+      - fine location (Android 10) -->
+    <uses-permission-sdk-23 android:name="android.permission.ACCESS_COARSE_LOCATION"/>
     <uses-permission-sdk-23 android:name="android.permission.ACCESS_FINE_LOCATION"/>
     <!-- required since Android 10 to get the WiFi name while in background (= while syncing) -->
     <uses-permission-sdk-23 android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
 
     <!-- ical4android declares task access permissions -->
 
+    <!-- Disable GPS capability requirement, which is implicitly derived from ACCESS_FINE_LOCATION
+    permission and makes app unusable on some devices without GPS. We need location permissions only
+    to get the current WiFi SSID, and we don't need GPS for that. -->
+    <uses-feature android:name="android.hardware.location.gps" android:required="false" />
+
     <application
         android:name=".App"
         android:allowBackup="false"
         android:networkSecurityConfig="@xml/network_security_config"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
-        android:theme="@style/AppThemeExt"
-        tools:ignore="UnusedAttribute">
+        android:theme="@style/AppTheme"
+        android:resizeableActivity="true"
+        tools:ignore="UnusedAttribute"
+        android:supportsRtl="true">
 
-        <service android:name=".DavService"/>
+        <!-- required for Hilt/WorkManager integration -->
+        <provider
+            android:name="androidx.startup.InitializationProvider"
+            android:authorities="${applicationId}.androidx-startup"
+            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.AccountsActivity"
             android:label="@string/app_name"
-            android:theme="@style/AppTheme.NoActionBar">
+            android:theme="@style/AppTheme.NoActionBar"
+            android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN"/>
                 <category android:name="android.intent.category.LAUNCHER"/>
@@ -70,28 +93,9 @@
             android:exported="true">
             <intent-filter>
                 <action android:name="android.intent.action.APPLICATION_PREFERENCES"/>
+                <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
-
-        <activity
-            android:name=".ui.setup.LoginActivity"
-            android:label="@string/login_title"
-            android:parentActivityName=".ui.AccountsActivity">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN"/>
-            </intent-filter>
-        </activity>
-
-        <activity
-            android:name=".ui.account.AccountActivity"
-            android:parentActivityName=".ui.AccountsActivity"
-            android:theme="@style/AppTheme.NoActionBar"/>
-        <activity android:name=".ui.AccountSettingsActivity"/>
-        <activity android:name=".ui.CreateAddressBookActivity"
-            android:label="@string/create_addressbook"/>
-        <activity android:name=".ui.CreateCalendarActivity"
-                  android:label="@string/create_calendar"/>
-
         <activity
             android:name=".ui.DebugInfoActivity"
             android:parentActivityName=".ui.AppSettingsActivity"
@@ -99,17 +103,75 @@
             android:label="@string/debug_info_title">
             <intent-filter>
                 <action android:name="android.intent.action.BUG_REPORT"/>
+                <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
-        <provider
-            android:name="androidx.core.content.FileProvider"
-            android:authorities="@string/authority_debug_provider"
-            android:grantUriPermissions="true"
-            android:exported="false">
-            <meta-data
-                android:name="android.support.FILE_PROVIDER_PATHS"
-                android:resource="@xml/debug_paths" />
-        </provider>
+        <activity
+            android:name=".ui.PermissionsActivity"
+            android:label="@string/app_settings_security_app_permissions"
+            android:parentActivityName=".ui.AppSettingsActivity" />
+        <activity
+            android:name=".ui.TasksActivity"
+            android:label="@string/intro_tasks_title"
+            android:parentActivityName=".ui.AppSettingsActivity" />
+
+        <activity
+            android:name=".ui.setup.LoginActivity"
+            android:label="@string/login_title"
+            android:parentActivityName=".ui.AccountsActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW"/>
+                <category android:name="android.intent.category.BROWSABLE"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <data android:scheme="caldav"/>
+                <data android:scheme="caldavs"/>
+                <data android:scheme="carddav"/>
+                <data android:scheme="carddavs"/>
+                <data android:scheme="davx5"/>
+            </intent-filter>
+            <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 android:scheme="https" />
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".ui.account.AccountActivity"
+            android:parentActivityName=".ui.AccountsActivity"
+            android:theme="@style/AppTheme.NoActionBar"
+            android:exported="true">
+        </activity>
+        <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:parentActivityName=".ui.account.AccountActivity" />
+        <activity
+            android:name=".ui.account.WifiPermissionsActivity"
+            android:label="@string/wifi_permissions_label"
+            android:parentActivityName=".ui.account.SettingsActivity" />
+
+        <activity
+            android:name=".ui.webdav.WebdavMountsActivity"
+            android:label="@string/webdav_mounts_title"
+            android:parentActivityName=".ui.AccountsActivity"
+            android:exported="true" />
+        <activity
+            android:name=".ui.webdav.AddWebdavMountActivity"
+            android:label="@string/webdav_add_mount_title"
+            android:parentActivityName=".ui.webdav.WebdavMountsActivity" />
 
         <!-- account type "DAVx⁵" -->
         <service
@@ -118,7 +180,6 @@
             <intent-filter>
                 <action android:name="android.accounts.AccountAuthenticator"/>
             </intent-filter>
-
             <meta-data
                 android:name="android.accounts.AccountAuthenticator"
                 android:resource="@xml/account_authenticator"/>
@@ -130,28 +191,58 @@
             <intent-filter>
                 <action android:name="android.content.SyncAdapter"/>
             </intent-filter>
-
             <meta-data
                 android:name="android.content.SyncAdapter"
                 android:resource="@xml/sync_calendars"/>
         </service>
         <service
-            android:name=".syncadapter.TasksSyncAdapterService"
+            android:name=".syncadapter.JtxSyncAdapterService"
             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_tasks"/>
+                android:resource="@xml/sync_notes"/>
         </service>
+        <service
+            android:name=".syncadapter.OpenTasksSyncAdapterService"
+            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_opentasks"/>
+        </service>
+        <service
+            android:name=".syncadapter.TasksOrgSyncAdapterService"
+            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_tasks_org"/>
+        </service>
+        <provider
+            android:authorities="@string/webdav_authority"
+            android:name=".webdav.DavDocumentsProvider"
+            android:exported="true"
+            android:grantUriPermissions="true"
+            android:permission="android.permission.MANAGE_DOCUMENTS">
+            <intent-filter>
+                <action android:name="android.content.action.DOCUMENTS_PROVIDER" />
+            </intent-filter>
+        </provider>
 
         <!-- account type "DAVx⁵ Address book" -->
         <service
-            android:name=".syncadapter.NullAuthenticatorService"
-            android:exported="false">
+            android:name=".syncadapter.AddressBookAuthenticatorService"
+            android:exported="true">   <!-- 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>
@@ -164,8 +255,7 @@
             android:authorities="@string/address_books_authority"
             android:exported="false"
             android:label="@string/address_books_authority_title"
-            android:name=".syncadapter.AddressBookProvider"
-            android:multiprocess="false"/>
+            android:name=".syncadapter.AddressBookProvider" />
         <service
             android:name=".syncadapter.AddressBooksSyncAdapterService"
             android:exported="true"
@@ -194,6 +284,54 @@
                 android:resource="@xml/contacts"/>
         </service>
 
+        <!-- provider to share debug info/logs -->
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="@string/authority_debug_provider"
+            android:grantUriPermissions="true"
+            android:exported="false">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/debug_paths" />
+        </provider>
+
     </application>
 
-</manifest>
+    <!-- package visiblity – which apps do we need to see? -->
+    <queries>
+        <!-- system providers (listing them is technically not required, but some apps like the
+        Huawei calendar take this as indication of whether these providers are accessed) -->
+        <provider android:authorities="com.android.calendar"/>
+        <provider android:authorities="com.android.contacts"/>
+
+        <!-- task providers -->
+        <package android:name="at.techbee.jtx" />
+        <package android:name="org.dmfs.tasks" />
+        <package android:name="org.tasks" />
+
+        <!-- ICSx5 for Webcal feeds -->
+        <package android:name="at.bitfire.icsdroid"/>
+
+        <!-- apps that interact with contact, calendar, task data (for debug info) -->
+        <intent>
+            <action android:name="*" />
+            <data android:scheme="content" android:host="com.android.contacts" />
+        </intent>
+        <intent>
+            <action android:name="*" />
+            <data android:scheme="content" android:host="com.android.calendar" />
+        </intent>
+
+        <!-- Open URLs in a browser or other app [https://developer.android.com/training/package-visibility/use-cases#open-urls-browser-or-other-app] -->
+        <intent>
+            <action android:name="android.intent.action.VIEW" />
+            <data android:scheme="https" />
+        </intent>
+
+        <!-- Custom Tabs support (e.g. Nextcloud Login Flow) -->
+        <intent>
+            <action android:name="android.support.customtabs.action.CustomTabsService" />
+        </intent>
+    </queries>
+
+</manifest>

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

@@ -0,0 +1,38 @@
+carddav.a1.net
+aol.com
+calendar.dingtalk.com/dav/
+cloud.disroot.org
+dav.edis.at
+dav.fruux.com
+caldav.gmx.com
+caldav.gmx.co.uk
+caldav.gmx.de
+caldav.gmx.es
+caldav.gmx.fr
+caldav.gmx.net
+carddav.gmx.com
+carddav.gmx.co.uk
+carddav.gmx.de
+carddav.gmx.es
+carddav.gmx.fr
+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/java/at/bitfire/davdroid/App.kt

@@ -1,62 +1,74 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * 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.content.Intent
-import android.content.IntentFilter
-import android.graphics.Bitmap
-import android.graphics.drawable.BitmapDrawable
 import android.net.Uri
-import android.os.Build
 import android.os.StrictMode
-import androidx.appcompat.app.AppCompatDelegate
 import androidx.appcompat.content.res.AppCompatResources
-import androidx.multidex.MultiDexApplication
+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
 
-@Suppress("unused")
-class App: MultiDexApplication(), Thread.UncaughtExceptionHandler {
+@HiltAndroidApp
+class App: Application(), Thread.UncaughtExceptionHandler, Configuration.Provider {
 
     companion object {
 
-        fun getLauncherBitmap(context: Context): Bitmap? {
-            val drawableLogo = AppCompatResources.getDrawable(context, R.mipmap.ic_launcher)
-            return if (drawableLogo is BitmapDrawable)
-                drawableLogo.bitmap
-            else
-                null
-        }
+        const val HOMEPAGE_PRIVACY = "privacy"
 
-        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()!!
+        fun getLauncherBitmap(context: Context) =
+                AppCompatResources.getDrawable(context, R.mipmap.ic_launcher)?.toBitmap()
+
+        /**
+         * Gets the DAVx5 Web site URL that should be used to open in the user's browser.
+         * Package ID, version number and calling context name will be appended as arguments.
+         *
+         * @param context   context name to use
+         * @param page      optional page segment to append (for instance: [HOMEPAGE_PRIVACY]])
+         *
+         * @return the Uri for the browser
+         */
+        fun homepageUrl(context: Context, page: String? = null): Uri {
+            val builder = Uri.parse(context.getString(R.string.homepage_url)).buildUpon()
+
+            if (page != null)
+                builder.appendPath(page)
+
+            return builder
+                .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.FLAVOR == FLAVOR_STANDARD)
-            Thread.setDefaultUncaughtExceptionHandler(this)
-
         if (BuildConfig.DEBUG)
+            // debug builds
             StrictMode.setVmPolicy(StrictMode.VmPolicy.Builder()
                     .detectActivityLeaks()
                     .detectFileUriExposure()
@@ -65,32 +77,49 @@ class App: MultiDexApplication(), Thread.UncaughtExceptionHandler {
                     .detectLeakedSqlLiteObjects()
                     .penaltyLog()
                     .build())
-
-        if (Build.VERSION.SDK_INT <= 21)
-            AppCompatDelegate.setCompatVectorFromResourcesEnabled(true)
+        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 installed/removed apps
-            val tasksFilter = IntentFilter()
-            tasksFilter.addAction(Intent.ACTION_PACKAGE_ADDED)
-            tasksFilter.addAction(Intent.ACTION_PACKAGE_FULLY_REMOVED)
-            tasksFilter.addDataScheme("package")
-            registerReceiver(PackageChangedReceiver(), tasksFilter)
+            // 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
-            PackageChangedReceiver.updateTaskSync(this)
+            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 = Intent(this, DebugInfoActivity::class.java)
-        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-        intent.putExtra(DebugInfoActivity.KEY_THROWABLE, e)
+        val intent = DebugInfoActivity.IntentBuilder(this)
+            .withCause(e)
+            .newTask()
+            .build()
         startActivity(intent)
 
         exitProcess(1)

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

@@ -1,12 +0,0 @@
-package at.bitfire.davdroid
-
-import android.content.ContentProviderClient
-import android.os.Build
-
-@Suppress("DEPRECATION")
-fun ContentProviderClient.closeCompat() {
-    if (Build.VERSION.SDK_INT >= 24)
-        close()
-    else
-        release()
-}

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

@@ -1,17 +1,14 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * 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()
 
-    const val DEFAULT_SYNC_INTERVAL = 4 * 3600L    // 4 hours
+    // gplay billing
+    const val BILLINGCLIENT_CONNECTION_MAX_RETRIES = 4
 
     /**
      * Context label for [org.apache.commons.lang3.exception.ContextedException].

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

@@ -1,374 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import android.accounts.Account
-import android.app.PendingIntent
-import android.content.ContentResolver
-import android.content.Intent
-import android.os.Binder
-import android.os.Bundle
-import androidx.core.app.NotificationCompat
-import androidx.core.app.NotificationManagerCompat
-import androidx.room.Transaction
-import at.bitfire.dav4jvm.DavResource
-import at.bitfire.dav4jvm.Response
-import at.bitfire.dav4jvm.UrlUtils
-import at.bitfire.dav4jvm.exception.HttpException
-import at.bitfire.dav4jvm.property.*
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.*
-import at.bitfire.davdroid.model.Collection
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import okhttp3.HttpUrl
-import okhttp3.OkHttpClient
-import java.lang.ref.WeakReference
-import java.util.*
-import java.util.logging.Level
-import kotlin.concurrent.thread
-
-class DavService: android.app.Service() {
-
-    companion object {
-        const val ACTION_REFRESH_COLLECTIONS = "refreshCollections"
-        const val EXTRA_DAV_SERVICE_ID = "davServiceID"
-
-        /** Initialize a forced synchronization. Expects intent data
-            to be an URI of this format:
-            contents://<authority>/<account.type>/<account name>
-         **/
-        const val ACTION_FORCE_SYNC = "forceSync"
-
-        val DAV_COLLECTION_PROPERTIES = arrayOf(
-                ResourceType.NAME,
-                CurrentUserPrivilegeSet.NAME,
-                DisplayName.NAME,
-                AddressbookDescription.NAME, SupportedAddressData.NAME,
-                CalendarDescription.NAME, CalendarColor.NAME, SupportedCalendarComponentSet.NAME,
-                Source.NAME
-        )
-
-    }
-
-    private val runningRefresh = HashSet<Long>()
-    private val refreshingStatusListeners = LinkedList<WeakReference<RefreshingStatusListener>>()
-
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        intent?.let {
-            val id = intent.getLongExtra(EXTRA_DAV_SERVICE_ID, -1)
-
-            when (intent.action) {
-                ACTION_REFRESH_COLLECTIONS ->
-                    if (runningRefresh.add(id)) {
-                        refreshingStatusListeners.forEach { listener ->
-                            listener.get()?.onDavRefreshStatusChanged(id, true)
-                        }
-                        thread { refreshCollections(id) }
-                    }
-
-                ACTION_FORCE_SYNC -> {
-                    val uri = intent.data!!
-                    val authority = uri.authority!!
-                    val account = Account(
-                            uri.pathSegments[1],
-                            uri.pathSegments[0]
-                    )
-                    forceSync(authority, account)
-                }
-            }
-        }
-
-        return START_NOT_STICKY
-    }
-
-
-    /* BOUND SERVICE PART
-       for communicating with the activities
-    */
-
-    interface RefreshingStatusListener {
-        fun onDavRefreshStatusChanged(id: Long, refreshing: Boolean)
-    }
-
-    private val binder = InfoBinder()
-
-    inner class InfoBinder: Binder() {
-        fun isRefreshing(id: Long) = runningRefresh.contains(id)
-
-        fun addRefreshingStatusListener(listener: RefreshingStatusListener, callImmediateIfRunning: Boolean) {
-            refreshingStatusListeners += WeakReference<RefreshingStatusListener>(listener)
-            if (callImmediateIfRunning)
-                runningRefresh.forEach { id -> listener.onDavRefreshStatusChanged(id, true) }
-        }
-
-        fun removeRefreshingStatusListener(listener: RefreshingStatusListener) {
-            val iter = refreshingStatusListeners.iterator()
-            while (iter.hasNext()) {
-                val item = iter.next().get()
-                if (listener == item)
-                    iter.remove()
-            }
-        }
-    }
-
-    override fun onBind(intent: Intent?) = binder
-
-
-
-    /* ACTION RUNNABLES
-       which actually do the work
-     */
-
-    private fun forceSync(authority: String, account: Account) {
-        Logger.log.info("Forcing $authority synchronization of $account")
-        val extras = Bundle(2)
-        extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)        // manual sync
-        extras.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)     // run immediately (don't queue)
-        ContentResolver.requestSync(account, authority, extras)
-    }
-
-    private fun refreshCollections(serviceId: Long) {
-        val db = AppDatabase.getInstance(this)
-        val homeSetDao = db.homeSetDao()
-        val collectionDao = db.collectionDao()
-
-        val service = db.serviceDao().get(serviceId) ?: throw IllegalArgumentException("Service not found")
-        val account = Account(service.accountName, getString(R.string.account_type))
-
-        val homeSets = homeSetDao.getByService(serviceId).associateBy { it.url }.toMutableMap()
-        val collections = collectionDao.getByService(serviceId).associateBy { it.url }.toMutableMap()
-
-        /**
-         * Checks if the given URL defines home sets and adds them to the home set list.
-         *
-         * @throws java.io.IOException
-         * @throws HttpException
-         * @throws at.bitfire.dav4jvm.exception.DavException
-         */
-        fun queryHomeSets(client: OkHttpClient, url: HttpUrl, recurse: Boolean = true) {
-            val related = mutableSetOf<HttpUrl>()
-
-            fun findRelated(root: HttpUrl, dav: Response) {
-                // refresh home sets: calendar-proxy-read/write-for
-                dav[CalendarProxyReadFor::class.java]?.let {
-                    for (href in it.hrefs) {
-                        Logger.log.fine("Principal is a read-only proxy for $href, checking for home sets")
-                        root.resolve(href)?.let { proxyReadFor ->
-                            related += proxyReadFor
-                        }
-                    }
-                }
-                dav[CalendarProxyWriteFor::class.java]?.let {
-                    for (href in it.hrefs) {
-                        Logger.log.fine("Principal is a read/write proxy for $href, checking for home sets")
-                        root.resolve(href)?.let { proxyWriteFor ->
-                            related += proxyWriteFor
-                        }
-                    }
-                }
-
-                // refresh home sets: direct group memberships
-                dav[GroupMembership::class.java]?.let {
-                    for (href in it.hrefs) {
-                        Logger.log.fine("Principal is member of group $href, checking for home sets")
-                        root.resolve(href)?.let { groupMembership ->
-                            related += groupMembership
-                        }
-                    }
-                }
-            }
-
-            val dav = DavResource(client, url)
-            when (service.type) {
-                Service.TYPE_CARDDAV ->
-                    try {
-                        dav.propfind(0, DisplayName.NAME, AddressbookHomeSet.NAME, GroupMembership.NAME) { response, _ ->
-                            response[AddressbookHomeSet::class.java]?.let { homeSet ->
-                                for (href in homeSet.hrefs)
-                                    dav.location.resolve(href)?.let {
-                                        val foundUrl = UrlUtils.withTrailingSlash(it)
-                                        homeSets[foundUrl] = HomeSet(0, service.id, foundUrl)
-                                    }
-                            }
-
-                            if (recurse)
-                                findRelated(dav.location, response)
-                        }
-                    } catch (e: HttpException) {
-                        if (e.code/100 == 4)
-                            Logger.log.log(Level.INFO, "Ignoring Client Error 4xx while looking for addressbook home sets", e)
-                        else
-                            throw e
-                    }
-                Service.TYPE_CALDAV -> {
-                    try {
-                        dav.propfind(0, DisplayName.NAME, CalendarHomeSet.NAME, CalendarProxyReadFor.NAME, CalendarProxyWriteFor.NAME, GroupMembership.NAME) { response, _ ->
-                            response[CalendarHomeSet::class.java]?.let { homeSet ->
-                                for (href in homeSet.hrefs)
-                                    dav.location.resolve(href)?.let {
-                                        val foundUrl = UrlUtils.withTrailingSlash(it)
-                                        homeSets[foundUrl] = HomeSet(0, service.id, foundUrl)
-                                    }
-                            }
-
-                            if (recurse)
-                                findRelated(dav.location, response)
-                        }
-                    } catch (e: HttpException) {
-                        if (e.code/100 == 4)
-                            Logger.log.log(Level.INFO, "Ignoring Client Error 4xx while looking for calendar home sets", e)
-                        else
-                            throw e
-                    }
-                }
-            }
-
-            for (resource in related)
-                queryHomeSets(client, resource, false)
-        }
-
-        @Transaction
-        fun saveHomesets() {
-            DaoTools(homeSetDao).syncAll(
-                    homeSetDao.getByService(serviceId),
-                    homeSets,
-                    { it.url })
-        }
-
-        @Transaction
-        fun saveCollections() {
-            DaoTools(collectionDao).syncAll(
-                    collectionDao.getByService(serviceId),
-                    collections, { it.url }) { new, old ->
-                new.forceReadOnly = old.forceReadOnly
-                new.sync = old.sync
-            }
-        }
-
-        fun saveResults() {
-            saveHomesets()
-            saveCollections()
-        }
-
-        try {
-            Logger.log.info("Refreshing ${service.type} collections of service #$service")
-
-            // cancel previous notification
-            NotificationManagerCompat.from(this)
-                    .cancel(service.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS)
-
-            // create authenticating OkHttpClient (credentials taken from account settings)
-            HttpClient.Builder(this, AccountSettings(this, account))
-                    .setForeground(true)
-                    .build().use { client ->
-                val httpClient = client.okHttpClient
-
-                // refresh home set list (from principal)
-                service.principal?.let { principalUrl ->
-                    Logger.log.fine("Querying principal $principalUrl for home sets")
-                    queryHomeSets(httpClient, principalUrl)
-                }
-
-                // now refresh homesets and their member collections
-                val itHomeSets = homeSets.iterator()
-                while (itHomeSets.hasNext()) {
-                    val homeSet = itHomeSets.next()
-                    Logger.log.fine("Listing home set ${homeSet.key}")
-
-                    try {
-                        DavResource(httpClient, homeSet.key).propfind(1, *DAV_COLLECTION_PROPERTIES) { response, relation ->
-                            if (!response.isSuccess())
-                                return@propfind
-
-                            if (relation == Response.HrefRelation.SELF) {
-                                // this response is about the homeset itself
-                                homeSet.value.displayName = response[DisplayName::class.java]?.displayName
-                                homeSet.value.privBind = response[CurrentUserPrivilegeSet::class.java]?.mayBind ?: true
-
-                            } else {
-                                val info = Collection.fromDavResponse(response) ?: return@propfind
-                                info.serviceId = serviceId
-                                info.confirmed = true
-                                Logger.log.log(Level.FINE, "Found collection", info)
-
-                                if ((service.type == Service.TYPE_CARDDAV && info.type == Collection.TYPE_ADDRESSBOOK) ||
-                                    (service.type == Service.TYPE_CALDAV && arrayOf(Collection.TYPE_CALENDAR, Collection.TYPE_WEBCAL).contains(info.type)))
-                                    collections[response.href] = info
-                            }
-                        }
-                    } catch(e: HttpException) {
-                        if (e.code in arrayOf(403, 404, 410))
-                            // delete home set only if it was not accessible (40x)
-                            itHomeSets.remove()
-                    }
-                }
-
-                // check/refresh unconfirmed collections
-                val itCollections = collections.entries.iterator()
-                while (itCollections.hasNext()) {
-                    val (url, info) = itCollections.next()
-                    if (!info.confirmed)
-                        try {
-                            DavResource(httpClient, url).propfind(0, *DAV_COLLECTION_PROPERTIES) { response, _ ->
-                                if (!response.isSuccess())
-                                    return@propfind
-
-                                val collection = Collection.fromDavResponse(response) ?: return@propfind
-                                collection.confirmed = true
-
-                                // remove unusable collections
-                                if ((service.type == Service.TYPE_CARDDAV && collection.type != Collection.TYPE_ADDRESSBOOK) ||
-                                    (service.type == Service.TYPE_CALDAV && !arrayOf(Collection.TYPE_CALENDAR, Collection.TYPE_WEBCAL).contains(collection.type)) ||
-                                    (collection.type == Collection.TYPE_WEBCAL && collection.source == null))
-                                    itCollections.remove()
-                            }
-                        } catch(e: HttpException) {
-                            if (e.code in arrayOf(403, 404, 410))
-                            // delete collection only if it was not accessible (40x)
-                                itCollections.remove()
-                            else
-                                throw e
-                        }
-                }
-            }
-
-            saveResults()
-
-        } catch(e: InvalidAccountException) {
-            Logger.log.log(Level.SEVERE, "Invalid account", e)
-        } catch(e: Exception) {
-            Logger.log.log(Level.SEVERE, "Couldn't refresh collection list", e)
-
-            val debugIntent = Intent(this, DebugInfoActivity::class.java)
-            debugIntent.putExtra(DebugInfoActivity.KEY_THROWABLE, e)
-            debugIntent.putExtra(DebugInfoActivity.KEY_ACCOUNT, account)
-
-            val notify = NotificationUtils.newBuilder(this, NotificationUtils.CHANNEL_GENERAL)
-                    .setSmallIcon(R.drawable.ic_sync_problem_notify)
-                    .setContentTitle(getString(R.string.dav_service_refresh_failed))
-                    .setContentText(getString(R.string.dav_service_refresh_couldnt_refresh))
-                    .setContentIntent(PendingIntent.getActivity(this, 0, debugIntent, PendingIntent.FLAG_UPDATE_CURRENT))
-                    .setSubText(account.name)
-                    .setCategory(NotificationCompat.CATEGORY_ERROR)
-                    .build()
-            NotificationManagerCompat.from(this)
-                    .notify(serviceId.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS, notify)
-        } finally {
-            runningRefresh.remove(serviceId)
-            refreshingStatusListeners.mapNotNull { it.get() }.forEach {
-                it.onDavRefreshStatusChanged(serviceId, false)
-            }
-        }
-
-    }
-
-}

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

@@ -1,107 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import android.accounts.Account
-import android.annotation.TargetApi
-import android.content.ContentResolver
-import android.content.Context
-import android.net.ConnectivityManager
-import android.os.Build
-import android.os.Bundle
-import android.provider.CalendarContract
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.ical4android.TaskProvider
-import okhttp3.HttpUrl
-import org.xbill.DNS.*
-import java.util.*
-
-/**
- * Some WebDAV and related network utility methods
- */
-object DavUtils {
-
-    fun ARGBtoCalDAVColor(colorWithAlpha: Int): String {
-        val alpha = (colorWithAlpha shr 24) and 0xFF
-        val color = colorWithAlpha and 0xFFFFFF
-        return String.format("#%06X%02X", color, alpha)
-    }
-
-
-    fun lastSegmentOfUrl(url: HttpUrl): String {
-        // the list returned by HttpUrl.pathSegments() is unmodifiable, so we have to create a copy
-        val segments = LinkedList<String>(url.pathSegments())
-        segments.reverse()
-
-        return segments.firstOrNull { it.isNotEmpty() } ?: "/"
-    }
-
-    fun prepareLookup(context: Context, lookup: Lookup) {
-        @TargetApi(Build.VERSION_CODES.O)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            /* Since Android 8, the system properties net.dns1, net.dns2, ... are not available anymore.
-               The current version of dnsjava relies on these properties to find the default name servers,
-               so we have to add the servers explicitly (fortunately, there's an Android API to
-               get the active DNS servers). */
-            val connectivity = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
-            val activeLink = connectivity.getLinkProperties(connectivity.activeNetwork)
-            if (activeLink != null) {
-                // get DNS servers of active network link and set them for dnsjava so that it can send SRV queries
-                val simpleResolvers = activeLink.dnsServers.map {
-                    Logger.log.fine("Using DNS server ${it.hostAddress}")
-                    val resolver = SimpleResolver()
-                    resolver.setAddress(it)
-                    resolver
-                }
-                val resolver = ExtendedResolver(simpleResolvers.toTypedArray())
-                lookup.setResolver(resolver)
-            } else
-                Logger.log.severe("Couldn't determine DNS servers, dnsjava queries (SRV/TXT records) won't work")
-        }
-    }
-
-    fun selectSRVRecord(records: Array<Record>?): SRVRecord? {
-        val srvRecords = records?.filterIsInstance(SRVRecord::class.java)
-        srvRecords?.let {
-            if (it.size > 1)
-                Logger.log.warning("Multiple SRV records not supported yet; using first one")
-            return it.firstOrNull()
-        }
-        return null
-    }
-
-    fun pathsFromTXTRecords(records: Array<Record>?): List<String> {
-        val paths = LinkedList<String>()
-        records?.filterIsInstance(TXTRecord::class.java)?.forEach { txt ->
-            @Suppress("UNCHECKED_CAST")
-            for (segment in txt.strings as List<String>)
-                if (segment.startsWith("path=")) {
-                    paths.add(segment.substring(5))
-                    break
-                }
-        }
-        return paths
-    }
-
-
-    fun requestSync(context: Context, account: Account) {
-        val authorities = arrayOf(
-                context.getString(R.string.address_books_authority),
-                CalendarContract.AUTHORITY,
-                TaskProvider.ProviderName.OpenTasks.authority
-        )
-
-        for (authority in authorities) {
-            val extras = Bundle(2)
-            extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)        // manual sync
-            extras.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)     // run immediately (don't queue)
-            ContentResolver.requestSync(account, authority, extras)
-        }
-    }
-}

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

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

@@ -1,252 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import android.content.Context
-import android.os.Build
-import android.security.KeyChain
-import at.bitfire.cert4android.CustomCertManager
-import at.bitfire.dav4jvm.BasicDigestAuthHandler
-import at.bitfire.dav4jvm.Constants
-import at.bitfire.dav4jvm.UrlUtils
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.Credentials
-import at.bitfire.davdroid.settings.AccountSettings
-import at.bitfire.davdroid.settings.Settings
-import okhttp3.*
-import okhttp3.internal.tls.OkHostnameVerifier
-import okhttp3.logging.HttpLoggingInterceptor
-import java.io.File
-import java.net.InetSocketAddress
-import java.net.Proxy
-import java.net.Socket
-import java.security.KeyStore
-import java.security.Principal
-import java.text.SimpleDateFormat
-import java.util.*
-import java.util.concurrent.TimeUnit
-import java.util.logging.Level
-import javax.net.ssl.*
-
-class HttpClient private constructor(
-        val okHttpClient: OkHttpClient,
-        private val certManager: CustomCertManager?
-): AutoCloseable {
-
-    companion object {
-        /** max. size of disk cache (10 MB) */
-        const val DISK_CACHE_MAX_SIZE: Long = 10*1024*1024
-
-        /** [OkHttpClient] singleton to build all clients from */
-        val sharedClient: OkHttpClient = OkHttpClient.Builder()
-                // set timeouts
-                .connectTimeout(15, TimeUnit.SECONDS)
-                .writeTimeout(30, TimeUnit.SECONDS)
-                .readTimeout(120, TimeUnit.SECONDS)
-
-                // don't allow redirects by default, because it would break PROPFIND handling
-                .followRedirects(false)
-
-                // add User-Agent to every request
-                .addNetworkInterceptor(UserAgentInterceptor)
-
-                .build()
-    }
-
-
-    override fun close() {
-        okHttpClient.cache()?.close()
-        certManager?.close()
-    }
-
-    class Builder(
-            val context: Context? = null,
-            accountSettings: AccountSettings? = null,
-            val logger: java.util.logging.Logger = Logger.log
-    ) {
-        private var certManager: CustomCertManager? = null
-        private var certificateAlias: String? = null
-        private var cache: Cache? = null
-
-        private val orig = sharedClient.newBuilder()
-
-        init {
-            // add cookie store for non-persistent cookies (some services like Horde use cookies for session tracking)
-            orig.cookieJar(MemoryCookieStore())
-
-            // add network logging, if requested
-            if (logger.isLoggable(Level.FINEST)) {
-                val loggingInterceptor = HttpLoggingInterceptor(HttpLoggingInterceptor.Logger {
-                    message -> logger.finest(message)
-                })
-                loggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
-                orig.addInterceptor(loggingInterceptor)
-            }
-
-            context?.let {
-                val settings = Settings.getInstance(context)
-
-                // custom proxy support
-                try {
-                    if (settings.getBoolean(Settings.OVERRIDE_PROXY) == true) {
-                        val address = InetSocketAddress(
-                                settings.getString(Settings.OVERRIDE_PROXY_HOST)
-                                        ?: Settings.OVERRIDE_PROXY_HOST_DEFAULT,
-                                settings.getInt(Settings.OVERRIDE_PROXY_PORT)
-                                        ?: Settings.OVERRIDE_PROXY_PORT_DEFAULT
-                        )
-
-                        val proxy = Proxy(Proxy.Type.HTTP, address)
-                        orig.proxy(proxy)
-                        Logger.log.log(Level.INFO, "Using proxy", proxy)
-                    }
-                } catch (e: Exception) {
-                    Logger.log.log(Level.SEVERE, "Can't set proxy, ignoring", e)
-                }
-
-                //if (BuildConfig.customCerts)
-                    customCertManager(CustomCertManager(context, true,
-                            !(settings.getBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES)
-                                    ?: Settings.DISTRUST_SYSTEM_CERTIFICATES_DEFAULT)))
-            }
-
-            // use account settings for authentication
-            accountSettings?.let {
-                addAuthentication(null, it.credentials())
-            }
-        }
-
-        constructor(context: Context, host: String?, credentials: Credentials): this(context) {
-            addAuthentication(host, credentials)
-        }
-
-        fun withDiskCache(): Builder {
-            val context = context ?: throw IllegalArgumentException("Context is required to find the cache directory")
-            for (dir in arrayOf(context.externalCacheDir, context.cacheDir).filterNotNull()) {
-                if (dir.exists() && dir.canWrite()) {
-                    val cacheDir = File(dir, "HttpClient")
-                    cacheDir.mkdir()
-                    Logger.log.fine("Using disk cache: $cacheDir")
-                    orig.cache(Cache(cacheDir, DISK_CACHE_MAX_SIZE))
-                    break
-                }
-            }
-            return this
-        }
-
-        fun followRedirects(follow: Boolean): Builder {
-            orig.followRedirects(follow)
-            return this
-        }
-
-        fun customCertManager(manager: CustomCertManager) {
-            certManager = manager
-        }
-        fun setForeground(foreground: Boolean): Builder {
-            certManager?.appInForeground = foreground
-            return this
-        }
-
-        fun addAuthentication(host: String?, credentials: Credentials): Builder {
-            when (credentials.type) {
-                Credentials.Type.UsernamePassword -> {
-                    val authHandler = BasicDigestAuthHandler(UrlUtils.hostToDomain(host), credentials.userName!!, credentials.password!!)
-                    orig    .addNetworkInterceptor(authHandler)
-                            .authenticator(authHandler)
-                }
-                Credentials.Type.ClientCertificate -> {
-                    certificateAlias = credentials.certificateAlias
-                }
-            }
-            return this
-        }
-
-        fun build(): HttpClient {
-            val trustManager = certManager ?: {
-                val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
-                factory.init(null as KeyStore?)
-                factory.trustManagers.first() as X509TrustManager
-            }()
-
-            val hostnameVerifier = certManager?.hostnameVerifier(OkHostnameVerifier.INSTANCE)
-                    ?: OkHostnameVerifier.INSTANCE
-
-            var keyManager: KeyManager? = null
-            certificateAlias?.let { alias ->
-                try {
-                    val context = requireNotNull(context)
-
-                    // get provider certificate and private key
-                    val certs = KeyChain.getCertificateChain(context, alias) ?: return@let
-                    val key = KeyChain.getPrivateKey(context, alias) ?: return@let
-                    logger.fine("Using provider certificate $alias for authentication (chain length: ${certs.size})")
-
-                    // create Android KeyStore (performs key operations without revealing secret data to DAVx5)
-                    val keyStore = KeyStore.getInstance("AndroidKeyStore")
-                    keyStore.load(null)
-
-                    // create KeyManager
-                    keyManager = object: X509ExtendedKeyManager() {
-                        override fun getServerAliases(p0: String?, p1: Array<out Principal>?): Array<String>? = null
-                        override fun chooseServerAlias(p0: String?, p1: Array<out Principal>?, p2: Socket?) = null
-
-                        override fun getClientAliases(p0: String?, p1: Array<out Principal>?) =
-                                arrayOf(alias)
-
-                        override fun chooseClientAlias(p0: Array<out String>?, p1: Array<out Principal>?, p2: Socket?) =
-                                alias
-
-                        override fun getCertificateChain(forAlias: String?) =
-                                certs.takeIf { forAlias == alias }
-
-                        override fun getPrivateKey(forAlias: String?) =
-                                key.takeIf { forAlias == alias }
-                    }
-
-                    // HTTP/2 doesn't support client certificates (yet)
-                    // see https://tools.ietf.org/html/draft-ietf-httpbis-http2-secondary-certs-04
-                    orig.protocols(listOf(Protocol.HTTP_1_1))
-                } catch (e: Exception) {
-                    logger.log(Level.SEVERE, "Couldn't set up provider certificate authentication", e)
-                }
-            }
-
-            val sslContext = SSLContext.getInstance("TLS")
-            sslContext.init(
-                    if (keyManager != null) arrayOf(keyManager) else null,
-                    arrayOf(trustManager),
-                    null)
-            orig.sslSocketFactory(sslContext.socketFactory, trustManager)
-            orig.hostnameVerifier(hostnameVerifier)
-
-            return HttpClient(orig.build(), certManager)
-        }
-
-    }
-
-
-    private object UserAgentInterceptor: Interceptor {
-        // use Locale.US because numbers may be encoded as non-ASCII characters in other locales
-        private val userAgentDateFormat = SimpleDateFormat("yyyy/MM/dd", Locale.US)
-        private val userAgentDate = userAgentDateFormat.format(Date(BuildConfig.buildTime))
-        private val userAgent = "${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ($userAgentDate; dav4jvm; " +
-                "okhttp/${Constants.okhttpVersion}) Android/${Build.VERSION.RELEASE}"
-
-        override fun intercept(chain: Interceptor.Chain): Response {
-            val locale = Locale.getDefault()
-            val request = chain.request().newBuilder()
-                    .header("User-Agent", userAgent)
-                    .header("Accept-Language", "${locale.language}-${locale.country}, ${locale.language};q=0.7, *;q=0.5")
-                    .build()
-            return chain.proceed(request)
-        }
-
-    }
-
-}

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

@@ -1,10 +1,6 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
 package at.bitfire.davdroid
 

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

@@ -1,58 +1,29 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
 package at.bitfire.davdroid
 
-import android.accounts.Account
 import android.content.BroadcastReceiver
-import android.content.ContentResolver
 import android.content.Context
 import android.content.Intent
-import android.os.Bundle
-import androidx.annotation.WorkerThread
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.AppDatabase
-import at.bitfire.davdroid.model.Service
-import at.bitfire.davdroid.resource.LocalTaskList
-import at.bitfire.ical4android.TaskProvider.ProviderName.OpenTasks
-import kotlin.concurrent.thread
+import android.content.IntentFilter
 
-class PackageChangedReceiver: BroadcastReceiver() {
+abstract class PackageChangedReceiver(
+        val context: Context
+): BroadcastReceiver(), AutoCloseable {
 
-    companion object {
-
-        @WorkerThread
-        fun updateTaskSync(context: Context) {
-            val tasksInstalled = LocalTaskList.tasksProviderAvailable(context)
-            Logger.log.info("Tasks provider available = $tasksInstalled")
-
-            // check all accounts and (de)activate OpenTasks if a CalDAV service is defined
-            val db = AppDatabase.getInstance(context)
-            db.serviceDao().getByType(Service.TYPE_CALDAV).forEach { service ->
-                val account = Account(service.accountName, context.getString(R.string.account_type))
-                if (tasksInstalled) {
-                    if (ContentResolver.getIsSyncable(account, OpenTasks.authority) <= 0) {
-                        ContentResolver.setIsSyncable(account, OpenTasks.authority, 1)
-                        ContentResolver.addPeriodicSync(account, OpenTasks.authority, Bundle(), Constants.DEFAULT_SYNC_INTERVAL)
-                    }
-                } else
-                    ContentResolver.setIsSyncable(account, OpenTasks.authority, 0)
-
-            }
+    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 onReceive(context: Context, intent: Intent) {
-        thread {
-            updateTaskSync(context)
-        }
+    override fun close() {
+        context.unregisterReceiver(this)
     }
 
-}
+}

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

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

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

@@ -0,0 +1,83 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid
+
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+
+class TextTable(
+        vararg val headers: String
+) {
+
+    companion object {
+
+        fun indent(str: String, pos: Int): String =
+                " ".repeat(pos) +
+                str.split('\n').joinToString("\n" + " ".repeat(pos))
+
+    }
+
+
+    private val lines = mutableListOf<Array<String>>()
+
+    fun addLine(vararg values: Any?) {
+        if (values.size != headers.size)
+            throw IllegalArgumentException("Table line must have ${headers.size} column(s)")
+        lines += values.map {
+            it?.toString() ?: "—"
+        }.toTypedArray()
+    }
+
+    override fun toString(): String {
+        val sb = StringBuilder()
+
+        val headerWidths = headers.map { it.length }
+        val colWidths = Array<Int>(headers.size) { colIdx ->
+            Collections.max(listOf(headerWidths[colIdx]) + lines.map { it[colIdx] }.map { it.length })
+        }
+
+        // first line
+        sb.append("\n┌")
+        for (colIdx in headers.indices)
+            sb  .append(StringUtils.repeat('─', colWidths[colIdx] + 2))
+                .append(if (colIdx == headers.size - 1) '┐' else '┬')
+        sb.append('\n')
+
+        // header
+        sb.append('│')
+        for (colIdx in headers.indices)
+            sb  .append(' ')
+                .append(StringUtils.rightPad(headers[colIdx], colWidths[colIdx] + 1))
+                .append('│')
+        sb.append('\n')
+
+        // separator between header and body
+        sb.append('├')
+        for (colIdx in headers.indices) {
+            sb  .append(StringUtils.repeat('─', colWidths[colIdx] + 2))
+                .append(if (colIdx == headers.size - 1) '┤' else '┼')
+        }
+        sb.append('\n')
+
+        // body
+        for (line in lines) {
+            for (colIdx in headers.indices)
+                sb  .append("│ ")
+                    .append(StringUtils.rightPad(line[colIdx], colWidths[colIdx] + 1))
+            sb.append("│\n")
+        }
+
+        // last line
+        sb.append("└")
+        for (colIdx in headers.indices) {
+            sb  .append("─".repeat(colWidths[colIdx] + 2))
+                .append(if (colIdx == headers.size - 1) '┘' else '┴')
+        }
+        sb.append("\n\n")
+
+        return sb.toString()
+    }
+
+}

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

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

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

@@ -1,27 +1,59 @@
-package at.bitfire.davdroid.model
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
 
 import androidx.room.*
 import at.bitfire.dav4jvm.Response
 import at.bitfire.dav4jvm.UrlUtils
 import at.bitfire.dav4jvm.property.*
-import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.util.DavUtils
 import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import org.apache.commons.lang3.StringUtils
 
 @Entity(tableName = "collection",
         foreignKeys = [
-            ForeignKey(entity = Service::class, parentColumns = arrayOf("id"), childColumns = arrayOf("serviceId"), onDelete = ForeignKey.CASCADE)
+            ForeignKey(entity = Service::class, parentColumns = arrayOf("id"), childColumns = arrayOf("serviceId"), onDelete = ForeignKey.CASCADE),
+            ForeignKey(entity = HomeSet::class, parentColumns = arrayOf("id"), childColumns = arrayOf("homeSetId"), onDelete = ForeignKey.SET_NULL),
+            ForeignKey(entity = Principal::class, parentColumns = arrayOf("id"), childColumns = arrayOf("ownerId"), onDelete = ForeignKey.SET_NULL)
         ],
         indices = [
-            Index("serviceId","type")
+            Index("serviceId","type"),
+            Index("homeSetId","type"),
+            Index("url")
         ]
 )
 data class Collection(
     @PrimaryKey(autoGenerate = true)
-    override var id: Long = 0,
+    var id: Long = 0,
 
+    /**
+     * Service, which this collection belongs to. Services are unique, so a [Collection] is uniquely
+     * identifiable via its [serviceId] and [url].
+     */
     var serviceId: Long = 0,
 
+    /**
+     * A home set this collection belongs to. Multiple homesets are not supported.
+     * If *null* the collection is considered homeless.
+     */
+    var homeSetId: Long? = null,
+
+    /**
+     * Principal who is owner of this collection.
+     */
+    var ownerId: Long? = null,
+
+    /**
+     * Type of service. CalDAV or CardDAV
+     */
     var type: String,
+
+    /**
+     * Address where this collection lives - with trailing slash
+     */
     var url: HttpUrl,
 
     var privWriteContent: Boolean = true,
@@ -52,7 +84,7 @@ data class Collection(
     /** whether this collection has been selected for synchronization */
     var sync: Boolean = false
 
-): IdEntity() {
+) {
 
     companion object {
 
@@ -83,11 +115,7 @@ data class Collection(
                 privUnbind = privilegeSet.mayUnbind
             }
 
-            var displayName: String? = null
-            dav[DisplayName::class.java]?.let {
-                if (!it.displayName.isNullOrEmpty())
-                    displayName = it.displayName
-            }
+            val displayName = StringUtils.trimToNull(dav[DisplayName::class.java]?.displayName)
 
             var description: String? = null
             var color: Int? = null
@@ -115,12 +143,14 @@ data class Collection(
                             supportsVJOURNAL = it.supportsJournal
                         }
                     } else { // Type.WEBCAL
-                        dav[Source::class.java]?.let { source = it.hrefs.firstOrNull()?.let { rawHref ->
-                            val href = rawHref
-                                    .replace("^webcal://".toRegex(), "http://")
-                                    .replace("^webcals://".toRegex(), "https://")
-                            HttpUrl.parse(href)
-                        } }
+                        dav[Source::class.java]?.let {
+                            source = it.hrefs.firstOrNull()?.let { rawHref ->
+                                val href = rawHref
+                                        .replace("^webcal://".toRegex(), "http://")
+                                        .replace("^webcals://".toRegex(), "https://")
+                                href.toHttpUrlOrNull()
+                            }
+                        }
                         supportsVEVENT = true
                     }
                 }
@@ -144,12 +174,6 @@ data class Collection(
 
     }
 
-
-    // non-persistent properties
-    @Ignore
-    var confirmed: Boolean = false
-
-
     // calculated properties
     fun title() = displayName ?: DavUtils.lastSegmentOfUrl(url)
     fun readOnly() = forceReadOnly || !privWriteContent

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

@@ -0,0 +1,106 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import androidx.lifecycle.LiveData
+import androidx.paging.PagingSource
+import androidx.room.*
+
+@Dao
+interface CollectionDao {
+
+    @Query("SELECT DISTINCT color FROM collection WHERE serviceId=:id")
+    fun colorsByServiceLive(id: Long): LiveData<List<Int>>
+
+    @Query("SELECT * FROM collection WHERE id=:id")
+    fun get(id: Long): Collection?
+
+    @Query("SELECT * FROM collection WHERE id=:id")
+    fun getLive(id: Long): LiveData<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId")
+    fun getByService(serviceId: Long): List<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND homeSetId IS :homeSetId")
+    fun getByServiceAndHomeset(serviceId: Long, homeSetId: Long?): List<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type=:type ORDER BY displayName, url")
+    fun getByServiceAndType(serviceId: Long, type: String): List<Collection>
+
+    /**
+     * Returns collections which
+     *   - support VEVENT and/or VTODO (= supported calendar collections), or
+     *   - have supportsVEVENT = supportsVTODO = null (= address books)
+     */
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type=:type " +
+            "AND (supportsVTODO OR supportsVEVENT OR supportsVJOURNAL OR (supportsVEVENT IS NULL AND supportsVTODO IS NULL AND supportsVJOURNAL IS NULL)) ORDER BY displayName, URL")
+    fun pageByServiceAndType(serviceId: Long, type: String): PagingSource<Int, Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND sync")
+    fun getByServiceAndSync(serviceId: Long): List<Collection>
+
+    @Query("SELECT collection.* FROM collection, homeset WHERE collection.serviceId=:serviceId AND type=:type AND homeSetId=homeset.id AND homeset.personal ORDER BY collection.displayName, collection.url")
+    fun pagePersonalByServiceAndType(serviceId: Long, type: String): PagingSource<Int, Collection>
+
+    @Deprecated("Use getByServiceAndUrl instead")
+    @Query("SELECT * FROM collection WHERE url=:url")
+    fun getByUrl(url: String): Collection?
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND url=:url")
+    fun getByServiceAndUrl(serviceId: Long, url: String): Collection?
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type='${Collection.TYPE_CALENDAR}' AND supportsVEVENT AND sync ORDER BY displayName, url")
+    fun getSyncCalendars(serviceId: Long): List<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type='${Collection.TYPE_CALENDAR}' AND (supportsVTODO OR supportsVJOURNAL) AND sync ORDER BY displayName, url")
+    fun getSyncJtxCollections(serviceId: Long): List<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type='${Collection.TYPE_CALENDAR}' AND supportsVTODO AND sync ORDER BY displayName, url")
+    fun getSyncTaskLists(serviceId: Long): List<Collection>
+
+    @Insert(onConflict = OnConflictStrategy.IGNORE)
+    fun insert(collection: Collection): Long
+
+    @Update
+    fun update(collection: Collection)
+
+    /**
+     * 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!
+     *
+     * @param collection Collection to be inserted or updated
+     * @return ID of the row, that has been inserted or updated. -1 If the insert fails due to other reasons.
+     */
+    @Transaction
+    fun insertOrUpdateByUrl(collection: Collection): Long = getByServiceAndUrl(
+        collection.serviceId,
+        collection.url.toString()
+    )?.let { localCollection ->
+        update(collection.copy(id = localCollection.id))
+        localCollection.id
+    } ?: insert(collection)
+
+    /**
+     * Inserts or updates the collection. On update it will not update flag values ([Collection.sync],
+     * [Collection.forceReadOnly]), but use the values of the already existing collection.
+     *
+     * @param newCollection Collection to be inserted or updated
+     */
+    fun insertOrUpdateByUrlAndRememberFlags(newCollection: Collection) {
+        // remember locally set flags
+        getByServiceAndUrl(newCollection.serviceId, newCollection.url.toString())?.let { oldCollection ->
+            newCollection.sync = oldCollection.sync
+            newCollection.forceReadOnly = oldCollection.forceReadOnly
+        }
+
+        // commit to database
+        insertOrUpdateByUrl(newCollection)
+    }
+
+    @Delete
+    fun delete(collection: Collection)
+
+}

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

@@ -0,0 +1,31 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import androidx.room.TypeConverter
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+
+class Converters {
+
+    @TypeConverter
+    fun httpUrlToString(url: HttpUrl?) =
+            url?.toString()
+
+    @TypeConverter
+    fun mediaTypeToString(mediaType: MediaType?) =
+        mediaType?.toString()
+
+    @TypeConverter
+    fun stringToHttpUrl(url: String?): HttpUrl? =
+        url?.toHttpUrlOrNull()
+
+    @TypeConverter
+    fun stringToMediaType(mimeType: String?): MediaType? =
+        mimeType?.toMediaTypeOrNull()
+
+}

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

@@ -0,0 +1,35 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import net.openid.appauth.AuthState
+
+data class Credentials(
+    val userName: String? = null,
+    val password: String? = null,
+
+    val certificateAlias: String? = null,
+
+    val authState: AuthState? = null
+) {
+
+    override fun toString(): String {
+        val s = mutableListOf<String>()
+
+        if (userName != null)
+            s += "userName=$userName"
+        if (password != null)
+            s += "password=*****"
+
+        if (certificateAlias != null)
+            s += "certificateAlias=$certificateAlias"
+
+        if (authState != null)
+            s += "authState=${authState.jsonSerializeString()}"
+
+        return "Credentials(" + s.joinToString(", ") + ")"
+    }
+
+}

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

@@ -1,4 +1,8 @@
-package at.bitfire.davdroid.model
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
 
 import androidx.room.Entity
 import androidx.room.ForeignKey
@@ -8,7 +12,7 @@ import okhttp3.HttpUrl
 
 @Entity(tableName = "homeset",
         foreignKeys = [
-            ForeignKey(entity = Service::class, parentColumns = arrayOf("id"), childColumns = arrayOf("serviceId"), onDelete = ForeignKey.CASCADE)
+            ForeignKey(entity = Service::class, parentColumns = ["id"], childColumns = ["serviceId"], onDelete = ForeignKey.CASCADE)
         ],
         indices = [
             // index by service; no duplicate URLs per service
@@ -17,12 +21,18 @@ import okhttp3.HttpUrl
 )
 data class HomeSet(
     @PrimaryKey(autoGenerate = true)
-    override var id: Long,
+    var id: Long,
 
     var serviceId: Long,
+
+    /**
+     * Whether this homeset belongs to the [Service.principal] given by [serviceId].
+     */
+    var personal: Boolean,
+
     var url: HttpUrl,
 
     var privBind: Boolean = true,
 
     var displayName: String? = null
-): IdEntity()
+)

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

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

@@ -0,0 +1,69 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.UrlUtils
+import at.bitfire.dav4jvm.property.DisplayName
+import at.bitfire.dav4jvm.property.ResourceType
+import okhttp3.HttpUrl
+import org.apache.commons.lang3.StringUtils
+
+@Entity(tableName = "principal",
+    foreignKeys = [
+        ForeignKey(entity = Service::class, parentColumns = arrayOf("id"), childColumns = arrayOf("serviceId"), onDelete = ForeignKey.CASCADE)
+    ],
+    indices = [
+        // index by service, urls are unique
+        Index("serviceId", "url", unique = true)
+    ]
+)
+data class Principal(
+    @PrimaryKey(autoGenerate = true)
+    var id: Long = 0,
+    var serviceId: Long,
+    /** URL of the principal, always without trailing slash */
+    var url: HttpUrl,
+    var displayName: String? = null
+) {
+
+    companion object {
+
+        /**
+         * Generates a principal entity from a WebDAV response.
+         * @param dav WebDAV response (make sure that you have queried `DAV:resource-type` and `DAV:display-name`)
+         * @return generated principal data object (with `id`=0), `null` if the response doesn't represent a principal
+         */
+        fun fromDavResponse(serviceId: Long, dav: Response): Principal? {
+            // Check if response is a principal
+            val resourceType = dav[ResourceType::class.java] ?: return null
+            if (!resourceType.types.contains(ResourceType.PRINCIPAL))
+                return null
+
+            // Try getting the display name of the principal
+            val displayName: String? = StringUtils.trimToNull(
+                dav[DisplayName::class.java]?.displayName
+            )
+
+            // Create and return principal - even without it's display name
+            return Principal(
+                serviceId = serviceId,
+                url = UrlUtils.omitTrailingSlash(dav.href),
+                displayName = displayName
+            )
+        }
+
+        fun fromServiceAndUrl(service: Service, url: HttpUrl) = Principal(
+            serviceId = service.id,
+            url = UrlUtils.omitTrailingSlash(url)
+        )
+
+    }
+
+}

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

@@ -0,0 +1,55 @@
+/***************************************************************************************************
+ * 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.*
+import okhttp3.HttpUrl
+
+@Dao
+interface PrincipalDao {
+
+    @Query("SELECT * FROM principal WHERE id=:id")
+    fun get(id: Long): Principal
+
+    @Query("SELECT * FROM principal WHERE id=:id")
+    fun getLive(id: Long): LiveData<Principal>
+
+    @Query("SELECT * FROM principal WHERE serviceId=:serviceId")
+    fun getByService(serviceId: Long): List<Principal>
+
+    @Query("SELECT * FROM principal WHERE serviceId=:serviceId AND url=:url")
+    fun getByUrl(serviceId: Long, url: HttpUrl): Principal?
+
+    /**
+     * Gets all principals who do not own any collections
+     */
+    @Query("SELECT * FROM principal WHERE principal.id NOT IN (SELECT ownerId FROM collection WHERE ownerId IS NOT NULL)")
+    fun getAllWithoutCollections(): List<Principal>
+
+    @Insert
+    fun insert(principal: Principal): Long
+
+    @Update
+    fun update(principal: Principal)
+
+    @Delete
+    fun delete(principal: Principal)
+
+    /**
+     * Inserts, updates or just gets existing principal if its display name has not
+     * changed (will not update/overwrite with null values).
+     *
+     * @param principal Principal to be inserted or updated
+     * @return ID of the newly inserted or already existing principal
+     */
+    fun insertOrUpdate(serviceId: Long, principal: Principal): Long =
+        getByUrl(serviceId, principal.url)?.let { oldPrincipal ->
+            if (principal.displayName != oldPrincipal.displayName)
+                update(principal.copy(id = oldPrincipal.id))
+            return oldPrincipal.id
+        } ?: insert(principal)
+
+}

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

@@ -1,10 +1,19 @@
-package at.bitfire.davdroid.model
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
 
 import androidx.room.Entity
 import androidx.room.Index
 import androidx.room.PrimaryKey
 import okhttp3.HttpUrl
 
+/**
+ * A service entity.
+ *
+ * Services represent accounts and are unique. They are of type CardDAV or CalDAV and may have an associated principal.
+ */
 @Entity(tableName = "service",
         indices = [
             // only one service per type and account

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

@@ -1,5 +1,11 @@
-package at.bitfire.davdroid.model
+/***************************************************************************************************
+ * 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.ColumnInfo
 import androidx.room.Dao
 import androidx.room.Insert
 import androidx.room.OnConflictStrategy
@@ -12,14 +18,14 @@ interface ServiceDao {
     fun getByAccountAndType(accountName: String, type: String): Service?
 
     @Query("SELECT id FROM service WHERE accountName=:accountName AND type=:type")
-    fun getIdByAccountAndType(accountName: String, type: String): Long?
+    fun getIdByAccountAndType(accountName: String, type: String): LiveData<Long>
+
+    @Query("SELECT type, id FROM service WHERE accountName=:accountName")
+    fun getServiceTypeAndIdsByAccount(accountName: String): LiveData<List<ServiceTypeAndId>>
 
     @Query("SELECT * FROM service WHERE id=:id")
     fun get(id: Long): Service?
 
-    @Query("SELECT * FROM service WHERE type=:type")
-    fun getByType(type: String): List<Service>
-
     @Insert(onConflict = OnConflictStrategy.REPLACE)
     fun insertOrReplace(service: Service): Long
 
@@ -32,4 +38,9 @@ interface ServiceDao {
     @Query("UPDATE service SET accountName=:newName WHERE accountName=:oldName")
     fun renameAccount(oldName: String, newName: String)
 
-}
+}
+
+data class ServiceTypeAndId(
+    @ColumnInfo(name = "type") val type: String,
+    @ColumnInfo(name = "id") val id: Long
+)

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

@@ -1,12 +1,8 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
 
-package at.bitfire.davdroid.model
+package at.bitfire.davdroid.db
 
 import at.bitfire.dav4jvm.property.SyncToken
 import org.json.JSONException

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

@@ -0,0 +1,28 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "syncstats",
+    foreignKeys = [
+        ForeignKey(childColumns = arrayOf("collectionId"), entity = Collection::class, parentColumns = arrayOf("id"), onDelete = ForeignKey.CASCADE)
+    ],
+    indices = [
+        Index("collectionId", "authority", unique = true),
+    ]
+)
+data class SyncStats(
+    @PrimaryKey(autoGenerate = true)
+    val id: Long,
+
+    val collectionId: Long,
+    val authority: String,
+
+    var lastSync: Long
+)

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

@@ -0,0 +1,21 @@
+/***************************************************************************************************
+ * 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.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+
+@Dao
+interface SyncStatsDao {
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertOrReplace(syncStats: SyncStats)
+
+    @Query("SELECT * FROM syncstats WHERE collectionId=:id")
+    fun getLiveByCollectionId(id: Long): LiveData<List<SyncStats>>
+}

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

@@ -0,0 +1,119 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import android.annotation.SuppressLint
+import android.os.Bundle
+import android.provider.DocumentsContract.Document
+import android.webkit.MimeTypeMap
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import at.bitfire.davdroid.util.DavUtils.MEDIA_TYPE_OCTET_STREAM
+import okhttp3.HttpUrl
+import okhttp3.MediaType
+import okhttp3.MediaType.Companion.toMediaTypeOrNull
+import java.io.FileNotFoundException
+
+@Entity(
+    tableName = "webdav_document",
+    foreignKeys = [
+        ForeignKey(entity = WebDavMount::class, parentColumns = ["id"], childColumns = ["mountId"], onDelete = ForeignKey.CASCADE),
+        ForeignKey(entity = WebDavDocument::class, parentColumns = ["id"], childColumns = ["parentId"], onDelete = ForeignKey.CASCADE)
+    ],
+    indices = [
+        Index("mountId", "parentId", "name", unique = true)
+    ]
+)
+data class WebDavDocument(
+
+    @PrimaryKey(autoGenerate = true)
+    var id: Long = 0,
+
+    /** refers to the [WebDavMount] the document belongs to */
+    val mountId: Long,
+
+    /** refers to parent document (*null* when this document is a root document) */
+    var parentId: Long?,
+
+    /** file name (without any slashes) */
+    var name: String,
+    var isDirectory: Boolean = false,
+
+    var displayName: String? = null,
+    var mimeType: MediaType? = null,
+    var eTag: String? = null,
+    var lastModified: Long? = null,
+    var size: Long? = null,
+
+    var mayBind: Boolean? = null,
+    var mayUnbind: Boolean? = null,
+    var mayWriteContent: Boolean? = null,
+
+    var quotaAvailable: Long? = null,
+    var quotaUsed: Long? = null
+
+) {
+
+    @SuppressLint("InlinedApi")
+    fun toBundle(parent: WebDavDocument?): Bundle {
+        if (parent?.isDirectory == false)
+            throw IllegalArgumentException("Parent must be a directory")
+
+        val bundle = Bundle()
+        bundle.putString(Document.COLUMN_DOCUMENT_ID, id.toString())
+        bundle.putString(Document.COLUMN_DISPLAY_NAME, name)
+
+        displayName?.let { bundle.putString(Document.COLUMN_SUMMARY, it) }
+        size?.let { bundle.putLong(Document.COLUMN_SIZE, it) }
+        lastModified?.let { bundle.putLong(Document.COLUMN_LAST_MODIFIED, it) }
+
+        // see RFC 3744 appendix B for required privileges for the various operations
+        var flags = Document.FLAG_SUPPORTS_COPY
+        if (isDirectory) {
+            bundle.putString(Document.COLUMN_MIME_TYPE, Document.MIME_TYPE_DIR)
+            if (mayBind != false)
+                flags += Document.FLAG_DIR_SUPPORTS_CREATE
+        } else {
+            val reportedMimeType = mimeType ?:
+                MimeTypeMap.getSingleton().getMimeTypeFromExtension(
+                    MimeTypeMap.getFileExtensionFromUrl(name)
+                )?.toMediaTypeOrNull() ?:
+                MEDIA_TYPE_OCTET_STREAM
+
+            bundle.putString(Document.COLUMN_MIME_TYPE, reportedMimeType.toString())
+            if (mimeType?.type == "image")
+                flags += Document.FLAG_SUPPORTS_THUMBNAIL
+            if (mayWriteContent != false)
+                flags += Document.FLAG_SUPPORTS_WRITE
+        }
+        if (parent?.mayUnbind != false)
+            flags += Document.FLAG_SUPPORTS_DELETE or
+                    Document.FLAG_SUPPORTS_MOVE or
+                    Document.FLAG_SUPPORTS_RENAME
+        bundle.putInt(Document.COLUMN_FLAGS, flags)
+
+        return bundle
+    }
+
+    fun toHttpUrl(db: AppDatabase): HttpUrl {
+        val mount = db.webDavMountDao().getById(mountId)
+
+        val segments = mutableListOf(name)
+        var parentIter = parentId
+        while (parentIter != null) {
+            val parent = db.webDavDocumentDao().get(parentIter) ?: throw FileNotFoundException()
+            segments += parent.name
+            parentIter = parent.parentId
+        }
+
+        val builder = mount.url.newBuilder()
+        for (segment in segments.reversed())
+            builder.addPathSegment(segment)
+        return builder.build()
+    }
+
+}

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

@@ -0,0 +1,78 @@
+/***************************************************************************************************
+ * 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 WebDavDocumentDao {
+
+    @Query("SELECT * FROM webdav_document WHERE id=:id")
+    fun get(id: Long): WebDavDocument?
+
+    @Query("SELECT * FROM webdav_document WHERE mountId=:mountId AND (parentId=:parentId OR (parentId IS NULL AND :parentId IS NULL)) AND name=:name")
+    fun getByParentAndName(mountId: Long, parentId: Long?, name: String): WebDavDocument?
+
+    @Query("SELECT * FROM webdav_document WHERE parentId=:parentId")
+    fun getChildren(parentId: Long): List<WebDavDocument>
+
+    @Query("SELECT * FROM webdav_document WHERE parentId IS NULL")
+    fun getRootsLive(): LiveData<List<WebDavDocument>>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertOrReplace(document: WebDavDocument): Long
+
+    @Query("DELETE FROM webdav_document WHERE parentId=:parentId")
+    fun removeChildren(parentId: Long)
+
+    @Insert
+    fun insert(document: WebDavDocument): Long
+
+    @Update
+    fun update(document: WebDavDocument)
+    
+    @Delete
+    fun delete(document: WebDavDocument)
+
+
+    // complex operations
+
+    /**
+     * 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 insertOrUpdate(document: WebDavDocument): Long {
+        val parentId = document.parentId
+            ?: return insert(document)
+        val existingDocument = getByParentAndName(document.mountId, parentId, document.name)
+            ?: return insert(document)
+        update(document.copy(id = existingDocument.id))
+        return existingDocument.id
+    }
+
+    @Transaction
+    fun getOrCreateRoot(mount: WebDavMount): WebDavDocument {
+        getByParentAndName(mount.id, null, "")?.let { existing ->
+            return existing
+        }
+
+        val newDoc = WebDavDocument(
+            mountId = mount.id,
+            parentId = null,
+            name = "",
+            isDirectory = true,
+            displayName = mount.name
+        )
+        val id = insertOrReplace(newDoc)
+        newDoc.id = id
+        return newDoc
+    }
+
+}

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

@@ -0,0 +1,24 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.db
+
+import androidx.room.Entity
+import androidx.room.PrimaryKey
+import okhttp3.HttpUrl
+
+@Entity(tableName = "webdav_mount")
+data class WebDavMount(
+    @PrimaryKey(autoGenerate = true)
+    var id: Long = 0,
+
+    /** display name of the WebDAV mount */
+    var name: String,
+
+    /** URL of the WebDAV service, including trailing slash */
+    var url: HttpUrl
+
+    // credentials are stored using CredentialsStore
+
+)

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

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