Updated name, package and color

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

.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/ISSUE_TEMPLATE/qualified-bug.yml

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

.github/ISSUE_TEMPLATE/qualified-feature.yml

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

.github/pull_request_template.md

@@ -0,0 +1,38 @@
+
+Please delete this paragraph and other repeating text (like the examples) after reading and before submitting the PR.
+
+The PR should be in _Draft_ state during development. As soon as it's finished, it should be marked as _Ready for review_ and a reviewer should be chosen.
+
+See also: [Writing A Great Pull Request Description](https://www.pullrequest.com/blog/writing-a-great-pull-request-description/)
+
+
+### Purpose
+
+What this PR is intended to do and why this is desirable.
+
+Example: 
+
+> Adds support for AAA in BBB, as requested by several people in issue #XX.
+
+
+### Short description
+
+A short description of the chosen approach to achieve the purpose.
+
+Example:
+
+> - Added authentication option _Some authentication_ to _some module_.
+> - Added support for _Some authentication_ to _some content provider_.
+> - Added UI support for _Some authentication_ in account settings.
+
+Related information (links to Android docs and other resources that help to understand/review
+the changes) can also be put here.
+
+
+### Checklist
+
+- [ ] The PR has a proper title, description and label.
+- [ ] I have [self-reviewed the PR](https://patrickdinh.medium.com/review-your-own-pull-requests-5634cad10b7a).
+- [ ] I have added documentation to complex functions and functions that can be used by other modules.
+- [ ] I have added reasonable tests or consciously decided to not add tests.
+

.github/release.yml

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

.github/workflows/codeql.yml

@@ -0,0 +1,58 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main-ose ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main-ose ]
+  schedule:
+    - cron: '22 10 * * 1'
+concurrency:
+  group: codeql-${{ 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@v4
+    - uses: actions/setup-java@v4
+      with:
+        distribution: temurin
+        java-version: 21
+    - uses: gradle/actions/setup-gradle@v3
+      with:
+        cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+        cache-read-only: true         # gradle user home cache is generated by test jobs
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v3
+      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 --build-cache --configuration-cache --configuration-cache-problems=warn --no-daemon app:assembleOseDebug
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v3
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/dependent-issues.yml

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

.github/workflows/release.yml

@@ -0,0 +1,48 @@
+name: Create release
+on:
+  push:
+    tags:
+      - v*
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  prerelease: ${{ contains(github.ref_name, '-alpha') || contains(github.ref_name, '-beta') || contains(github.ref_name, '-rc') }}
+
+jobs:
+  build:
+    name: Create release
+    permissions:
+      contents: write
+      discussions: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v3
+
+      - name: Prepare keystore
+        run: echo ${{ secrets.android_keystore_base64 }} | base64 -d >$GITHUB_WORKSPACE/keystore.jks
+
+      - name: Build signed package
+        # Make sure that caches are disabled to generate reproducible release builds
+        run: ./gradlew --no-build-cache --no-configuration-cache --no-daemon app:assembleRelease
+        env:
+          ANDROID_KEYSTORE: ${{ github.workspace }}/keystore.jks
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.android_keystore_password }}
+          ANDROID_KEY_ALIAS: ${{ secrets.android_key_alias }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.android_key_password }}
+
+      - name: Create Github release
+        uses: softprops/action-gh-release@v2
+        with:
+          prerelease: ${{ env.prerelease }}
+          files: app/build/outputs/apk/ose/release/*.apk
+          fail_on_unmatched_files: true
+          generate_release_notes: true
+          discussion_category_name: Announcements

.github/workflows/test-dev.yml

@@ -0,0 +1,81 @@
+name: Development tests
+on:
+  push:
+    branches:
+      - '*'
+
+concurrency:
+  group: test-dev-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  compile:
+    name: Compile for build cache
+    if: ${{ github.ref == 'refs/heads/main-ose' }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+
+      # See https://community.gradle.org/github-actions/docs/setup-gradle/ for more information
+      - uses: gradle/actions/setup-gradle@v3            # creates build cache when on main branch
+        with:
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          dependency-graph: generate-and-submit         # submit Github Dependency Graph info
+
+      - run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:compileOseDebugSource
+
+  test:
+    needs: compile
+    if: ${{ always() }}     # even if compile didn't run (because not on main branch)
+    name: Lint and unit tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v3
+        with:
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          cache-read-only: true
+
+      - name: Run lint
+        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:lintOseDebug
+      - name: Run unit tests
+        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:testOseDebugUnitTest
+
+  test_on_emulator:
+    needs: compile
+    if: ${{ always() }}     # even if compile didn't run (because not on main branch)
+    name: Instrumented tests
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-java@v4
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v3
+        with:
+          cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+          cache-read-only: true
+
+      - name: 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
+        uses: actions/cache@v4
+        with:
+          path: ~/.config/.android/avd
+          key: avd-${{ hashFiles('app/build.gradle.kts') }}   # gradle-managed devices are defined there
+
+      - name: Run device tests
+        run: ./gradlew --build-cache --configuration-cache --configuration-cache-problems=warn app:virtualCheck

.gitignore

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

.gitmodules

@@ -1,12 +0,0 @@
-[submodule "dav4android"]
-	path = dav4android
-	url = ../dav4android.git
-[submodule "ical4android"]
-	path = ical4android
-	url = ../ical4android.git
-[submodule "vcard4android"]
-	path = vcard4android
-	url = ../vcard4android.git
-[submodule "cert4android"]
-	path = cert4android
-	url = ../cert4android.git

.tx/config

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

AUTHORS

@@ -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

@@ -0,0 +1,117 @@
+
+**Thank you for your interest in contributing to DAVx⁵!**
+
+
+# Licensing
+
+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.
+
+
+# Copyright
+
+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.
+
+
+# Style guide
+
+Please adhere to the [Kotlin style guide](https://developer.android.com/kotlin/style-guide) and
+the following hints to make the source code uniform.
+
+**Have a look at similar files and copy their style if you're not certain.**
+
+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

@@ -0,0 +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⁵, including a list of services it has been tested with.
+
+DAVx⁵ is licensed under the [GPLv3 License](LICENSE).
+
+News and updates: 
+
+* [@davx5app@fosstodon.org](https://fosstodon.org/@davx5app) on Mastodon
+
+**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://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
+==========================
+
+The most important libraries which are used by DAVx⁵ (alphabetically):
+
+* [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/README

@@ -1,9 +0,0 @@
-
-flavor        directory
-
-gplay         main + davdroid + gplay
-icloud        main + icloud
-managed       main + managed
-soldupe       main + soldupe
-standard      main + davdroid
-

app/build.gradle

@@ -1,167 +0,0 @@
-/*
- * 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
- */
-
-apply plugin: 'com.android.application'
-apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
-apply plugin: 'org.jetbrains.dokka-android'
-
-ext {
-    baseVersionName = '2.0'
-}
-
-android {
-    compileSdkVersion 27
-    buildToolsVersion '28.0.1'
-
-    defaultConfig {
-        applicationId "at.bitfire.davdroid"
-        resValue "string", "packageID", applicationId
-
-        versionCode 241
-        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
-
-        minSdkVersion 19        // Android 4.4
-        targetSdkVersion 27     // Android 8.1
-
-        buildConfigField "boolean", "customCerts", "false"
-        buildConfigField "boolean", "customCertsUI", "true"
-
-        // when using this, make sure that notification icons are real bitmaps
-        vectorDrawables.useSupportLibrary = true
-    }
-
-    flavorDimensions "type"
-    productFlavors {
-        standard {
-            dimension "type"
-            versionName baseVersionName
-
-            buildConfigField "boolean", "customCerts", "true"
-        }
-        managed {
-            dimension "type"
-            versionName "$baseVersionName-mgd"
-
-            applicationId "com.davdroid.managed"
-            resValue "string", "packageID", applicationId
-
-            buildConfigField "boolean", "customCerts", "true"
-            buildConfigField "boolean", "customCertsUI", "false"
-            minSdkVersion 21
-        }
-
-        gplay {
-            dimension "type"
-            versionName "$baseVersionName-gplay"
-
-            buildConfigField "boolean", "customCerts", "true"
-        }
-        icloud {
-            dimension "type"
-            versionName "$baseVersionName-icloud"
-
-            applicationId "at.bitfire.cloudsync"
-            resValue "string", "packageID", applicationId
-        }
-        soldupe {
-            dimension "type"
-            versionName "$baseVersionName-soldupe"
-
-            applicationId "com.soldupe.cloudsync"
-            resValue "string", "packageID", applicationId
-            minSdkVersion 21
-        }
-    }
-
-    sourceSets {
-        standard.java.srcDirs = [ "src/davdroid/java" ]
-        standard.res.srcDirs = [ "src/davdroid/res" ]
-        gplay.java.srcDirs = [ "src/gplay/java", "src/davdroid/java" ]
-        gplay.res.srcDirs = [ "src/gplay/res", "src/davdroid/res" ]
-        androidTest.java.srcDirs = [ "src/androidTest/java", "src/espressoTest/java" ]
-    }
-
-    signingConfigs {
-        bitfire {
-            storeFile file("${System.env.HOME}/Entwicklung/GooglePlay/bitfire.jks")
-            storePassword '***REMOVED***'
-            keyAlias 'bitfire'
-            keyPassword '***REMOVED***'
-        }
-        soldupe {
-            storeFile file("${System.env.HOME}/Entwicklung/GooglePlay/soldupe.jks")
-            storePassword 'hei8eePh'
-            keyAlias 'soldupe'
-            keyPassword 'ocaip6oZ'
-        }
-    }
-
-    buildTypes {
-        debug {
-            minifyEnabled false
-        }
-        release {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
-
-            signingConfig signingConfigs.bitfire
-            productFlavors.soldupe.signingConfig signingConfigs.soldupe
-        }
-    }
-
-    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 "OnClick"     // doesn't recognize Kotlin onClick methods
-        disable 'RtlEnabled'
-        disable 'RtlHardcoded'
-        disable 'Typos'
-    }
-    packagingOptions {
-        exclude 'META-INF/DEPENDENCIES'
-        exclude 'META-INF/LICENSE'
-    }
-
-    defaultConfig {
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
-    }
-}
-
-dependencies {
-    implementation project(':cert4android')
-    implementation project(':dav4android')
-    implementation project(':ical4android')
-    implementation project(':vcard4android')
-
-    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-
-    implementation 'com.android.support:appcompat-v7:27.1.1'
-    implementation 'com.android.support:cardview-v7:27.1.1'
-    implementation 'com.android.support:design:27.1.1'
-    implementation 'com.android.support:preference-v14:27.1.1'
-
-    implementation 'com.github.yukuku:ambilwarna:2.0.1'
-    implementation 'com.mikepenz:aboutlibraries:6.0.9'
-
-    implementation 'com.squareup.okhttp3:logging-interceptor:3.11.0'
-    implementation 'commons-io:commons-io:2.6'
-    implementation 'dnsjava:dnsjava:2.1.8'
-    implementation 'org.apache.commons:commons-lang3:3.7'
-    implementation 'org.apache.commons:commons-collections4:4.1'
-
-    // for tests
-    androidTestImplementation 'com.android.support.test:runner:1.0.2'
-    androidTestImplementation 'com.android.support.test:rules:1.0.2'
-    androidTestImplementation 'junit:junit:4.12'
-    androidTestImplementation 'com.squareup.okhttp3:mockwebserver:3.11.0'
-
-    testImplementation 'junit:junit:4.12'
-    testImplementation 'com.squareup.okhttp3:mockwebserver:3.11.0'
-}

app/build.gradle.kts

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

app/proguard-rules-release.pro

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

app/proguard-rules.txt

@@ -1,44 +0,0 @@
-
-# ProGuard usage for DAVdroid:
-#       shrinking        yes (main reason for using ProGuard)
-#       optimization     yes
-#       obfuscation      no (DAVdroid is open-source)
-#       preverification  no
-
--dontobfuscate
-
--optimizations !code/simplification/arithmetic,!code/simplification/cast,!field/*,!class/merging/*
--optimizationpasses 5
--allowaccessmodification
--dontpreverify
-
-# Kotlin
--dontwarn kotlin.**
-
-# 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 okio.**
--dontwarn javax.annotation.Nullable
--dontwarn javax.annotation.ParametersAreNonnullByDefault
--dontwarn org.conscrypt.**
-
-# dnsjava
--dontwarn sun.net.spi.nameservice.**   # not available on Android
-
-# DAVdroid + libs
--keep class at.bitfire.** { *; }       # all DAVdroid 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/13.json

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

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

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

app/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,27 @@
+<?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"/>
+
+    <application>
+
+        <!-- test account type (without associated sync adapters) -->
+        <service
+            android:name="at.bitfire.davdroid.sync.account.TestAccountAuthenticator"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.accounts.AccountAuthenticator"
+                android:resource="@xml/test_account_authenticator"/>
+        </service>
+
+    </application>
+
+</manifest>

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

@@ -1,128 +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.support.test.InstrumentationRegistry.getInstrumentation
-import at.bitfire.cert4android.CustomCertManager
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.mockwebserver.MockWebServer
-import org.apache.commons.io.IOUtils
-import org.apache.commons.lang3.ArrayUtils.contains
-import org.junit.After
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.Test
-import java.net.Socket
-import java.security.KeyFactory
-import java.security.KeyStore
-import java.security.Principal
-import java.security.cert.CertificateFactory
-import java.security.cert.X509Certificate
-import java.security.spec.PKCS8EncodedKeySpec
-import javax.net.ssl.SSLSocket
-import javax.net.ssl.TrustManagerFactory
-import javax.net.ssl.X509ExtendedKeyManager
-import javax.net.ssl.X509TrustManager
-
-class CustomTlsSocketFactoryTest {
-
-    private lateinit var certMgr: CustomCertManager
-    private lateinit var factory: CustomTlsSocketFactory
-    private val server = MockWebServer()
-
-    @Before
-    fun startServer() {
-        certMgr = CustomCertManager(getInstrumentation().context, false, true)
-        factory = CustomTlsSocketFactory(null, certMgr)
-        server.start()
-    }
-
-    @After
-    fun stopServer() {
-        server.shutdown()
-        certMgr.close()
-    }
-
-
-    @Test
-    fun testSendClientCertificate() {
-        var public: X509Certificate? = null
-        javaClass.classLoader.getResourceAsStream("sample.crt").use {
-            public = CertificateFactory.getInstance("X509").generateCertificate(it) as? X509Certificate
-        }
-        assertNotNull(public)
-
-        val keyFactory = KeyFactory.getInstance("RSA")
-        val private = keyFactory.generatePrivate(PKCS8EncodedKeySpec(readResource("sample.key")))
-        assertNotNull(private)
-
-        val keyStore = KeyStore.getInstance("AndroidKeyStore")
-        keyStore.load(null)
-        val alias = "sample"
-        keyStore.setKeyEntry(alias, private, null, arrayOf(public))
-        assertTrue(keyStore.containsAlias(alias))
-
-        val trustManagerFactory = TrustManagerFactory.getInstance("X509")
-        trustManagerFactory.init(null as KeyStore?)
-        val trustManager = trustManagerFactory.trustManagers.first() as X509TrustManager
-
-        val factory = CustomTlsSocketFactory(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?) =
-                    arrayOf(public).takeIf { forAlias == alias }
-
-            override fun getPrivateKey(forAlias: String?) =
-                    private.takeIf { forAlias == alias }
-        }, trustManager)
-
-        /* known client cert test URLs (thanks!):
-        *  - https://prod.idrix.eu/secure/
-        *  - https://server.cryptomix.com/secure/
-        */
-        val client = OkHttpClient.Builder()
-                .sslSocketFactory(factory, trustManager)
-                .build()
-        client.newCall(Request.Builder()
-                .get()
-                .url("https://prod.idrix.eu/secure/")
-                .build()).execute().use { response ->
-            assertTrue(response.isSuccessful)
-            assertTrue(response.body()!!.string().contains("CN=User Cert,O=Internet Widgits Pty Ltd,ST=Some-State,C=CA"))
-        }
-    }
-
-    @Test
-    fun testUpgradeTLS() {
-        val s = factory.createSocket(server.hostName, server.port)
-        assertTrue(s is SSLSocket)
-        val ssl = s as SSLSocket
-
-        assertFalse(contains(ssl.enabledProtocols, "SSLv3"))
-        assertTrue(contains(ssl.enabledProtocols, "TLSv1"))
-        assertTrue(contains(ssl.enabledProtocols, "TLSv1.1"))
-        assertTrue(contains(ssl.enabledProtocols, "TLSv1.2"))
-    }
-
-
-    private fun readResource(name: String): ByteArray {
-        this.javaClass.classLoader.getResourceAsStream(name).use {
-            return IOUtils.toByteArray(it)
-        }
-    }
-
-}

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

@@ -1,130 +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.model
-
-import android.content.ContentValues
-import android.support.test.filters.SmallTest
-import at.bitfire.dav4android.DavResource
-import at.bitfire.dav4android.property.ResourceType
-import at.bitfire.davdroid.HttpClient
-import at.bitfire.davdroid.model.ServiceDB.Collections
-import okhttp3.HttpUrl
-import okhttp3.mockwebserver.MockResponse
-import okhttp3.mockwebserver.MockWebServer
-import org.junit.After
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.Test
-
-class CollectionInfoTest {
-
-    private lateinit var httpClient: HttpClient
-    private val server = MockWebServer()
-
-    @Before
-    fun setUp() {
-        httpClient = HttpClient.Builder().build()
-    }
-
-    @After
-    fun shutDown() {
-        httpClient.close()
-    }
-
-
-    @Test
-    @SmallTest
-    fun testFromDavResource() {
-        // r/w address book
-        server.enqueue(MockResponse()
-                .setResponseCode(207)
-                .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav'>" +
-                        "<response>" +
-                        "   <href>/</href>" +
-                        "   <propstat><prop>" +
-                        "       <resourcetype><collection/><CARD:addressbook/></resourcetype>" +
-                        "       <displayname>My Contacts</displayname>" +
-                        "       <CARD:addressbook-description>My Contacts Description</CARD:addressbook-description>" +
-                        "   </prop></propstat>" +
-                        "</response>" +
-                        "</multistatus>"))
-
-        var info: CollectionInfo? = null
-        DavResource(httpClient.okHttpClient, server.url("/"))
-                .propfind(0, ResourceType.NAME) { response, _ ->
-            info = CollectionInfo(response)
-        }
-        assertEquals(CollectionInfo.Type.ADDRESS_BOOK, info?.type)
-        assertFalse(info!!.readOnly)
-        assertEquals("My Contacts", info?.displayName)
-        assertEquals("My Contacts Description", info?.description)
-
-        // read-only calendar, no display name
-        server.enqueue(MockResponse()
-                .setResponseCode(207)
-                .setBody("<multistatus xmlns='DAV:' xmlns:CAL='urn:ietf:params:xml:ns:caldav' xmlns:ICAL='http://apple.com/ns/ical/'>" +
-                        "<response>" +
-                        "   <href>/</href>" +
-                        "   <propstat><prop>" +
-                        "       <resourcetype><collection/><CAL:calendar/></resourcetype>" +
-                        "       <current-user-privilege-set><privilege><read/></privilege></current-user-privilege-set>" +
-                        "       <CAL:calendar-description>My Calendar</CAL:calendar-description>" +
-                        "       <CAL:calendar-timezone>tzdata</CAL:calendar-timezone>" +
-                        "       <ICAL:calendar-color>#ff0000</ICAL:calendar-color>" +
-                        "   </prop></propstat>" +
-                        "</response>" +
-                        "</multistatus>"))
-
-        info = null
-        DavResource(httpClient.okHttpClient, server.url("/"))
-                .propfind(0, ResourceType.NAME) { response, _ ->
-            info = CollectionInfo(response)
-        }
-        assertEquals(CollectionInfo.Type.CALENDAR, info?.type)
-        assertTrue(info!!.readOnly)
-        assertNull(info?.displayName)
-        assertEquals("My Calendar", info?.description)
-        assertEquals(0xFFFF0000.toInt(), info?.color)
-        assertEquals("tzdata", info?.timeZone)
-        assertTrue(info!!.supportsVEVENT)
-        assertTrue(info!!.supportsVTODO)
-    }
-
-    @Test
-    fun testFromDB() {
-        val values = ContentValues()
-        values.put(Collections.ID, 1)
-        values.put(Collections.SERVICE_ID, 1)
-        values.put(Collections.TYPE, CollectionInfo.Type.CALENDAR.name)
-        values.put(Collections.URL, "http://example.com")
-        values.put(Collections.READ_ONLY, 1)
-        values.put(Collections.DISPLAY_NAME, "display name")
-        values.put(Collections.DESCRIPTION, "description")
-        values.put(Collections.COLOR, 0xFFFF0000)
-        values.put(Collections.TIME_ZONE, "tzdata")
-        values.put(Collections.SUPPORTS_VEVENT, 1)
-        values.put(Collections.SUPPORTS_VTODO, 1)
-        values.put(Collections.SYNC, 1)
-
-        val info = CollectionInfo(values)
-        assertEquals(CollectionInfo.Type.CALENDAR, info.type)
-        assertEquals(1.toLong(), info.id)
-        assertEquals(1.toLong(), info.serviceID)
-        assertEquals(HttpUrl.parse("http://example.com/"), info.url)
-        assertTrue(info.readOnly)
-        assertEquals("display name", info.displayName)
-        assertEquals("description", info.description)
-        assertEquals(0xFFFF0000.toInt(), info.color)
-        assertEquals("tzdata", info.timeZone)
-        assertTrue(info.supportsVEVENT)
-        assertTrue(info.supportsVTODO)
-        assertTrue(info.selected)
-    }
-
-}

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

@@ -1,39 +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 at.bitfire.davdroid.App
-import junit.framework.Assert.assertEquals
-import junit.framework.Assert.assertFalse
-import org.junit.Test
-
-class DefaultsProviderTest {
-
-    private val provider: Provider = DefaultsProvider()
-
-    @Test
-    fun testHas() {
-        assertEquals(Pair(false, true), provider.has("notExisting"))
-        assertEquals(Pair(true, true), provider.has(App.OVERRIDE_PROXY))
-    }
-
-    @Test
-    fun testGet() {
-        assertEquals(Pair("localhost", true), provider.getString(App.OVERRIDE_PROXY_HOST))
-        assertEquals(Pair(8118, true), provider.getInt(App.OVERRIDE_PROXY_PORT))
-    }
-
-    @Test
-    fun testPutRemove() {
-        assertEquals(Pair(false, true), provider.isWritable(App.OVERRIDE_PROXY))
-        assertFalse(provider.putBoolean(App.OVERRIDE_PROXY, true))
-        assertFalse(provider.remove(App.OVERRIDE_PROXY))
-    }
-
-}

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

@@ -1,44 +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 android.support.test.InstrumentationRegistry
-import android.support.test.InstrumentationRegistry.getTargetContext
-import at.bitfire.davdroid.App
-import junit.framework.Assert.assertFalse
-import junit.framework.Assert.assertTrue
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-
-class SettingsTest {
-
-    lateinit var settings: Settings.Stub
-
-    @Before
-    fun init() {
-        InstrumentationRegistry.getContext().isRestricted
-        settings = Settings.getInstance(getTargetContext())!!
-    }
-
-    @After
-    fun shutdown() {
-        settings.close()
-    }
-
-
-    @Test
-    fun testHas() {
-        assertFalse(settings.has("notExisting"))
-
-        // provided by DefaultsProvider
-        assertTrue(settings.has(App.OVERRIDE_PROXY))
-    }
-
-}

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

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

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

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

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

@@ -0,0 +1,123 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid
+
+import android.Manifest
+import android.accounts.Account
+import android.content.ContentProviderClient
+import android.content.ContentUris
+import android.content.ContentValues
+import android.os.Build
+import android.provider.CalendarContract
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import at.bitfire.davdroid.resource.LocalCalendar
+import at.bitfire.davdroid.resource.LocalEvent
+import at.bitfire.ical4android.AndroidCalendar
+import at.bitfire.ical4android.Event
+import net.fortuna.ical4j.model.property.DtStart
+import net.fortuna.ical4j.model.property.RRule
+import org.junit.Assert.assertNotNull
+import org.junit.rules.ExternalResource
+import org.junit.rules.RuleChain
+import java.util.logging.Logger
+
+/**
+ * JUnit ClassRule which initializes the AOSP CalendarProvider.
+ *
+ * It seems that the calendar provider unfortunately forgets the very first requests when it is used the very first time,
+ * maybe by some wrongly synchronized database initialization. So things like querying the instances
+ * fails in this case.
+ *
+ * So this rule is needed to allow tests which need the calendar provider to succeed even when the calendar provider
+ * is used the very first time (especially in CI tests / a fresh emulator).
+ *
+ * See [at.bitfire.davdroid.resource.LocalCalendarTest] for an example of how to use this rule.
+ */
+class InitCalendarProviderRule private constructor(): ExternalResource() {
+
+    companion object {
+
+        private var isInitialized = false
+        private val logger = Logger.getLogger(InitCalendarProviderRule::javaClass.name)
+
+        fun getInstance(): RuleChain = RuleChain
+            .outerRule(GrantPermissionRule.grant(Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR))
+            .around(InitCalendarProviderRule())
+
+    }
+
+    override fun before() {
+        if (!isInitialized) {
+            logger.info("Initializing calendar provider")
+            if (Build.VERSION.SDK_INT < 31)
+                logger.warning("Calendar provider initialization may or may not work. See InitCalendarProviderRule")
+
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+            val client = context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)
+            assertNotNull("Couldn't acquire calendar provider", client)
+
+            client!!.use {
+                initCalendarProvider(client)
+                isInitialized = true
+            }
+        }
+    }
+
+    private fun initCalendarProvider(provider: ContentProviderClient) {
+        val account = Account("LocalCalendarTest", CalendarContract.ACCOUNT_TYPE_LOCAL)
+
+        // Sometimes, the calendar provider returns an ID for the created calendar, but then fails to find it.
+        var calendarOrNull: LocalCalendar? = null
+        for (i in 0..50) {
+            calendarOrNull = createAndVerifyCalendar(account, provider)
+            if (calendarOrNull != null)
+                break
+            else
+                Thread.sleep(100)
+        }
+        val calendar = calendarOrNull ?: throw IllegalStateException("Couldn't create calendar")
+
+        try {
+            // single event init
+            val normalEvent = Event().apply {
+                dtStart = DtStart("20220120T010203Z")
+                summary = "Event with 1 instance"
+            }
+            val normalLocalEvent = LocalEvent(calendar, normalEvent, null, null, null, 0)
+            normalLocalEvent.add()
+            LocalEvent.numInstances(provider, account, normalLocalEvent.id!!)
+
+            // recurring event init
+            val recurringEvent = Event().apply {
+                dtStart = DtStart("20220120T010203Z")
+                summary = "Event over 22 years"
+                rRules.add(RRule("FREQ=YEARLY;UNTIL=20740119T010203Z"))     // year needs to be  >2074 (not supported by Android <11 Calendar Storage)
+            }
+            val localRecurringEvent = LocalEvent(calendar, recurringEvent, null, null, null, 0)
+            localRecurringEvent.add()
+            LocalEvent.numInstances(provider, account, localRecurringEvent.id!!)
+        } finally {
+            calendar.delete()
+        }
+    }
+
+    private fun createAndVerifyCalendar(account: Account, provider: ContentProviderClient): LocalCalendar? {
+        val uri = AndroidCalendar.create(account, provider, ContentValues())
+
+        return try {
+            AndroidCalendar.findByID(
+                account,
+                provider,
+                LocalCalendar.Factory,
+                ContentUris.parseId(uri)
+            )
+        } catch (e: Exception) {
+            logger.warning("Couldn't find calendar after creation: $e")
+            null
+        }
+    }
+
+}

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

@@ -0,0 +1,48 @@
+/*
+ * 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.network.HttpClient
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import okhttp3.Request
+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
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testIcloudWithSettings() {
+        val client = HttpClient.Builder(context).build()
+        client.okHttpClient.newCall(Request.Builder()
+                .get()
+                .url("https://icloud.com")
+                .build())
+                .execute()
+    }
+
+}

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

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

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

@@ -0,0 +1,82 @@
+/*
+ * 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
+import kotlin.math.abs
+
+object TestUtils {
+
+    fun assertWithin(expected: Long, actual: Long, tolerance: Long) {
+        val absDifference = abs(expected - actual)
+        assertTrue(
+            "$actual not within ($expected ± $tolerance)",
+            absDifference <= tolerance
+        )
+    }
+
+    @TestOnly
+    fun workScheduledOrRunning(context: Context, workerName: String): Boolean =
+        workInStates(context, workerName, listOf(
+            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/kotlin/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/kotlin/at/bitfire/davdroid/db/CollectionTest.kt

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

app/src/androidTest/kotlin/at/bitfire/davdroid/db/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/kotlin/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>().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/kotlin/at/bitfire/davdroid/network/DnsRecordResolverTest.kt

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

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

@@ -1,30 +1,45 @@
 /*
- * 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.content.Context
+import android.security.NetworkSecurityPolicy
+import dagger.hilt.android.qualifiers.ApplicationContext
+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.Assert.assertTrue
+import org.junit.Assume
 import org.junit.Before
+import org.junit.Rule
 import org.junit.Test
+import javax.inject.Inject
 
+@HiltAndroidTest
 class HttpClientTest {
 
     lateinit var server: MockWebServer
     lateinit var httpClient: HttpClient
 
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
     @Before
     fun setUp() {
-        httpClient = HttpClient.Builder().build()
+        hiltRule.inject()
+
+        httpClient = HttpClient.Builder(context).build()
 
         server = MockWebServer()
         server.start(30000)
@@ -39,6 +54,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
@@ -61,7 +77,8 @@ class HttpClientTest {
         httpClient.okHttpClient.newCall(Request.Builder()
                 .get().url(url)
                 .build()).execute()
-        assertEquals("cookie2=2; cookie1=1", server.takeRequest().getHeader("Cookie"))
+        val header = server.takeRequest().getHeader("Cookie")
+        assertTrue(header == "cookie1=1; cookie2=2" || header == "cookie2=2; cookie1=1")
 
         server.enqueue(MockResponse()
                 .setResponseCode(200))

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,281 @@
+/*
+ * 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.content.Context
+import android.provider.ContactsContract
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+import at.bitfire.vcard4android.BatchOperation
+import at.bitfire.vcard4android.CachedGroupMembership
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.GroupMethod
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class LocalGroupTest {
+
+    companion object {
+
+        @JvmField
+        @ClassRule
+        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
+
+        private lateinit var provider: ContentProviderClient
+
+        @BeforeClass
+        @JvmStatic
+        fun connect() {
+            val context = InstrumentationRegistry.getInstrumentation().targetContext
+            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
+            assertNotNull(provider)
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun disconnect() {
+            provider.close()
+        }
+    }
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+
+    private lateinit var addressBookGroupsAsCategories: LocalTestAddressBook
+    private lateinit var addressBookGroupsAsVCards: LocalTestAddressBook
+
+    @Before
+    fun setup() {
+        hiltRule.inject()
+
+        addressBookGroupsAsCategories = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
+        addressBookGroupsAsVCards = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+
+        // clear contacts
+        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)
+    }
+
+
+    // helpers
+
+    private fun newGroup(addressBook: LocalAddressBook = addressBookGroupsAsCategories): LocalGroup =
+        LocalGroup(addressBook,
+            Contact().apply {
+                displayName = "Test Group"
+            }, null, null, 0
+        ).apply {
+            add()
+        }
+
+}

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

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

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

@@ -0,0 +1,87 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.resource.contactrow
+
+import android.Manifest
+import android.content.ContentProviderClient
+import android.content.ContentValues
+import android.content.Context
+import android.provider.ContactsContract
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+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 dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
+import org.junit.Assert.assertArrayEquals
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class CachedGroupMembershipHandlerTest {
+
+    companion object {
+
+        @JvmField
+        @ClassRule
+        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
+
+        private lateinit var provider: ContentProviderClient
+
+        @BeforeClass
+        @JvmStatic
+        fun connect() {
+            val context = InstrumentationRegistry.getInstrumentation().context
+            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun disconnect() {
+            provider.close()
+        }
+
+    }
+
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testMembership() {
+        val addressBook = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+
+        val contact = Contact()
+        val localContact = LocalContact(addressBook, contact, null, null, 0)
+        CachedGroupMembershipHandler(localContact).handle(ContentValues().apply {
+            put(CachedGroupMembership.GROUP_ID, 123456)
+            put(CachedGroupMembership.RAW_CONTACT_ID, 789)
+        }, contact)
+        assertArrayEquals(arrayOf(123456L), localContact.cachedGroupMemberships.toArray())
+    }
+
+}

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

@@ -0,0 +1,97 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.resource.contactrow
+
+import android.Manifest
+import android.content.ContentProviderClient
+import android.content.Context
+import android.net.Uri
+import android.provider.ContactsContract
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership
+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 dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class GroupMembershipBuilderTest {
+
+    companion object {
+
+        @JvmField
+        @ClassRule
+        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
+
+        private lateinit var provider: ContentProviderClient
+
+        @BeforeClass
+        @JvmStatic
+        fun connect() {
+            val context: Context = InstrumentationRegistry.getInstrumentation().targetContext
+            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun disconnect() {
+            provider.close()
+        }
+
+    }
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testCategories_GroupsAsCategories() {
+        val contact = Contact().apply {
+            categories += "TEST GROUP"
+        }
+        val addressBookGroupsAsCategories = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
+        GroupMembershipBuilder(Uri.EMPTY, null, contact, addressBookGroupsAsCategories, false).build().also { result ->
+            assertEquals(1, result.size)
+            assertEquals(GroupMembership.CONTENT_ITEM_TYPE, result[0].values[GroupMembership.MIMETYPE])
+            assertEquals(addressBookGroupsAsCategories.findOrCreateGroup("TEST GROUP"), result[0].values[GroupMembership.GROUP_ROW_ID])
+        }
+    }
+
+    @Test
+    fun testCategories_GroupsAsVCards() {
+        val contact = Contact().apply {
+            categories += "TEST GROUP"
+        }
+        val addressBookGroupsAsVCards = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+        GroupMembershipBuilder(Uri.EMPTY, null, contact, addressBookGroupsAsVCards, false).build().also { result ->
+            // group membership is constructed during post-processing
+            assertEquals(0, result.size)
+        }
+    }
+
+}

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

@@ -0,0 +1,105 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.resource.contactrow
+
+import android.Manifest
+import android.content.ContentProviderClient
+import android.content.ContentValues
+import android.content.Context
+import android.provider.ContactsContract
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.test.rule.GrantPermissionRule
+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 dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.AfterClass
+import org.junit.Assert
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.BeforeClass
+import org.junit.ClassRule
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class GroupMembershipHandlerTest {
+
+    companion object {
+
+        @JvmField
+        @ClassRule
+        val permissionRule = GrantPermissionRule.grant(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS)!!
+
+        private lateinit var provider: ContentProviderClient
+
+        @BeforeClass
+        @JvmStatic
+        fun connect() {
+            val context: Context = InstrumentationRegistry.getInstrumentation().context
+            provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)!!
+            Assert.assertNotNull(provider)
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun disconnect() {
+            provider.close()
+        }
+
+    }
+
+    @Inject
+    lateinit var addressbookFactory: LocalTestAddressBook.Factory
+
+    @Inject @ApplicationContext
+    lateinit var context: Context
+
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
+    @Before
+    fun inject() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testMembership_GroupsAsCategories() {
+        val addressBookGroupsAsCategories = addressbookFactory.create(provider, GroupMethod.CATEGORIES)
+        val addressBookGroupsAsCategoriesGroup = addressBookGroupsAsCategories.findOrCreateGroup("TEST GROUP")
+
+        val contact = Contact()
+        val localContact = LocalContact(addressBookGroupsAsCategories, contact, null, null, 0)
+        GroupMembershipHandler(localContact).handle(ContentValues().apply {
+            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 addressBookGroupsAsVCards = addressbookFactory.create(provider, GroupMethod.GROUP_VCARDS)
+
+        val contact = Contact()
+        val localContact = LocalContact(addressBookGroupsAsVCards, contact, null, null, 0)
+        GroupMembershipHandler(localContact).handle(ContentValues().apply {
+            put(CachedGroupMembership.GROUP_ID, 12345)    // because the group name is not queried and put into CATEGORIES, the group doesn't have to really exist
+            put(CachedGroupMembership.RAW_CONTACT_ID, -1)
+        }, contact)
+        assertArrayEquals(arrayOf(12345L), localContact.groupMemberships.toArray())
+        assertTrue(contact.categories.isEmpty())
+    }
+
+}

app/src/androidTest/kotlin/at/bitfire/davdroid/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/kotlin/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/kotlin/at/bitfire/davdroid/servicedetection/CollectionListRefresherTest.kt

@@ -0,0 +1,718 @@
+/*
+ * 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 at.bitfire.davdroid.db.AppDatabase
+import at.bitfire.davdroid.db.Collection
+import at.bitfire.davdroid.db.HomeSet
+import at.bitfire.davdroid.db.Principal
+import at.bitfire.davdroid.db.Service
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.every
+import io.mockk.mockkObject
+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.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Assume
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import java.util.logging.Logger
+import javax.inject.Inject
+
+@HiltAndroidTest
+class CollectionListRefresherTest {
+
+    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"
+    }
+
+    @get:Rule
+    var hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var db: AppDatabase
+
+    @Inject
+    lateinit var logger: Logger
+
+    @Inject
+    lateinit var refresherFactory: CollectionListRefresher.Factory
+
+    @Inject
+    lateinit var settings: SettingsManager
+
+    private val mockServer = MockWebServer()
+    private lateinit var client: HttpClient
+
+    @Before
+    fun setup() {
+        hiltRule.inject()
+
+        // Start mock web server
+        mockServer.dispatcher = TestDispatcher(logger)
+        mockServer.start()
+
+        client = HttpClient.Builder(context).build()
+
+        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
+    }
+
+    @After
+    fun teardown() {
+        mockServer.shutdown()
+        db.close()
+    }
+
+
+    @Test
+    fun testDiscoverHomesets() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+        val baseUrl = mockServer.url(PATH_CARDDAV + SUBPATH_PRINCIPAL)
+
+        // Query home sets
+        refresherFactory.create(service, client.okHttpClient).discoverHomesets(baseUrl)
+
+        // Check home sets have been saved to database
+        assertEquals(mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET/"), db.homeSetDao().getByService(service.id).first().url)
+        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
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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.
+        refresherFactory.create(service, 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)
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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)
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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
+        refresherFactory.create(service, 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)!!
+
+        mockkObject(settings) {
+            every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_NONE
+            every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+            val collection = Collection(
+                0,
+                service.id,
+                0,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+            )
+            val homesets = listOf(
+                HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+            )
+
+            val refresher = refresherFactory.create(service, client.okHttpClient)
+            assertFalse(refresher.shouldPreselect(collection, homesets))
+        }
+    }
+
+    @Test
+    fun shouldPreselect_all() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        mockkObject(settings) {
+            every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_ALL
+            every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+            val collection = Collection(
+                0,
+                service.id,
+                0,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+            )
+            val homesets = listOf(
+                HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+            )
+
+            val refresher = refresherFactory.create(service, 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/")
+
+        mockkObject(settings) {
+            every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_ALL
+            every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns url.toString()
+
+            val collection = Collection(
+                0,
+                service.id,
+                0,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = url
+            )
+            val homesets = listOf(
+                HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+            )
+
+            val refresher = refresherFactory.create(service, client.okHttpClient)
+            assertFalse(refresher.shouldPreselect(collection, homesets))
+        }
+    }
+
+    @Test
+    fun shouldPreselect_personal_notPersonal() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        mockkObject(settings) {
+            every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
+            every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+            val collection = Collection(
+                0,
+                service.id,
+                0,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+            )
+            val homesets = listOf(
+                HomeSet(0, service.id, false, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+            )
+
+            val refresher = refresherFactory.create(service, client.okHttpClient)
+            assertFalse(refresher.shouldPreselect(collection, homesets))
+        }
+    }
+
+    @Test
+    fun shouldPreselect_personal_isPersonal() {
+        val service = createTestService(Service.TYPE_CARDDAV)!!
+
+        mockkObject(settings) {
+            every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
+            every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns ""
+
+            val collection = Collection(
+                0,
+                service.id,
+                0,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/")
+            )
+            val homesets = listOf(
+                HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+            )
+
+            val refresher = refresherFactory.create(service, 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/")
+
+        mockkObject(settings) {
+            every { settings.getIntOrNull(Settings.PRESELECT_COLLECTIONS) } returns Settings.PRESELECT_COLLECTIONS_PERSONAL
+            every { settings.getString(Settings.PRESELECT_COLLECTIONS_EXCLUDED) } returns collectionUrl.toString()
+
+            val collection = Collection(
+                0,
+                service.id,
+                0,
+                type = Collection.TYPE_ADDRESSBOOK,
+                url = collectionUrl
+            )
+            val homesets = listOf(
+                HomeSet(0, service.id, true, mockServer.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET"))
+            )
+
+            val refresher = refresherFactory.create(service, 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(
+        private val logger: Logger
+    ): Dispatcher() {
+
+        override fun dispatch(request: RecordedRequest): MockResponse {
+            val path = request.path!!.trimEnd('/')
+
+            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.info("Queried: $path")
+                logger.info("Response: $responseBody")
+                return MockResponse()
+                    .setResponseCode(responseCode)
+                    .setBody(responseBody)
+            }
+
+            return MockResponse().setResponseCode(404)
+        }
+
+    }
+}

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

@@ -1,32 +1,41 @@
 /*
- * 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.support.test.InstrumentationRegistry.getTargetContext
-import android.support.test.filters.SmallTest
-import at.bitfire.dav4android.DavResource
-import at.bitfire.dav4android.property.AddressbookHomeSet
-import at.bitfire.dav4android.property.ResourceType
-import at.bitfire.davdroid.HttpClient
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.Credentials
-import at.bitfire.davdroid.ui.setup.DavResourceFinder.Configuration.ServiceInfo
+import android.content.Context
+import android.security.NetworkSecurityPolicy
+import androidx.test.filters.SmallTest
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.property.carddav.AddressbookHomeSet
+import at.bitfire.dav4jvm.property.webdav.ResourceType
+import at.bitfire.davdroid.db.Credentials
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.servicedetection.DavResourceFinder.Configuration.ServiceInfo
+import at.bitfire.davdroid.settings.SettingsManager
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
 import okhttp3.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 java.util.logging.Logger
+import javax.inject.Inject
 
+@HiltAndroidTest
 class DavResourceFinderTest {
 
     companion object {
@@ -40,27 +49,47 @@ class DavResourceFinderTest {
         private const val SUBPATH_ADDRESSBOOK = "/addressbooks/private-contacts"
     }
 
-    val server = MockWebServer()
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
 
-    lateinit var finder: DavResourceFinder
-    lateinit var client: HttpClient
-    lateinit var loginInfo: LoginInfo
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var logger: Logger
+
+    @Inject
+    lateinit var resourceFinderFactory: DavResourceFinder.Factory
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    private val server = MockWebServer()
+
+    private lateinit var finder: DavResourceFinder
+    private lateinit var client: HttpClient
 
     @Before
-    fun initServerAndClient() {
-        server.setDispatcher(TestDispatcher())
+    fun setup() {
+        hiltRule.inject()
+
+        server.dispatcher = TestDispatcher(logger)
         server.start()
 
-        loginInfo = LoginInfo(URI.create("/"), Credentials("mock", "12345"))
-        finder = DavResourceFinder(getTargetContext(), loginInfo)
+        val baseURI = URI.create("/")
+        val credentials = Credentials("mock", "12345")
 
-        client = HttpClient.Builder()
-                .addAuthentication(null, loginInfo.credentials)
+        finder = resourceFinderFactory.create(baseURI, credentials)
+        client = HttpClient.Builder(context)
+                .addAuthentication(null, credentials)
                 .build()
+
+        Assume.assumeTrue(NetworkSecurityPolicy.getInstance().isCleartextTrafficPermitted)
     }
 
     @After
-    fun stopServer() {
+    fun teardown() {
         server.shutdown()
     }
 
@@ -72,7 +101,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)
@@ -82,7 +111,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())
@@ -122,21 +151,33 @@ 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() {
+    class TestDispatcher(
+        private val logger: Logger
+    ): 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"
@@ -147,7 +188,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,
@@ -165,14 +206,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")
+                logger.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/kotlin/at/bitfire/davdroid/settings/SettingsManagerTest.kt

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

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

@@ -0,0 +1,49 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync
+
+import at.bitfire.davdroid.db.SyncState
+import at.bitfire.davdroid.resource.LocalCollection
+
+class LocalTestCollection(
+    override val collectionUrl: String = "http://example.com/test/"
+): LocalCollection<LocalTestResource> {
+
+    override val tag = "LocalTestCollection"
+    override val title = "Local Test Collection"
+
+    override var lastSyncState: SyncState? = null
+
+    val entries = mutableListOf<LocalTestResource>()
+
+    override val readOnly: Boolean
+        get() = throw NotImplementedError()
+
+    override fun deleteCollection(): Boolean = true
+
+    override fun findDeleted() = entries.filter { it.deleted }
+    override fun findDirty() = entries.filter { it.dirty }
+
+    override fun findByName(name: String) = entries.firstOrNull { it.fileName == name }
+
+    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/androidTest/kotlin/at/bitfire/davdroid/sync/LocalTestResource.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync
+
+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()
+    override fun resetDeleted() = throw NotImplementedError()
+
+}

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

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

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

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

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

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

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

@@ -0,0 +1,127 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync
+
+import android.accounts.Account
+import at.bitfire.dav4jvm.DavCollection
+import at.bitfire.dav4jvm.MultiResponseCallback
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.property.caldav.GetCTag
+import at.bitfire.davdroid.db.Collection
+import at.bitfire.davdroid.db.SyncState
+import at.bitfire.davdroid.network.HttpClient
+import at.bitfire.davdroid.resource.LocalResource
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.util.DavUtils.lastSegment
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import okhttp3.HttpUrl
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.junit.Assert.assertEquals
+
+class TestSyncManager @AssistedInject constructor(
+    @Assisted account: Account,
+    @Assisted accountSettings: AccountSettings,
+    @Assisted extras: Array<String>,
+    @Assisted authority: String,
+    @Assisted httpClient: HttpClient,
+    @Assisted syncResult: SyncResult,
+    @Assisted localCollection: LocalTestCollection,
+    @Assisted collection: Collection
+): SyncManager<LocalTestResource, LocalTestCollection, DavCollection>(
+    account,
+    accountSettings,
+    httpClient,
+    extras,
+    authority,
+    syncResult,
+    localCollection,
+    collection
+) {
+
+    @AssistedFactory
+    interface Factory {
+        fun create(
+            account: Account,
+            accountSettings: AccountSettings,
+            extras: Array<String>,
+            authority: String,
+            httpClient: HttpClient,
+            syncResult: SyncResult,
+            localCollection: LocalTestCollection,
+            collection: Collection
+        ): TestSyncManager
+    }
+
+    override fun prepare(): Boolean {
+        davCollection = DavCollection(httpClient.okHttpClient, collection.url)
+        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 = url.lastSegment
+            var localEntry = localCollection.entries.firstOrNull { it.fileName == fileName }
+            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/androidTest/kotlin/at/bitfire/davdroid/sync/account/AccountUtilsTest.kt

@@ -0,0 +1,67 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync.account
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.Context
+import android.os.Bundle
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.davdroid.test.R
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class AccountUtilsTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+    val testContext = InstrumentationRegistry.getInstrumentation().context
+
+    @Inject
+    lateinit var settingsManager: SettingsManager
+
+    val account = Account(
+        "AccountUtilsTest",
+        testContext.getString(R.string.account_type_test)
+    )
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+    }
+
+
+    @Test
+    fun testCreateAccount() {
+        val userData = Bundle(2)
+        userData.putString("int", "1")
+        userData.putString("string", "abc/\"-")
+
+        val manager = AccountManager.get(context)
+        try {
+            assertTrue(SystemAccountUtils.createAccount(context, account, userData))
+
+            // validate user data
+            assertEquals("1", manager.getUserData(account, "int"))
+            assertEquals("abc/\"-", manager.getUserData(account, "string"))
+        } finally {
+            assertTrue(manager.removeAccountExplicitly(account))
+        }
+    }
+
+}

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

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

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

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

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

@@ -0,0 +1,103 @@
+/***************************************************************************************************
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ **************************************************************************************************/
+
+package at.bitfire.davdroid.sync.worker
+
+import android.accounts.Account
+import android.content.Context
+import android.provider.CalendarContract
+import android.util.Log
+import androidx.test.platform.app.InstrumentationRegistry
+import androidx.work.Configuration
+import androidx.work.ListenableWorker
+import androidx.work.WorkManager
+import androidx.work.WorkerFactory
+import androidx.work.WorkerParameters
+import androidx.work.testing.TestListenableWorkerBuilder
+import androidx.work.testing.WorkManagerTestInitHelper
+import androidx.work.workDataOf
+import at.bitfire.davdroid.sync.account.TestAccountAuthenticator
+import at.bitfire.davdroid.test.R
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.mockkObject
+import io.mockk.verify
+import kotlinx.coroutines.runBlocking
+import org.junit.After
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class PeriodicSyncWorkerTest {
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+    val testContext = InstrumentationRegistry.getInstrumentation().context
+
+    @Inject
+    lateinit var syncWorkerFactory: PeriodicSyncWorker.Factory
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    lateinit var account: Account
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+
+        // Initialize WorkManager for instrumentation tests.
+        val config = Configuration.Builder()
+            .setMinimumLoggingLevel(Log.DEBUG)
+            .build()
+        WorkManagerTestInitHelper.initializeTestWorkManager(context, config)
+
+        account = TestAccountAuthenticator.create()
+    }
+
+    @After
+    fun tearDown() {
+        TestAccountAuthenticator.remove(account)
+    }
+
+
+    @Test
+    fun doWork_cancelsItselfOnInvalidAccount() {
+        val invalidAccount = Account("invalid", testContext.getString(R.string.account_type_test))
+
+        // Run PeriodicSyncWorker as TestWorker
+        val inputData = workDataOf(
+            BaseSyncWorker.INPUT_AUTHORITY to CalendarContract.AUTHORITY,
+            BaseSyncWorker.INPUT_ACCOUNT_NAME to invalidAccount.name,
+            BaseSyncWorker.INPUT_ACCOUNT_TYPE to invalidAccount.type
+        )
+
+        // mock WorkManager to observe cancellation call
+        val workManager = WorkManager.getInstance(context)
+        mockkObject(workManager)
+
+        // run test worker, expect failure
+        val testWorker = TestListenableWorkerBuilder<PeriodicSyncWorker>(context, inputData)
+            .setWorkerFactory(object: WorkerFactory() {
+                override fun createWorker(appContext: Context, workerClassName: String, workerParameters: WorkerParameters) =
+                    syncWorkerFactory.create(appContext, workerParameters)
+            })
+            .build()
+        val result = runBlocking {
+            testWorker.doWork()
+        }
+        assertTrue(result is ListenableWorker.Result.Failure)
+
+        // verify that worker called WorkManager.cancelWorkById(<its ID>)
+        verify {
+            workManager.cancelWorkById(testWorker.id)
+        }
+    }
+
+}

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

@@ -0,0 +1,280 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package at.bitfire.davdroid.sync.worker
+
+import android.accounts.Account
+import android.content.Context
+import android.net.ConnectivityManager
+import android.net.Network
+import android.net.NetworkCapabilities
+import android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET
+import android.net.NetworkCapabilities.NET_CAPABILITY_NOT_VPN
+import android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED
+import android.net.NetworkCapabilities.TRANSPORT_WIFI
+import android.net.wifi.WifiInfo
+import android.net.wifi.WifiManager
+import androidx.core.content.getSystemService
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.sync.SyncConditions
+import at.bitfire.davdroid.util.PermissionUtils
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import io.mockk.every
+import io.mockk.impl.annotations.MockK
+import io.mockk.junit4.MockKRule
+import io.mockk.mockk
+import io.mockk.mockkObject
+import io.mockk.spyk
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import javax.inject.Inject
+
+@HiltAndroidTest
+class SyncConditionsTest {
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @get:Rule
+    val mockkRule = MockKRule(this)
+
+    @MockK
+    lateinit var capabilities: NetworkCapabilities
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var factory: SyncConditions.Factory
+
+    @MockK
+    lateinit var network1: Network
+
+    @MockK
+    lateinit var network2: Network
+
+
+    private lateinit var accountSettings: AccountSettings
+
+    private lateinit var conditions: SyncConditions
+
+    private lateinit var connectivityManager: ConnectivityManager
+
+    @Before
+    fun setup() {
+        hiltRule.inject()
+
+        // prepare accountSettings with some necessary data
+        accountSettings = mockk<AccountSettings> {
+            every { account } returns Account("test", "test")
+            every { getIgnoreVpns() } returns false     // default value
+        }
+
+        conditions = factory.create(accountSettings)
+
+        connectivityManager = context.getSystemService<ConnectivityManager>()!!.also { cm ->
+            mockkObject(cm)
+            every { cm.allNetworks } returns arrayOf(network1, network2)
+            every { cm.getNetworkInfo(network1) } returns mockk()
+            every { cm.getNetworkInfo(network2) } returns mockk()
+            every { cm.getNetworkCapabilities(network1) } returns capabilities
+            every { cm.getNetworkCapabilities(network2) } returns capabilities
+        }
+    }
+
+
+    @Test
+    fun testCorrectWifiSsid_CorrectWiFiSsid() {
+        every { accountSettings.getSyncWifiOnlySSIDs() } returns listOf("SampleWiFi1","ConnectedWiFi")
+
+        mockkObject(PermissionUtils)
+        every { PermissionUtils.canAccessWifiSsid(any()) } returns true
+
+        val wifiManager = context.getSystemService<WifiManager>()!!
+        mockkObject(wifiManager)
+        every { wifiManager.connectionInfo } returns spyk<WifiInfo>().apply {
+            every { ssid } returns "ConnectedWiFi"
+        }
+
+        assertTrue(conditions.correctWifiSsid())
+    }
+
+    @Test
+    fun testCorrectWifiSsid_WrongWiFiSsid() {
+        every { accountSettings.getSyncWifiOnlySSIDs() } returns listOf("SampleWiFi1","SampleWiFi2")
+
+        mockkObject(PermissionUtils)
+        every { PermissionUtils.canAccessWifiSsid(any()) } returns true
+
+        val wifiManager = context.getSystemService<WifiManager>()!!
+        mockkObject(wifiManager)
+        every { wifiManager.connectionInfo } returns spyk<WifiInfo>().apply {
+            every { ssid } returns "ConnectedWiFi"
+        }
+
+        assertFalse(conditions.correctWifiSsid())
+    }
+
+
+    @Test
+    fun testInternetAvailable_capabilitiesNull() {
+        every { connectivityManager.getNetworkCapabilities(network1) } returns null
+        every { connectivityManager.getNetworkCapabilities(network2) } returns null
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_Internet() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_Validated() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns false
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_InternetValidated() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertTrue(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_ignoreVpns() {
+        every { accountSettings.getIgnoreVpns() } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_NOT_VPN) } returns false
+        assertFalse(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_ignoreVpns_NotVpn() {
+        every { accountSettings.getIgnoreVpns() } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_NOT_VPN) } returns true
+        assertTrue(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_twoConnectionsFirstOneWithoutInternet() {
+        // The real case that failed in davx5-ose#395 is that the connection list contains (in this order)
+        // 1. a mobile network without INTERNET, but with VALIDATED
+        // 2. a WiFi network with INTERNET and VALIDATED
+
+        // The "return false" of hasINTERNET will trigger at the first connection, the
+        // "andThen true" will trigger for the second connection
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns false andThen true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+
+        // There is an internet connection if any(!) connection has both INTERNET and VALIDATED.
+        assertTrue(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_twoConnectionsFirstOneWithoutValidated() {
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false andThen true
+        assertTrue(conditions.internetAvailable())
+    }
+
+    @Test
+    fun testInternetAvailable_twoConnectionsFirstOneWithoutNotVpn() {
+        every { accountSettings.getIgnoreVpns() } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_INTERNET) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_NOT_VPN) } returns false andThen true
+        assertTrue(conditions.internetAvailable())
+    }
+    
+
+    @Test
+    fun testWifiAvailable_capabilitiesNull() {
+        every { connectivityManager.getNetworkCapabilities(network1) } returns null
+        every { connectivityManager.getNetworkCapabilities(network2) } returns null
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns false
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable_wifi() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns false
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable_validated() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns false
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertFalse(conditions.wifiAvailable())
+    }
+
+    @Test
+    fun testWifiAvailable_wifiValidated() {
+        every { capabilities.hasTransport(TRANSPORT_WIFI) } returns true
+        every { capabilities.hasCapability(NET_CAPABILITY_VALIDATED) } returns true
+        assertTrue(conditions.wifiAvailable())
+    }
+
+
+    @Test
+    fun testWifiConditionsMet_withoutWifi() {
+        // "Sync only over Wi-Fi" is disabled
+        every { accountSettings.getSyncWifiOnly() } returns false
+
+        assertTrue(factory.create(accountSettings).wifiConditionsMet())
+    }
+
+    @Test
+    fun testWifiConditionsMet_anyWifi_wifiEnabled() {
+        // "Sync only over Wi-Fi" is enabled
+        every { accountSettings.getSyncWifiOnly() } returns true
+
+        // Wi-Fi is available
+        mockkObject(conditions) {
+            // Wi-Fi is available
+            every { conditions.wifiAvailable() } returns true
+
+            // Wi-Fi SSID is correct
+            every { conditions.correctWifiSsid() } returns true
+
+            assertTrue(conditions.wifiConditionsMet())
+        }
+    }
+
+    @Test
+    fun testWifiConditionsMet_anyWifi_wifiDisabled() {
+        // "Sync only over Wi-Fi" is enabled
+        every { accountSettings.getSyncWifiOnly() } returns true
+
+        mockkObject(conditions) {
+            // Wi-Fi is not available
+            every { conditions.wifiAvailable() } returns false
+
+            // Wi-Fi SSID is correct
+            every { conditions.correctWifiSsid() } returns true
+
+            assertFalse(conditions.wifiConditionsMet())
+        }
+    }
+}

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

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

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

@@ -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/kotlin/at/bitfire/davdroid/webdav/CredentialsStoreTest.kt

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

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

@@ -0,0 +1,254 @@
+/*
+ * 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 at.bitfire.davdroid.R
+import at.bitfire.davdroid.db.AppDatabase
+import at.bitfire.davdroid.db.WebDavDocument
+import at.bitfire.davdroid.db.WebDavMount
+import at.bitfire.davdroid.network.HttpClient
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.android.testing.HiltAndroidRule
+import dagger.hilt.android.testing.HiltAndroidTest
+import okhttp3.CookieJar
+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 javax.inject.Inject
+
+@HiltAndroidTest
+class DavDocumentsProviderTest {
+
+    companion object {
+        private const val PATH_WEBDAV_ROOT = "/webdav"
+    }
+
+    @get:Rule
+    val hiltRule = HiltAndroidRule(this)
+
+    @Inject
+    @ApplicationContext
+    lateinit var context: Context
+
+    @Inject
+    lateinit var db: AppDatabase
+
+    @Inject
+    lateinit var logger: java.util.logging.Logger
+
+    @Before
+    fun setUp() {
+        hiltRule.inject()
+    }
+
+
+    private var mockServer =  MockWebServer()
+
+    private lateinit var client: HttpClient
+
+
+    @Before
+    fun mockServerSetup() {
+        // Start mock web server
+        mockServer.dispatcher = TestDispatcher(logger)
+        mockServer.start()
+
+        client = HttpClient.Builder(context).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, logger, 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, logger, 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, logger, 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, logger, cookieStore, CredentialsStore(context), context.getString(R.string.webdav_authority))
+            .queryChildren(parent1)
+        DavDocumentsProvider.DavDocumentsActor(context, db, logger, 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(
+        private val logger: java.util.logging.Logger
+    ): 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.info("Query path: $requestPath")
+                logger.info("Response: $multistatus")
+                return MockResponse()
+                    .setResponseCode(207)
+                    .setBody(multistatus)
+            }
+
+            return MockResponse().setResponseCode(404)
+        }
+
+    }
+
+}

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

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

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

@@ -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,7 @@
 
 <resources>
 
-    <string name="app_name">DavdroidTest</string>
+    <string name="app_name">Davx5Test</string>
+    <string name="account_type_test">at.bitfire.davdroid.test</string>
 
-</resources>
+</resources>

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

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

app/src/androidTest/resources/sample.crt

@@ -1,24 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIEEzCCAfsCAQEwDQYJKoZIhvcNAQEFBQAwRjELMAkGA1UEBhMCQ0ExEzARBgNV
-BAgMClNvbWUtU3RhdGUxEDAOBgNVBAoMB0NBIENlcnQxEDAOBgNVBAMMB0NBIENl
-cnQwHhcNMTgwMTEzMjAyOTI5WhcNMTkwMTEzMjAyOTI5WjBZMQswCQYDVQQGEwJD
-QTETMBEGA1UECAwKU29tZS1TdGF0ZTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0
-cyBQdHkgTHRkMRIwEAYDVQQDDAlVc2VyIENlcnQwggEiMA0GCSqGSIb3DQEBAQUA
-A4IBDwAwggEKAoIBAQDqOyHAeG4psE/f6i/eTfwbhn6j7WaFXxZiSOWwpQZmzRrx
-MrfkABJCk0X7KNgCaJcmBkG9G1Ri4HfKrxvJFswMXknlq+0ulGBk7oDnZM+pihuX
-3D9VCWMMkCqYhLCGADj2zB2mkX4LpcMRi6XoOetKURE/vcIy7rSLAtJM6ZRdftfh
-2ZxnautS1Tyujh9Au3NI/+Of80tT/nA+oBJQeT1fB/ga1OQlZP5kjSaA7IPiIbTz
-QBO+r898MvqK/lwsvOYnWAp7TY03z+vPfCs0zjijZEl9Wrl0hW6o5db5kU1v5bcr
-p87hxFJsGD2HIr2y6kvYfL2hn+h9iANyYdRnUgapAgMBAAEwDQYJKoZIhvcNAQEF
-BQADggIBAHANsiJITedXPyp89lVMEmGY3zKtOqgQ3tqjvjlNt2sdPnj7wmZbmrNd
-sa90S/UwOn8PzEFOVxYy1BPlljlEjtjmc4OHMcm4P4Zv36uawHilmK8V+zT59gCK
-ftB5FP2TLFUFi2X9o8J06d0xJRE77uewN155NV4RmPuP4b/tMmeixoQppHqLqEr5
-lgEUnt3Mh1ctmeFQFJR6lJ01hlB0gdpVHIhzrVLTO3uo8ePLJTmxP6tyKl/HXj9F
-mpVsKb1kriKwbkGczfw99OUZeUVbTwQOR07r0SrG71B7IuDvxIORnhQc1OUjt7ob
-wjdaZauAHxpGBRu+hw9Yqaxchk9Gldy1nEjGyyVCD0FU5taXbl8PhBWEDc4U9tI+
-xVNmPpsSuCsbz3Mjd1YIVRGL99vLrKsQcj+TNM+jJKKRKes3ihl+l/0FwG6UuO7L
-EvjlUg5hOtYi1D7xuYyMjroGBGh7swYMt6w4eCDbcjzcCkaCi0H2pScM/rLBpDjS
-LIoGCvZ1LBdi933/iOj1/8dxGZwY6fEgcyiD2n0xAgYIniLWjEZXOMdIK5FNTNga
-Tswanvp+6Noa4oIu/hl/LXvPMsouaWfSEbRe0Dshi3GpLj3YtEHoN9DHB8bn7jy5
-34By81GT41m5kq3hWP//x9kSHYSADpbovCbKbElU1qSt6vTVR4nq
------END CERTIFICATE-----

app/src/davdroid/java/at/bitfire/davdroid/ui/DefaultAccountsDrawerHandler.kt

@@ -1,68 +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.ui
-
-import android.app.Activity
-import android.content.Intent
-import android.net.Uri
-import android.view.Menu
-import android.view.MenuItem
-import at.bitfire.davdroid.App
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.settings.ISettings
-
-class DefaultAccountsDrawerHandler: IAccountsDrawerHandler {
-
-    companion object {
-        private const val BETA_FEEDBACK_URI = "mailto:support@davdroid.com?subject=${BuildConfig.APPLICATION_ID}/${BuildConfig.VERSION_NAME} feedback (${BuildConfig.VERSION_CODE})"
-    }
-
-
-    override fun onSettingsChanged(settings: ISettings?, menu: Menu) {
-        if (BuildConfig.VERSION_NAME.contains("-beta") || BuildConfig.VERSION_NAME.contains("-rc"))
-            menu.findItem(R.id.nav_beta_feedback).isVisible = true
-    }
-
-    override fun onNavigationItemSelected(activity: Activity, item: MenuItem): Boolean {
-        when (item.itemId) {
-            R.id.nav_about ->
-                activity.startActivity(Intent(activity, AboutActivity::class.java))
-            R.id.nav_app_settings ->
-                activity.startActivity(Intent(activity, AppSettingsActivity::class.java))
-            R.id.nav_beta_feedback -> {
-                val intent = Intent(Intent.ACTION_SENDTO, Uri.parse(BETA_FEEDBACK_URI))
-                if (activity.packageManager.resolveActivity(intent, 0) != null)
-                    activity.startActivity(intent)
-            }
-            R.id.nav_twitter ->
-                activity.startActivity(Intent(Intent.ACTION_VIEW, Uri.parse("https://twitter.com/davdroidapp")))
-            R.id.nav_website ->
-                activity.startActivity(Intent(Intent.ACTION_VIEW, App.homepageUrl(activity)))
-            R.id.nav_manual ->
-                activity.startActivity(Intent(Intent.ACTION_VIEW, App.homepageUrl(activity)
-                        .buildUpon().appendEncodedPath("manual/").build()))
-            R.id.nav_faq ->
-                activity.startActivity(Intent(Intent.ACTION_VIEW, App.homepageUrl(activity)
-                        .buildUpon().appendEncodedPath("faq/").build()))
-            R.id.nav_forums ->
-                activity.startActivity(Intent(Intent.ACTION_VIEW, App.homepageUrl(activity)
-                        .buildUpon().appendEncodedPath("forums/").build()))
-            R.id.nav_donate ->
-                if (BuildConfig.FLAVOR != App.FLAVOR_GOOGLE_PLAY)
-                    activity.startActivity(Intent(Intent.ACTION_VIEW, App.homepageUrl(activity)
-                            .buildUpon().appendEncodedPath("donate/").build()))
-            else ->
-                return false
-        }
-
-        return true
-    }
-
-}

app/src/davdroid/java/at/bitfire/davdroid/ui/setup/DefaultLoginCredentialsFragment.kt

@@ -1,211 +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.ui.setup
-
-import android.net.Uri
-import android.os.Bundle
-import android.os.Handler
-import android.os.Looper
-import android.security.KeyChain
-import android.support.v4.app.Fragment
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import android.widget.CompoundButton
-import at.bitfire.dav4android.Constants
-import at.bitfire.davdroid.R
-import kotlinx.android.synthetic.standard.login_credentials_fragment.view.*
-import java.net.IDN
-import java.net.URI
-import java.net.URISyntaxException
-import java.util.logging.Level
-
-class DefaultLoginCredentialsFragment: Fragment(), CompoundButton.OnCheckedChangeListener {
-
-    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
-        val v = inflater.inflate(R.layout.login_credentials_fragment, container, false)
-
-        if (savedInstanceState == null) {
-            // first call
-            activity?.intent?.let {
-                // we've got initial login data
-                val url = it.getStringExtra(LoginActivity.EXTRA_URL)
-                val username = it.getStringExtra(LoginActivity.EXTRA_USERNAME)
-                val password = it.getStringExtra(LoginActivity.EXTRA_PASSWORD)
-
-                if (url != null) {
-                    v.login_type_urlpwd.isChecked = true
-                    v.urlpwd_base_url.setText(url)
-                    v.urlpwd_user_name.setText(username)
-                    v.urlpwd_password.setText(password)
-                } else {
-                    v.login_type_email.isChecked = true
-                    v.email_address.setText(username)
-                    v.email_password.setText(password)
-                }
-            }
-        }
-
-        v.urlcert_select_cert.setOnClickListener {
-            KeyChain.choosePrivateKeyAlias(activity, { alias ->
-                Handler(Looper.getMainLooper()).post {
-                    v.urlcert_cert_alias.text = alias
-                    v.urlcert_cert_alias.error = null
-                }
-            }, null, null, null, -1, view!!.urlcert_cert_alias.text.toString())
-        }
-
-        v.login.setOnClickListener {
-            validateLoginData()?.let { info ->
-                DetectConfigurationFragment.newInstance(info).show(fragmentManager, null)
-            }
-        }
-
-        // initialize to Login by email
-        onCheckedChanged(v)
-
-        v.login_type_email.setOnCheckedChangeListener(this)
-        v.login_type_urlpwd.setOnCheckedChangeListener(this)
-        v.login_type_urlcert.setOnCheckedChangeListener(this)
-
-        return v
-    }
-
-    override fun onCheckedChanged(buttonView: CompoundButton, isChecked: Boolean) {
-        onCheckedChanged(view!!)
-    }
-
-    private fun onCheckedChanged(v: View) {
-        v.login_type_email_details.visibility = if (v.login_type_email.isChecked) View.VISIBLE else View.GONE
-        v.login_type_urlpwd_details.visibility = if (v.login_type_urlpwd.isChecked) View.VISIBLE else View.GONE
-        v.login_type_urlcert_details.visibility = if (v.login_type_urlcert.isChecked) View.VISIBLE else View.GONE
-    }
-
-    private fun validateLoginData(): LoginInfo? {
-        val view = requireNotNull(view)
-        when {
-            // Login with email address
-            view.login_type_email.isChecked -> {
-                var uri: URI? = null
-                var valid = true
-
-                val email = view.email_address.text.toString()
-                if (!email.matches(Regex(".+@.+"))) {
-                    view.email_address.error = getString(R.string.login_email_address_error)
-                    valid = false
-                } else
-                    try {
-                        uri = URI("mailto", email, null)
-                    } catch (e: URISyntaxException) {
-                        view.email_address.error = e.localizedMessage
-                        valid = false
-                    }
-
-                val password = view.email_password.text.toString()
-                if (password.isEmpty()) {
-                    view.email_password.error = getString(R.string.login_password_required)
-                    valid = false
-                }
-
-                return if (valid && uri != null)
-                    LoginInfo(uri, email, password)
-                else
-                    null
-
-            }
-
-            // Login with URL and user name
-            view.login_type_urlpwd.isChecked -> {
-                var valid = true
-
-                val baseUrl = Uri.parse(view.urlpwd_base_url.text.toString())
-                val uri = validateBaseUrl(baseUrl, false) { message ->
-                    view.urlpwd_base_url.error = message
-                    valid = false
-                }
-
-                val userName = view.urlpwd_user_name.text.toString()
-                if (userName.isBlank()) {
-                    view.urlpwd_user_name.error = getString(R.string.login_user_name_required)
-                    valid = false
-                }
-
-                val password = view.urlpwd_password.text.toString()
-                if (password.isEmpty()) {
-                    view.urlpwd_password.error = getString(R.string.login_password_required)
-                    valid = false
-                }
-
-                return if (valid && uri != null)
-                    LoginInfo(uri, userName, password)
-                else
-                    null
-            }
-
-            // Login with URL and client certificate
-            view.login_type_urlcert.isChecked -> {
-                var valid = true
-
-                val baseUrl = Uri.parse(view.urlcert_base_url.text.toString())
-                val uri = validateBaseUrl(baseUrl, true) { message ->
-                    view.urlcert_base_url.error = message
-                    valid = false
-                }
-
-                val alias = view.urlcert_cert_alias.text.toString()
-                if (alias.isEmpty()) {
-                    view.urlcert_cert_alias.error = ""
-                    valid = false
-                }
-
-                if (valid && uri != null)
-                    return LoginInfo(uri, certificateAlias = alias)
-            }
-        }
-
-        return null
-    }
-
-    private fun validateBaseUrl(baseUrl: Uri, httpsRequired: Boolean, reportError: (String) -> Unit): URI? {
-        var uri: URI? = null
-        val scheme = baseUrl.scheme
-        if ((!httpsRequired && scheme.equals("http", true)) || scheme.equals("https", true)) {
-            var host = baseUrl.host
-            if (host.isNullOrBlank())
-                reportError(getString(R.string.login_url_host_name_required))
-            else
-                try {
-                    host = IDN.toASCII(host)
-                } catch (e: IllegalArgumentException) {
-                    Constants.log.log(Level.WARNING, "Host name not conforming to RFC 3490", e)
-                }
-
-            val path = baseUrl.encodedPath
-            val port = baseUrl.port
-            try {
-                uri = URI(baseUrl.scheme, null, host, port, path, null, null)
-            } catch (e: URISyntaxException) {
-                reportError(e.localizedMessage)
-            }
-        } else
-            reportError(getString(if (httpsRequired)
-                    R.string.login_url_must_be_https
-                else
-                    R.string.login_url_must_be_http_or_https))
-        return uri
-    }
-
-
-    class Factory: ILoginCredentialsFragment {
-
-        override fun getFragment() = DefaultLoginCredentialsFragment()
-
-    }
-
-}

app/src/davdroid/res/layout/login_credentials_fragment.xml

@@ -1,201 +0,0 @@
-<?xml version="1.0" encoding="utf-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
-  -->
-
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-              xmlns:tools="http://schemas.android.com/tools"
-              xmlns:app="http://schemas.android.com/apk/res-auto"
-              android:orientation="vertical"
-              android:layout_width="match_parent"
-              android:layout_height="match_parent">
-
-    <!-- We don't want the keyboard up when the user arrives in this initial screen -->
-    <View android:layout_height="0dp"
-          android:layout_width="0dp"
-          android:focusable="true"
-          android:focusableInTouchMode="true"
-          android:contentDescription="@null"
-          android:importantForAccessibility="no" tools:ignore="UnusedAttribute">
-        <requestFocus/>
-    </View>
-
-    <ScrollView android:layout_width="match_parent"
-                android:layout_height="0dp"
-                android:layout_weight="1"
-                android:layout_margin="@dimen/activity_margin">
-
-        <RadioGroup
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:orientation="vertical"
-            android:animateLayoutChanges="true">
-
-            <RadioButton
-                android:id="@+id/login_type_email"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:checked="true"
-                android:text="@string/login_type_email"
-                android:paddingLeft="14dp" tools:ignore="RtlSymmetry"
-                style="@style/login_type_headline"/>
-            <LinearLayout
-                android:id="@+id/login_type_email_details"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:paddingTop="8dp"
-                android:paddingBottom="16dp"
-                android:orientation="vertical">
-
-                <android.support.design.widget.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content">
-                    <android.support.design.widget.TextInputEditText
-                        android:id="@+id/email_address"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:hint="@string/login_email_address"
-                        android:inputType="textEmailAddress"/>
-                </android.support.design.widget.TextInputLayout>
-                <android.support.design.widget.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    app:passwordToggleEnabled="true">
-                    <android.support.design.widget.TextInputEditText
-                        android:id="@+id/email_password"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:hint="@string/login_password"
-                        android:fontFamily="monospace"
-                        android:inputType="textPassword"/>
-                </android.support.design.widget.TextInputLayout>
-            </LinearLayout>
-
-            <RadioButton
-                android:id="@+id/login_type_urlpwd"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:text="@string/login_type_url"
-                android:layout_marginTop="16dp"
-                android:paddingLeft="14dp" tools:ignore="RtlSymmetry"
-                style="@style/login_type_headline"/>
-            <LinearLayout
-                android:id="@+id/login_type_urlpwd_details"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:paddingTop="8dp"
-                android:paddingBottom="16dp"
-                android:orientation="vertical">
-
-                <android.support.design.widget.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content">
-                    <android.support.design.widget.TextInputEditText
-                        android:id="@+id/urlpwd_base_url"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:hint="@string/login_base_url"
-                        android:inputType="textUri"/>
-                </android.support.design.widget.TextInputLayout>
-                <android.support.design.widget.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content">
-                    <android.support.design.widget.TextInputEditText
-                        android:id="@+id/urlpwd_user_name"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:hint="@string/login_user_name"
-                        android:inputType="textEmailAddress"/>
-                </android.support.design.widget.TextInputLayout>
-                <android.support.design.widget.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content"
-                    app:passwordToggleEnabled="true">
-                    <android.support.design.widget.TextInputEditText
-                        android:id="@+id/urlpwd_password"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:fontFamily="monospace"
-                        android:inputType="textPassword"
-                        android:hint="@string/login_password"/>
-                </android.support.design.widget.TextInputLayout>
-            </LinearLayout>
-
-            <RadioButton
-                android:id="@+id/login_type_urlcert"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:text="@string/login_type_url_certificate"
-                android:layout_marginTop="16dp"
-                android:paddingLeft="14dp" tools:ignore="RtlSymmetry"
-                style="@style/login_type_headline"/>
-            <LinearLayout
-                android:id="@+id/login_type_urlcert_details"
-                android:layout_width="match_parent"
-                android:layout_height="wrap_content"
-                android:paddingTop="8dp"
-                android:paddingBottom="16dp"
-                android:orientation="vertical">
-
-                <android.support.design.widget.TextInputLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content">
-                    <android.support.design.widget.TextInputEditText
-                        android:id="@+id/urlcert_base_url"
-                        android:layout_width="match_parent"
-                        android:layout_height="wrap_content"
-                        android:hint="@string/login_base_url"
-                        android:inputType="textUri"/>
-                </android.support.design.widget.TextInputLayout>
-
-                <LinearLayout
-                    android:layout_width="match_parent"
-                    android:layout_height="wrap_content">
-
-                    <TextView
-                        android:id="@+id/urlcert_cert_alias"
-                        android:layout_width="0dp"
-                        android:layout_weight="1"
-                        android:layout_height="wrap_content"
-                        android:paddingLeft="3dp"
-                        android:paddingRight="3dp"
-                        style="@style/Base.TextAppearance.AppCompat.Body1"
-                        android:textSize="16sp"/>
-
-                    <Button
-                        android:id="@+id/urlcert_select_cert"
-                        android:layout_width="wrap_content"
-                        android:layout_height="wrap_content"
-                        style="@style/Widget.AppCompat.Button.Borderless.Colored"
-                        android:text="@string/login_select_certificate"/>
-
-                </LinearLayout>
-
-            </LinearLayout>
-
-        </RadioGroup>
-    </ScrollView>
-
-    <LinearLayout
-        android:layout_width="match_parent"
-        android:layout_height="wrap_content"
-        style="@style/stepper_nav_bar">
-
-        <Space
-            android:layout_width="0dp"
-            android:layout_weight="1"
-            style="@style/stepper_nav_button"/>
-
-        <Button
-            android:id="@+id/login"
-            android:layout_width="0dp"
-            android:layout_weight="1"
-            android:text="@string/login_login"
-            style="@style/stepper_nav_button"/>
-
-    </LinearLayout>
-</LinearLayout>

app/src/davdroid/res/values-ca/strings.xml

@@ -1,113 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-  <!--common strings-->
-  <string name="app_name">DAVdroid</string>
-  <string name="account_title_address_book">DAVdroid Llibreta d’Adreces</string>
-  <string name="address_books_authority_title">Llibreta d’adreces</string>
-  <string name="help">Ajuda</string>
-  <string name="manage_accounts">Gestiona comptes</string>
-  <string name="please_wait">Esperi si us plau...</string>
-  <string name="send">Enviar</string>
-  <string name="notification_channel_debugging">Depurador</string>
-  <string name="notification_channel_general">Altres missatges importants</string>
-  <string name="notification_channel_sync">Sincronització</string>
-  <string name="notification_channel_sync_io_errors">Xarxa i errors E/S</string>
-  <string name="notification_channel_sync_status">Estat dels misatges</string>
-  <!--startup dialogs-->
-  <string name="startup_battery_optimization_disable">Desactiva per DAVdroid</string>
-  <string name="startup_dont_show_again">No mostrar de nou</string>
-  <string name="startup_donate">Informació de Codi Obert</string>
-  <string name="startup_donate_message">Som feliços de que utilitzis DAVdroid, el qual és programari lliure (GPLv3). Desenvolupar DAVdroid ens porte moltes hores i molta feina, si us plau, considera fer una donació.</string>
-  <string name="startup_donate_now">Mostra la pàgina de donació</string>
-  <string name="startup_donate_later">Més tard</string>
-  <string name="startup_google_play_accounts_removed">Informació d\'errors DRM a Play Store</string>
-  <string name="startup_more_info">Més informació</string>
-  <string name="startup_opentasks_not_installed">OpenTasks no està instal·lada</string>
-  <string name="startup_opentasks_not_installed_install">Instal·lar OpenTasks</string>
-  <!--AboutActivity-->
-  <!--global settings-->
-  <string name="logging_no_external_storage">Emmagatzematge extern no trobat</string>
-  <!--AccountsActivity-->
-  <string name="navigation_drawer_about">Quan a / Llicència</string>
-  <string name="navigation_drawer_beta_feedback">Retroacció de la Beta</string>
-  <string name="navigation_drawer_settings">Paràmetres</string>
-  <string name="navigation_drawer_news_updates">Novetats &amp; Actualitzacions</string>
-  <string name="navigation_drawer_external_links">Enllaços externs</string>
-  <string name="navigation_drawer_website">Pàgina web</string>
-  <string name="navigation_drawer_manual">Manual</string>
-  <string name="navigation_drawer_faq">Preguntes Freqüents</string>
-  <string name="navigation_drawer_forums">Ajuda / Fòrums</string>
-  <string name="navigation_drawer_donate">Fer donació</string>
-  <string name="accounts_global_sync_enable">Activar</string>
-  <!--DavService-->
-  <!--AppSettingsActivity-->
-  <string name="app_settings">Paràmetres</string>
-  <string name="app_settings_user_interface">Interfície d’usuari</string>
-  <string name="app_settings_reset_hints">Reiniciar pistes</string>
-  <string name="app_settings_security">Seguretat</string>
-  <string name="app_settings_debug">Depurador</string>
-  <!--AccountActivity-->
-  <string name="account_synchronize_now">Sincronitza ara</string>
-  <string name="account_synchronizing_now">Sincronitzant ara</string>
-  <string name="account_settings">Paràmetres del compte</string>
-  <string name="account_rename">Canvia el nom al compte</string>
-  <string name="account_rename_rename">Canvia el nom</string>
-  <string name="account_delete">Esborra el compte</string>
-  <string name="account_delete_confirmation_title">Segur que vols esborrar el compte?</string>
-  <string name="account_carddav">CardDAV</string>
-  <string name="account_caldav">CalDAV</string>
-  <string name="account_webcal">Webcal</string>
-  <string name="account_synchronize_this_collection">Sincronitzar aquesta col·lecció</string>
-  <string name="account_read_only">Només de lectura</string>
-  <string name="account_calendar">Calendari</string>
-  <string name="account_task_list">Llista de tasques</string>
-  <string name="account_refresh_address_book_list">Actualitza la llista de llibretes d’adreces</string>
-  <string name="account_create_new_address_book">Crear nova llibreta d’adreces</string>
-  <string name="account_refresh_calendar_list">Actualitzar llista de calendaris</string>
-  <string name="account_create_new_calendar">Crear nou calendari</string>
-  <string name="account_install_icsdroid">Instal·lar ICSdroid</string>
-  <!--AddAccountActivity-->
-  <string name="login_title">Afegir compte</string>
-  <string name="login_type_email">Entra amb una adreça de correu electrònic</string>
-  <string name="login_email_address">Correu electrònic</string>
-  <string name="login_email_address_error">Es requereix un correu electrònic vàlid</string>
-  <string name="login_password">Contrasenya</string>
-  <string name="login_password_required">Es requereix contrasenya</string>
-  <string name="login_type_url">Entra amb una URL i un nom d\'usuari</string>
-  <string name="login_url_must_be_http_or_https">La URL hauria de començar amb http(s)://</string>
-  <string name="login_url_must_be_https">La URL hauria de començar amb https://</string>
-  <string name="login_url_host_name_required">Es requereix nom d\'amfitrió</string>
-  <string name="login_user_name">Nom d\'usuari/a</string>
-  <string name="login_user_name_required">Es requereix nom d\'usuari/a</string>
-  <string name="login_base_url">URL base</string>
-  <string name="login_select_certificate">Selecciona certificat</string>
-  <string name="login_login">Entrada</string>
-  <string name="login_back">Sortir</string>
-  <string name="login_create_account">Crear compte</string>
-  <string name="login_account_name">Nom del compte</string>
-  <!--AccountSettingsActivity-->
-  <string name="settings_title">Paràmetres: %s</string>
-  <string name="settings_authentication">Autentificació</string>
-  <string name="settings_username">Nom d\'usuari/a</string>
-  <string name="settings_enter_username">Escriu el nom d\'usuari/a:</string>
-  <string name="settings_password">Contrasenya</string>
-  <string name="settings_enter_password">Escriu la teva contrasenya</string>
-  <string name="settings_sync">Sincronització</string>
-  <string name="settings_sync_summary_manually">Només a mà</string>
-  <string-array name="settings_sync_interval_names">
-    <item>Només a mà</item>
-    <item>Cada 15 minuts</item>
-    <item>Cada 30 minuts</item>
-    <item>Cada hora</item>
-    <item>Cada 2 hores</item>
-    <item>Cada 4 hores</item>
-    <item>Una vegada al dia</item>
-  </string-array>
-  <string name="settings_sync_wifi_only">Sincronitzar només amb WI-FI</string>
-  <string name="settings_carddav">CardDAV</string>
-  <string name="settings_caldav">CalDAV</string>
-  <!--collection management-->
-  <!--ExceptionInfoFragment-->
-  <!--sync adapters and DebugInfoActivity-->
-  <!--cert4android-->
-</resources>

app/src/davdroid/res/values-cs/strings.xml

@@ -1,179 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-  <!--common strings-->
-  <string name="app_name">DAVdroid</string>
-  <string name="help">Pomoc</string>
-  <string name="manage_accounts">Spravovat účty</string>
-  <string name="please_wait">Chvíli strpení ...</string>
-  <string name="send">Odeslat</string>
-  <!--startup dialogs-->
-  <string name="startup_battery_optimization_disable">Vypnout pro DAVdroid</string>
-  <string name="startup_dont_show_again">Již nezobrazovat</string>
-  <string name="startup_donate">Open Source informace</string>
-  <string name="startup_donate_message">Jsme velice rádi že používáte DAVdroid, software s otevřeným zdrojovým kódem (GPLv3). Vývoj této aplikace je náročný a trval již několik tisíc hodin, velice nás potěší přispějete-li na jeho vývoj.</string>
-  <string name="startup_donate_now">Zobrazit stránku pro obdarování</string>
-  <string name="startup_donate_later">Možná později</string>
-  <string name="startup_google_play_accounts_removed">Informace o chybě DRM Obchodu Play</string>
-  <string name="startup_google_play_accounts_removed_message">Za určitých podmínek může dojít po restartu nebo aktualizaci aplikace DAVdroid k vymazání účtů kvůli chybě DRM Obchodu Play. Pokud jste postiženi touto chybou (ale pouze v tomto případě), nainstalujte prosím z Obchodu Play aplikaci \"DAVdroid JB Workaround\".</string>
-  <string name="startup_opentasks_not_installed">OpenTasks není nainstalován</string>
-  <string name="startup_opentasks_reinstall_davdroid">Po instalaci OpenTasks musíte PŘEINSTALOVAT DAVdroid a přidat znovu své účty (Android chyba).</string>
-  <string name="startup_opentasks_not_installed_install">Nainstalovat OpenTasks</string>
-  <!--AboutActivity-->
-  <string name="about_license_info_no_warranty">Tento program je distribuován BEZ JAKÉKOLIV ZÁRUKY. Je to volně dostupný software a lze jej za určitých podmínek dále distribuovat.</string>
-  <!--global settings-->
-  <string name="logging_davdroid_file_logging">DAVdroid logování do souboru</string>
-  <string name="logging_to_external_storage">Logování do externího úložiště: %s</string>
-  <string name="logging_couldnt_create_file">Nelze vytvořit externí soubor logu: %s</string>
-  <string name="logging_no_external_storage">Externí úložiště nenalezeno</string>
-  <!--AccountsActivity-->
-  <string name="navigation_drawer_open">Otevřít panel navigace</string>
-  <string name="navigation_drawer_close">Zavřít panel navigace</string>
-  <string name="navigation_drawer_subtitle">CalDAV/CardDAV adapter synchronizace</string>
-  <string name="navigation_drawer_about">O aplikaci / Licence</string>
-  <string name="navigation_drawer_settings">Nastavení</string>
-  <string name="navigation_drawer_news_updates">Novinky &amp; aktualizace</string>
-  <string name="navigation_drawer_external_links">Externí odkazy</string>
-  <string name="navigation_drawer_website">Webová stránka</string>
-  <string name="navigation_drawer_faq">FAQ</string>
-  <string name="navigation_drawer_donate">Obdarovat</string>
-  <string name="account_list_empty">Vítejte v aplikaci DAVdroid!\n\nNyní můžete přidat CalDAV/CardDAV účet.</string>
-  <!--DavService-->
-  <string name="dav_service_refresh_failed">Vyhledání služby selhalo</string>
-  <string name="dav_service_refresh_couldnt_refresh">Nelze obnovit seznam sbírky</string>
-  <!--AppSettingsActivity-->
-  <string name="app_settings">Nastavení</string>
-  <string name="app_settings_user_interface">Uživatelské prostředí</string>
-  <string name="app_settings_reset_hints">Resetovat nápovědu</string>
-  <string name="app_settings_reset_hints_summary">Znovu povolí vypnuté texty nápovědy</string>
-  <string name="app_settings_reset_hints_success">Budou zobrazovány všechny texty nápovědy</string>
-  <string name="app_settings_connection">Připojení</string>
-  <string name="app_settings_override_proxy">Přepsat proxy nastavení</string>
-  <string name="app_settings_override_proxy_on">Použít vlastní proxy nastavení</string>
-  <string name="app_settings_override_proxy_off">Použít výchozí systémová proxy nastavení</string>
-  <string name="app_settings_override_proxy_host">HTTP proxy hostname</string>
-  <string name="app_settings_override_proxy_port">HTTP proxy port</string>
-  <string name="app_settings_security">Zabezpečení</string>
-  <string name="app_settings_distrust_system_certs">Nedůvěřovat systémovým certifikátům</string>
-  <string name="app_settings_distrust_system_certs_on">Systémovým a uživatelem přidaným CA nebude důvěřováno</string>
-  <string name="app_settings_distrust_system_certs_off">Systémovým a uživatelem přidaným CA bude důvěřováno (doporučeno)</string>
-  <string name="app_settings_reset_certificates">Resetovat (ne)důvěryhodné certifikáty</string>
-  <string name="app_settings_reset_certificates_summary">Resetovat důvěryhodnost všech vlastních certifikátů</string>
-  <string name="app_settings_reset_certificates_success">Všechny vlastní certifikáty byly resetovány</string>
-  <string name="app_settings_debug">Ladění</string>
-  <string name="app_settings_log_to_external_storage">Logovat do externího souboru</string>
-  <string name="app_settings_log_to_external_storage_on">Logování do externího úložiště (pokud dostupné)</string>
-  <string name="app_settings_log_to_external_storage_off">Logování do externího souboru je vypnuto</string>
-  <string name="app_settings_show_debug_info">Zobrazit ladící informace</string>
-  <string name="app_settings_show_debug_info_details">Zobrazit/sdílet software a detaily konfigurace</string>
-  <!--AccountActivity-->
-  <string name="account_synchronize_now">Synchronizovat nyní</string>
-  <string name="account_synchronizing_now">Probíhá synchronizace</string>
-  <string name="account_settings">Nastavení účtu</string>
-  <string name="account_rename">Přejmenovat účet</string>
-  <string name="account_rename_new_name">Neuložená místní data mohou být vynechána. Po přejmenování je vyžadována nová synchronizace. Nové jméno účtu:</string>
-  <string name="account_rename_rename">Přejmenovat</string>
-  <string name="account_delete">Smazat účet</string>
-  <string name="account_delete_confirmation_title">Opravdu smazat účet?</string>
-  <string name="account_delete_confirmation_text">Všechny místní kopie adresáře, kalendářů a úkolů budou smazány.</string>
-  <string name="account_refresh_address_book_list">Obnovit seznam adresářů</string>
-  <string name="account_create_new_address_book">Vytvořit nový adresář</string>
-  <string name="account_refresh_calendar_list">Obnovit seznam kalendářů</string>
-  <string name="account_create_new_calendar">Vytvořit nový kalendář</string>
-  <!--AddAccountActivity-->
-  <string name="login_title">Přidat účet</string>
-  <string name="login_type_email">Přihlášení s emailovou adresou</string>
-  <string name="login_email_address">Emailová adresa</string>
-  <string name="login_email_address_error">Vyžadován platný email</string>
-  <string name="login_password">Heslo</string>
-  <string name="login_password_required">Vyžadováno heslo</string>
-  <string name="login_type_url">Přihlášení s URL a uživatelským jménem</string>
-  <string name="login_url_must_be_http_or_https">URL musí začínat na http(s)://</string>
-  <string name="login_url_host_name_required">Vyžadováno hostname</string>
-  <string name="login_user_name">Uživatelské jméno</string>
-  <string name="login_user_name_required">Vyžadováno uživatelské jméno</string>
-  <string name="login_base_url">Základní URL</string>
-  <string name="login_login">Login</string>
-  <string name="login_back">Zpět</string>
-  <string name="login_create_account">Vytvořit účet</string>
-  <string name="login_account_name">Jméno účtu</string>
-  <string name="login_account_name_info">Pro jméno účtu použijte svou emailovou adresu, protože Android bude brát jméno účtu jako údaj pro ORGANIZÁTORA vytvořených událostí. Nelze mít dva účty stejného jména.</string>
-  <string name="login_account_contact_group_method">Metoda seskupování kontaktů:</string>
-  <string name="login_account_name_required">Vyžadováno jméno účtu</string>
-  <string name="login_account_not_created">Účet nelze vytvořit</string>
-  <string name="login_configuration_detection">Vyhledání konfigurace</string>
-  <string name="login_querying_server">Chvíli strpení, probíhá dotazování serveru...</string>
-  <string name="login_no_caldav_carddav">Nelze nalézt službu CalDAV nebo CardDAV.</string>
-  <!--AccountSettingsActivity-->
-  <string name="settings_title">Nastavení: %s</string>
-  <string name="settings_authentication">Ověření</string>
-  <string name="settings_username">Uživatelské jméno</string>
-  <string name="settings_enter_username">Zadat uživatelské jméno</string>
-  <string name="settings_password">Heslo</string>
-  <string name="settings_password_summary">Aktualizovat heslo dle svého serveru.</string>
-  <string name="settings_enter_password">Vložit své heslo:</string>
-  <string name="settings_sync">Synchronizace</string>
-  <string name="settings_sync_interval_contacts">Interval synchronizace kontaktů</string>
-  <string name="settings_sync_summary_manually">Pouze manuálně</string>
-  <string name="settings_sync_summary_periodically" tools:ignore="PluralsCandidate">Každých %d minut a ihned při lokálních změnách</string>
-  <string name="settings_sync_interval_calendars">Interval synchronizace kalendáře</string>
-  <string name="settings_sync_interval_tasks">Interval synchronizace úkolů</string>
-  <string name="settings_sync_wifi_only">Synchronizovat pouze přes WiFi</string>
-  <string name="settings_sync_wifi_only_on">Synchronizace omezena na WiFi připojení</string>
-  <string name="settings_sync_wifi_only_off">Druh připojení není brán v potaz</string>
-  <string name="settings_carddav">CardDAV</string>
-  <string name="settings_contact_group_method">Metoda seskupování kontaktů</string>
-  <string-array name="settings_contact_group_method_values">
-    <item>GROUP_VCARDS</item>
-    <item>CATEGORIES</item>
-  </string-array>
-  <string-array name="settings_contact_group_method_entries">
-    <item>Skupiny jsou oddělené soubory VCard</item>
-    <item>Skupiny jsou kategorie na kontakt</item>
-  </string-array>
-  <string name="settings_caldav">CalDAV</string>
-  <string name="settings_sync_time_range_past">Časový limit pro staré události</string>
-  <string name="settings_sync_time_range_past_none">Synchronizovat všechny události</string>
-  <plurals name="settings_sync_time_range_past_days">
-    <item quantity="one">Ignorovat události starší než 1 den</item>
-    <item quantity="few">Ignorovat události starší než %d dny</item>
-    <item quantity="many">Ignorovat události starší než %d dnů</item>
-    <item quantity="other">Ignorovat události starší než %d dnů</item>
-  </plurals>
-  <string name="settings_sync_time_range_past_message">Události z minulosti starší než vyznačený počet dnů budou ignorovány (lze zadat 0). Ponechte prázdné pro synchronizaci všech událostí.</string>
-  <string name="settings_manage_calendar_colors">Spravovat barvy kalendářů</string>
-  <string name="settings_manage_calendar_colors_on">Barvy kalendářů spravuje DAVdroid</string>
-  <string name="settings_manage_calendar_colors_off">Barvy kalendářů nespravuje DAVdroid</string>
-  <!--collection management-->
-  <string name="create_addressbook">Vytvořit adresář</string>
-  <string name="create_addressbook_display_name_hint">Můj adresář</string>
-  <string name="create_calendar">Vytvořit CalDAV sbírku</string>
-  <string name="create_calendar_display_name_hint">Můj kalendář</string>
-  <string name="create_calendar_time_zone">Časová zóna:</string>
-  <string name="create_calendar_type">Typ sbírky:</string>
-  <string name="create_calendar_type_only_events">Kalendář (pouze události)</string>
-  <string name="create_calendar_type_only_tasks">Seznam úkolů (pouze úkoly)</string>
-  <string name="create_calendar_type_events_and_tasks">Kombinovaná (události a úkoly)</string>
-  <string name="create_collection_color">Nastavit barvu sbírky</string>
-  <string name="create_collection_creating">Vytváření sbírky</string>
-  <string name="create_collection_display_name">Zobrazit jméno (nadpis) této sbírky:</string>
-  <string name="create_collection_display_name_required">Nadpis je vyžadován</string>
-  <string name="create_collection_description">Popis (volitelný):</string>
-  <string name="create_collection_home_set">Domácí sbírka:</string>
-  <string name="create_collection_create">Vytvořit</string>
-  <string name="delete_collection">Smazat sbírku</string>
-  <string name="delete_collection_confirm_title">Jste si jisti?</string>
-  <string name="delete_collection_confirm_warning">Tato sbírka (%s) a všechna její data budou odstraněna ze serveru.</string>
-  <string name="delete_collection_deleting_collection">Mazání sbírky</string>
-  <!--ExceptionInfoFragment-->
-  <string name="exception">Došlo k chybě.</string>
-  <string name="exception_httpexception">Došlo k HTTP chybě.</string>
-  <string name="exception_ioexception">Došlo k I/O chybě.</string>
-  <string name="exception_show_details">Zobrazit detaily</string>
-  <!--sync adapters and DebugInfoActivity-->
-  <string name="debug_info_title">Ladící informace</string>
-  <string name="sync_error_permissions">DAVdroid oprávnění</string>
-  <string name="sync_error_permissions_text">Vyžadována dodatečná oprávnění</string>
-  <!--cert4android-->
-  <string name="certificate_notification_connection_security">DAVdroid: Zabezpečení připojení</string>
-  <string name="trust_certificate_unknown_certificate_found">DAVdroid nalezl neznámý certifikát. Chcete mu důvěřovat?</string>
-</resources>

app/src/davdroid/res/values-da/strings.xml

@@ -1,238 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-  <!--common strings-->
-  <string name="app_name">DAVdroid</string>
-  <string name="account_title_address_book">DAVdroid adressebog</string>
-  <string name="address_books_authority_title">Adressebøger</string>
-  <string name="help">Hjælp</string>
-  <string name="manage_accounts">Administrere konti</string>
-  <string name="please_wait">Vent...</string>
-  <string name="send">Send</string>
-  <string name="notification_channel_debugging">Fejlsøgning</string>
-  <string name="notification_channel_general">Andre vigtige beskeder</string>
-  <string name="notification_channel_sync">Synkronisering</string>
-  <string name="notification_channel_sync_errors">Synkroniserings-fejl</string>
-  <string name="notification_channel_sync_io_errors">Netværks- og I/O-fejl</string>
-  <string name="notification_channel_sync_status">Status beskeder</string>
-  <!--startup dialogs-->
-  <string name="startup_battery_optimization_disable">Deaktivere DAVdroid</string>
-  <string name="startup_dont_show_again">Vis ikke igen</string>
-  <string name="startup_donate">Open-Source information</string>
-  <string name="startup_donate_message">Det glæder os, at du bruger DAVdroid, som er open source-software (GPLv3). Det er hårdt arbejde at udvikle DAVdroid og taget tusindvis af arbejdstimer, så overvej at donere til projektet.</string>
-  <string name="startup_donate_now">Vis donationsside</string>
-  <string name="startup_donate_later">Måske senere</string>
-  <string name="startup_google_play_accounts_removed">Play Store DRM fejl information</string>
-  <string name="startup_google_play_accounts_removed_message">Under visse tekniske omstændigheder kan DRM fra Play Store bevirke, at alle DAVdroid-konti er væk efter en genstart eller opgradering af DAVdroid. Hvis du er udsat for dette problem (og ellers ikke), opfordres du til at installere DAVDroid JB Workaround\" fra Play Store.</string>
-  <string name="startup_more_info">Mere information</string>
-  <string name="startup_opentasks_not_installed">OpenTasks ikke installeret</string>
-  <string name="startup_opentasks_not_installed_message">Du er nødt til at have den gratis app OpenTasks for at kunne synkronisere opgaver. (Ikke påkrævet for kontakter/begivenheder.)</string>
-  <string name="startup_opentasks_reinstall_davdroid">Efter at have installeret OpenTasks, vil du være nødt til at GENINSTALLERE DAVdroid og dine konti igen (en fejl i Android).</string>
-  <string name="startup_opentasks_not_installed_install">Installere OpenTasks</string>
-  <!--AboutActivity-->
-  <string name="about_license_info_no_warranty">Dette program leveres ABSOLUT UDEN GARANTI. Det er fri software, og du er velkommen til at videredistribuere det under visse betingelse.</string>
-  <!--global settings-->
-  <string name="logging_davdroid_file_logging">DAVdroid fil-logning</string>
-  <string name="logging_to_external_storage">Logger til eksternt datalager: %s</string>
-  <string name="logging_couldnt_create_file">Kunne ikke oprette ekstern logfil: %s</string>
-  <string name="logging_no_external_storage">Eksternt lager ikke fundet</string>
-  <!--AccountsActivity-->
-  <string name="navigation_drawer_open">Åbn navigationsvindue</string>
-  <string name="navigation_drawer_close">Luk navigationsvindue</string>
-  <string name="navigation_drawer_subtitle">CalDAV/CardDAV synkroniseringsadapter</string>
-  <string name="navigation_drawer_about">Om / licens</string>
-  <string name="navigation_drawer_beta_feedback">Beta tilbagemelding</string>
-  <string name="navigation_drawer_settings">Opsætning</string>
-  <string name="navigation_drawer_news_updates">Nyheder &amp; opdateringer</string>
-  <string name="navigation_drawer_external_links">Eksterne henvisninger</string>
-  <string name="navigation_drawer_website">Netsted</string>
-  <string name="navigation_drawer_manual">Manual</string>
-  <string name="navigation_drawer_faq">OSS</string>
-  <string name="navigation_drawer_forums">Hjælp / fora</string>
-  <string name="navigation_drawer_donate">Donation</string>
-  <string name="account_list_empty">Velkommen til DAVdroid!\n\nDu kan nu tilføje en CalDAV/CardDAV konto.</string>
-  <string name="accounts_global_sync_disabled">Automatisk synkronisering på tværs af systemet er deaktiveret</string>
-  <string name="accounts_global_sync_enable">Aktivere</string>
-  <!--DavService-->
-  <string name="dav_service_refresh_failed">Registrering af tjeneste kunne ikke foretages</string>
-  <string name="dav_service_refresh_couldnt_refresh">Kunne ikke opdatere samling liste</string>
-  <!--AppSettingsActivity-->
-  <string name="app_settings">Indstillinger</string>
-  <string name="app_settings_user_interface">Brugerflade</string>
-  <string name="app_settings_reset_hints">Nulstil vejledende pop op</string>
-  <string name="app_settings_reset_hints_summary">Genaktivere tidligere lukket pop op</string>
-  <string name="app_settings_reset_hints_success">Al vejledning vil blive vist igen</string>
-  <string name="app_settings_connection">Forbindelse</string>
-  <string name="app_settings_override_proxy">Tilsidesæt proxyindstillinger</string>
-  <string name="app_settings_override_proxy_on">Brug brugerdefinerede proxyindstillinger</string>
-  <string name="app_settings_override_proxy_off">Brug systemstandard proxyindstillinger</string>
-  <string name="app_settings_override_proxy_host">HTTP proxy værtsnavn</string>
-  <string name="app_settings_override_proxy_port">HTTP proxy port</string>
-  <string name="app_settings_security">Sikkerhed</string>
-  <string name="app_settings_distrust_system_certs">Stol ikke på systemcertifikater</string>
-  <string name="app_settings_distrust_system_certs_on">System og brugertilføjede CA\'er vil ikke blive betroet</string>
-  <string name="app_settings_distrust_system_certs_off">System og brugertilføjede CA\'er vil blive betroet (anbefalet)</string>
-  <string name="app_settings_reset_certificates">Nulstil (ikke-)betroede certifikater</string>
-  <string name="app_settings_reset_certificates_summary">Nulstiller tilliden til brugerdefinerede certifikater</string>
-  <string name="app_settings_reset_certificates_success">Alle brugerdefinerede certifikater er blevet rydet</string>
-  <string name="app_settings_debug">Fejlsøgning</string>
-  <string name="app_settings_log_to_external_storage">Log til ekstern fil</string>
-  <string name="app_settings_log_to_external_storage_on">Logger til eksternt lager (hvis muligt)</string>
-  <string name="app_settings_log_to_external_storage_off">Ekstern logning deaktiveret</string>
-  <string name="app_settings_show_debug_info">Vis fejlsøgnings information</string>
-  <string name="app_settings_show_debug_info_details">Vis/del software og opsætningsoplysninger</string>
-  <!--AccountActivity-->
-  <string name="account_synchronize_now">Synkronisere</string>
-  <string name="account_synchronizing_now">Synkroniserer</string>
-  <string name="account_settings">Opsætning af konti</string>
-  <string name="account_rename">Omdøbe konto</string>
-  <string name="account_rename_new_name">Lokaldata der ikke er gemt kan gå tabt. Eftersynkronisering er krævet efter omdøbning. Nyt kontonavn: </string>
-  <string name="account_rename_rename">Omdøbe</string>
-  <string name="account_delete">Slette konto</string>
-  <string name="account_delete_confirmation_title">Slette konto?</string>
-  <string name="account_delete_confirmation_text">Alle lokale kopier af addessebøger, kalendere og opgavelister vil blive slettet.</string>
-  <string name="account_carddav">CardDAV</string>
-  <string name="account_caldav">CalDAV</string>
-  <string name="account_webcal">Webcal</string>
-  <string name="account_synchronize_this_collection">synkronisere samling</string>
-  <string name="account_read_only">skrivebeskyttet</string>
-  <string name="account_calendar">kalender</string>
-  <string name="account_task_list">opgave liste</string>
-  <string name="account_refresh_address_book_list">Opdatere adressebogslister</string>
-  <string name="account_create_new_address_book">Oprette ny adressebog</string>
-  <string name="account_refresh_calendar_list">Opdatere kalenderliste</string>
-  <string name="account_create_new_calendar">Oprette ny kalender</string>
-  <string name="account_no_webcal_handler_found">Der er ikke fundet noget program der kan håndtere Webcal.</string>
-  <string name="account_install_icsdroid">Installere ICSdroid</string>
-  <!--AddAccountActivity-->
-  <string name="login_title">Tilføje konto</string>
-  <string name="login_type_email">Logge ind med e-post adresse</string>
-  <string name="login_email_address">E-post adresse</string>
-  <string name="login_email_address_error">Gyldig e-post adresse påkrævet</string>
-  <string name="login_password">Adgangskode</string>
-  <string name="login_password_required">Adgangskode påkrævet</string>
-  <string name="login_type_url">Logge ind med URL og brugernavn</string>
-  <string name="login_url_must_be_http_or_https">URL skal starte med http(s)://</string>
-  <string name="login_url_must_be_https">URL skal starte med https://</string>
-  <string name="login_url_host_name_required">Værtsnavn påkrævet</string>
-  <string name="login_user_name">Brugernavn</string>
-  <string name="login_user_name_required">Brugernavn påkrævet</string>
-  <string name="login_base_url">Basis URL</string>
-  <string name="login_type_url_certificate">Logge ind med URL og klientcertifikat</string>
-  <string name="login_select_certificate">Vælge certifikat</string>
-  <string name="login_login">Logge ind</string>
-  <string name="login_back">Tilbage</string>
-  <string name="login_create_account">Oprette konto</string>
-  <string name="login_account_name">Kontonavn</string>
-  <string name="login_account_name_info">Brug emailadressen som kontonavn, for Android vil bruge kontonavnet til ORGANIZER-feltet for aktiviteter, som du opretter. Du kan ikke have to konti med samme navn.</string>
-  <string name="login_account_contact_group_method">Gruppering af kontakter:</string>
-  <string name="login_account_name_required">Kontonavn påkrævet</string>
-  <string name="login_account_not_created">Konto kunne ikke oprettes</string>
-  <string name="login_configuration_detection">Check konfiguration</string>
-  <string name="login_querying_server">Vent, forespørger serveren...</string>
-  <string name="login_no_caldav_carddav">Kunne ikke finde CalDAV- eller CardDAV-tjeneste.</string>
-  <!--AccountSettingsActivity-->
-  <string name="settings_title">Indstillinger: %s</string>
-  <string name="settings_authentication">Adgangsgodkendelse</string>
-  <string name="settings_username">Brugernavn</string>
-  <string name="settings_enter_username">Indtaste brugernavn:</string>
-  <string name="settings_password">Adgangskode</string>
-  <string name="settings_password_summary">Opdater adgangskoden, så den svarer til din server.</string>
-  <string name="settings_enter_password">Indtast adgangskode:</string>
-  <string name="settings_certificate_alias">Alias for klientcertifikat</string>
-  <string name="settings_sync">Synkronisering</string>
-  <string name="settings_sync_interval_contacts">Synkroniseringsinterval for kontakter</string>
-  <string name="settings_sync_summary_manually">Kun manuelt</string>
-  <string name="settings_sync_summary_periodically" tools:ignore="PluralsCandidate">Hver %d minutter + øjeblikkeligt ved lokale ændringer</string>
-  <string name="settings_sync_interval_calendars">Synkroniseringsinterval for kalender</string>
-  <string name="settings_sync_interval_tasks">Synkroniseringsinterval for opgaver</string>
-  <string-array name="settings_sync_interval_names">
-    <item>Kun manuelt</item>
-    <item>Hvert 15. minut</item>
-    <item>Hver halve time</item>
-    <item>Hver time</item>
-    <item>Hver 2. time</item>
-    <item>Hver 4. time</item>
-    <item>En gang om dagen</item>
-  </string-array>
-  <string name="settings_sync_wifi_only">Synkroniser kun over WiFi</string>
-  <string name="settings_sync_wifi_only_on">Synkronisering er begrænset til WiFi-forbindelser</string>
-  <string name="settings_sync_wifi_only_off">Forbindelsestypen har ingen betydning</string>
-  <string name="settings_sync_wifi_only_ssids">WiFi SSID-begrænsning</string>
-  <string name="settings_sync_wifi_only_ssids_on">Synkroniserer kun over %s</string>
-  <string name="settings_sync_wifi_only_ssids_off">Alle WiFi-forbindelser vil blive anvendt</string>
-  <string name="settings_sync_wifi_only_ssids_message">Kommaseparerede navne (SSID\'er) over tilladte WiFi-netværk (efterlad blank for at bruge alle)</string>
-  <string name="settings_carddav">CardDAV</string>
-  <string name="settings_contact_group_method">Gruppering af kontakter</string>
-  <string-array name="settings_contact_group_method_values">
-    <item>GROUP_VCARDS</item>
-    <item>CATEGORIES</item>
-  </string-array>
-  <string-array name="settings_contact_group_method_entries">
-    <item>Grupper er særskilte VCards</item>
-    <item>Grupper er kategorier pr. kontakt</item>
-  </string-array>
-  <string name="settings_contact_group_method_change">Skift grupperingsmetode</string>
-  <string name="settings_contact_group_method_change_reload_contacts">Dette kræver, at alle kontakter genindlæses. Lokale ændringer, der ikke er gemt, vil blive slettet.</string>
-  <string name="settings_caldav">CalDAV</string>
-  <string name="settings_sync_time_range_past">Tidsafgrænsning for tidligere begivenheder</string>
-  <string name="settings_sync_time_range_past_none">Alle begivenheder vil blive synkroniseret</string>
-  <plurals name="settings_sync_time_range_past_days">
-    <item quantity="one">Begivenheder ældre end en dag vil blive ignoreret</item>
-    <item quantity="other">Begivenheder, der er mere end %d dage gamle, vil blive ignoreret</item>
-  </plurals>
-  <string name="settings_sync_time_range_past_message">Begivenheder, som er mere end dette antal dage gamle vil blive ignoreret (kan også være 0). Hvis feltet ikke er udfyldt, vil alle begivenheder blive synkroniseret.</string>
-  <string name="settings_manage_calendar_colors">Administrer farver for kalender</string>
-  <string name="settings_manage_calendar_colors_on">Kalenderfarver administreres af DAVdroid</string>
-  <string name="settings_manage_calendar_colors_off">Kalenderfarver sættes ikke fra DAVdroid</string>
-  <string name="settings_event_colors">Farver for begivenheder</string>
-  <string name="settings_event_colors_on">Synkroniser farver for begivenheder</string>
-  <string name="settings_event_colors_off">Synkroniser ikke farver for begivenheder</string>
-  <string name="settings_event_colors_off_confirm">Fjernes farver for begivenheder kan det fjerne farver, der allerede er synkroniseret.</string>
-  <!--collection management-->
-  <string name="create_addressbook">Opret adressebog</string>
-  <string name="create_addressbook_display_name_hint">Min adressebog</string>
-  <string name="create_calendar">Opret CalDAV-sæt</string>
-  <string name="create_calendar_display_name_hint">Min kalender</string>
-  <string name="create_calendar_time_zone">Tidszone:</string>
-  <string name="create_calendar_type">Type af sæt:</string>
-  <string name="create_calendar_type_only_events">Kalender (kun begivenheder)</string>
-  <string name="create_calendar_type_only_tasks">Opgaveliste (kun opgaver)</string>
-  <string name="create_calendar_type_events_and_tasks">Kombineret (begivenheder og opgaver)</string>
-  <string name="create_collection_color">Sæt en farve på sættet</string>
-  <string name="create_collection_creating">Opretter sæt</string>
-  <string name="create_collection_display_name">Navn (titel) på dette sæt:</string>
-  <string name="create_collection_display_name_required">En titel er påkrævet</string>
-  <string name="create_collection_description">Beskrivelse (valgfri):</string>
-  <string name="create_collection_home_set">Home set:</string>
-  <string name="create_collection_create">Opret</string>
-  <string name="delete_collection">Slet sæt</string>
-  <string name="delete_collection_confirm_title">Er du sikker?</string>
-  <string name="delete_collection_confirm_warning">DAV-sættet (%s) og dets data vil blive fjernet fra serveren.</string>
-  <string name="delete_collection_deleting_collection">Sletter CalDAV-sæt</string>
-  <string name="collection_force_read_only">Sæt skrivebeskyttet</string>
-  <!--ExceptionInfoFragment-->
-  <string name="exception">Der er opstået en fejl.</string>
-  <string name="exception_httpexception">Der er opstået en HTTP-fejl.</string>
-  <string name="exception_ioexception">Der er opstået en I/O-fejl.</string>
-  <string name="exception_show_details">Vis detaljer</string>
-  <!--sync adapters and DebugInfoActivity-->
-  <string name="debug_info_title">Debug-info</string>
-  <string name="sync_contacts_read_only_address_book">Skrivebeskyttet adressebog</string>
-  <plurals name="sync_contacts_local_contact_changes_discarded">
-    <item quantity="one">Lokal ændring slettet</item>
-    <item quantity="other">%d lokale ændringer slettet</item>
-  </plurals>
-  <string name="sync_error_permissions">DAVdroid-rettigheder</string>
-  <string name="sync_error_permissions_text">Yderligere adgang påkrævet</string>
-  <string name="sync_error_opentasks_too_old">OpenTasks-version for gammel</string>
-  <string name="sync_error_opentasks_required_version">Påkrævet version: %1$s (aktuelt%2$s)</string>
-  <string name="sync_error_authentication_failed">Login mislykkedes (check loginoplysninger)</string>
-  <string name="sync_error_io">Netværks- eller I/O-fejl - %s</string>
-  <string name="sync_error_http_dav">HTTP-serverfejl - %s</string>
-  <string name="sync_error_local_storage">Lokal lagringsfejl - %s</string>
-  <string name="sync_error_retry">Gentag</string>
-  <string name="sync_error_view_item">Vis element</string>
-  <!--cert4android-->
-  <string name="certificate_notification_connection_security">DAVdroid: Forbindelsessikkerhed</string>
-  <string name="trust_certificate_unknown_certificate_found">DAVdroid er stødt på et ukendt certifikat. Vil du stole på det? </string>
-</resources>

app/src/davdroid/res/values-es/strings.xml

@@ -1,229 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-  <!--common strings-->
-  <string name="app_name">DAVdroid</string>
-  <string name="account_title_address_book">Agenda DAVdroid</string>
-  <string name="address_books_authority_title">Agendas</string>
-  <string name="help">Ayuda</string>
-  <string name="manage_accounts">Administrar cuentas</string>
-  <string name="please_wait">Por favor, espere...</string>
-  <string name="send">Enviar</string>
-  <string name="notification_channel_debugging">Depuración</string>
-  <string name="notification_channel_general">Otros mensajes importantes</string>
-  <string name="notification_channel_sync">Sincronización</string>
-  <string name="notification_channel_sync_errors">Errores de sincronización</string>
-  <string name="notification_channel_sync_io_errors">Errores de Red y E/S</string>
-  <string name="notification_channel_sync_status">Mensajes de estado</string>
-  <!--startup dialogs-->
-  <string name="startup_battery_optimization_disable">Apagar para DAVdroid</string>
-  <string name="startup_dont_show_again">No mostrar de nuevo</string>
-  <string name="startup_donate">Información de código abierto</string>
-  <string name="startup_donate_message">Nos alegra que uses DAVdroid, que es software de código abierto (GPLv3). Debido al duro trabajo que supone el desarrollo de DAVdroid y los cientos de horas de trabajo, por favor, considera hacer una donación.</string>
-  <string name="startup_donate_now">Mostrar página de donación</string>
-  <string name="startup_donate_later">Quizás luego</string>
-  <string name="startup_google_play_accounts_removed">Información de error de DRM de Play Store</string>
-  <string name="startup_google_play_accounts_removed_message">Bajo ciertas condiciones, el DRM de Play Store puede causar que todas las cuentas de DAVdroid se desconfiguren tras un reinicio o una actualización de DAVdroid. Si esto le afecta (y sólo en ese caso), por favor, instale \"DAVdroid JB Workaround\" desde Play Store.</string>
-  <string name="startup_more_info">Más información</string>
-  <string name="startup_opentasks_not_installed">OpenTasks no está instalado</string>
-  <string name="startup_opentasks_not_installed_message">Para sincronizar tareas, la aplicación libre OpenTasks es requerida. (No necesaria para contactos/eventos.)</string>
-  <string name="startup_opentasks_reinstall_davdroid">Tras instalar OpenTasks, tendrás que re-instalar DAVdroid y añadir tus cuentas de nuevo (por un error de Android).</string>
-  <string name="startup_opentasks_not_installed_install">Instalar OpenTasks</string>
-  <!--AboutActivity-->
-  <string name="about_license_info_no_warranty">Este programa viene sin NINGÚN TIPO DE GARANTÍA. Es software libre, y cualquier contribución es bienvenida y redistribuida bajo ciertas condiciones.</string>
-  <!--global settings-->
-  <string name="logging_davdroid_file_logging">Archivo de registro de DAVdroid</string>
-  <string name="logging_to_external_storage">Registrar en almacenamiento externo: %s</string>
-  <string name="logging_couldnt_create_file">No se puede crear el archivo de registro externo: %s</string>
-  <string name="logging_no_external_storage">Almacenamiento externo no encontrado</string>
-  <!--AccountsActivity-->
-  <string name="navigation_drawer_open">Abrir panel de navegación</string>
-  <string name="navigation_drawer_close">Cerrar panel de navegación</string>
-  <string name="navigation_drawer_subtitle">Adaptador de sincronización CalDAV/CardDAV</string>
-  <string name="navigation_drawer_about">Acerca de / Licencia</string>
-  <string name="navigation_drawer_beta_feedback">Retroalimentación Beta</string>
-  <string name="navigation_drawer_settings">Ajustes</string>
-  <string name="navigation_drawer_news_updates">Noticias y actualizaciones</string>
-  <string name="navigation_drawer_external_links">Enlaces externos</string>
-  <string name="navigation_drawer_website">Sitio web</string>
-  <string name="navigation_drawer_manual">Manual</string>
-  <string name="navigation_drawer_faq">Preguntas frequentes</string>
-  <string name="navigation_drawer_forums">Ayuda / Foros</string>
-  <string name="navigation_drawer_donate">Donar</string>
-  <string name="account_list_empty">Bienvenido a DAVdroid!\n\nAhora puedes añadir una cuenta CalDAV/CardDAV.</string>
-  <string name="accounts_global_sync_disabled">Sincronización automática del sistema completo está deshabilitada</string>
-  <string name="accounts_global_sync_enable">Activar</string>
-  <!--DavService-->
-  <string name="dav_service_refresh_failed">Falló la detección del servicio</string>
-  <string name="dav_service_refresh_couldnt_refresh">No se pudo refrescar lista de colección</string>
-  <!--AppSettingsActivity-->
-  <string name="app_settings">Ajustes</string>
-  <string name="app_settings_user_interface">Interfaz de usuario</string>
-  <string name="app_settings_reset_hints">Restablecer advertencias</string>
-  <string name="app_settings_reset_hints_summary">Habilita las advertencias que han sido rechazadas con anterioridad</string>
-  <string name="app_settings_reset_hints_success">Todas las advertencias se mostrarán nuevamente</string>
-  <string name="app_settings_connection">Conexión</string>
-  <string name="app_settings_override_proxy">Anular ajustes del proxy</string>
-  <string name="app_settings_override_proxy_on">Usar ajustes personalizados del proxy</string>
-  <string name="app_settings_override_proxy_off">Usar ajustes del proxy predefinidos por el sistema</string>
-  <string name="app_settings_override_proxy_host">Nombre del host del proxy HTTP</string>
-  <string name="app_settings_override_proxy_port">Puerto del proxy HTTP</string>
-  <string name="app_settings_security">Seguridad</string>
-  <string name="app_settings_distrust_system_certs">Invalidar los certificados del sistema</string>
-  <string name="app_settings_distrust_system_certs_on">Los CA del sistema y los añadidos por el usuario no serán válidos</string>
-  <string name="app_settings_distrust_system_certs_off">Los CA del sistema y los añadidos por el usuario serán usados y de confianza (recomendado)</string>
-  <string name="app_settings_reset_certificates">Reiniciar certificados (in)validados</string>
-  <string name="app_settings_reset_certificates_summary">Reinicia la validez de todos los certificados particulares</string>
-  <string name="app_settings_reset_certificates_success">Todos los certificados particulares han sido limpiados</string>
-  <string name="app_settings_debug">Depuración</string>
-  <string name="app_settings_log_to_external_storage">Registrar en fichero externo</string>
-  <string name="app_settings_log_to_external_storage_on">Registro en almacenamiento externo (si está disponible)</string>
-  <string name="app_settings_log_to_external_storage_off">El archivo de registro externo está deshabilitado</string>
-  <string name="app_settings_show_debug_info">Mostrar la información de depuración</string>
-  <string name="app_settings_show_debug_info_details">Ver/compartir detalles de software y configuración</string>
-  <!--AccountActivity-->
-  <string name="account_synchronize_now">Sincronizar ahora</string>
-  <string name="account_synchronizing_now">Sincronizando...</string>
-  <string name="account_settings">Ajustes de cuenta</string>
-  <string name="account_rename">Renombrar cuenta</string>
-  <string name="account_rename_new_name">Información local no guardada puede ser desechada. Se requiere resincronizar después de renombrar. Nuevo nombre de cuenta:</string>
-  <string name="account_rename_rename">Renombrar</string>
-  <string name="account_delete">Eliminar cuenta</string>
-  <string name="account_delete_confirmation_title">¿Seguro que deseas eliminar la cuenta?</string>
-  <string name="account_delete_confirmation_text">Todas las copias locales de tus contactos, calendarios y tareas serán eliminadas.</string>
-  <string name="account_carddav">CardDAV</string>
-  <string name="account_caldav">CalDAV</string>
-  <string name="account_webcal">Webcal</string>
-  <string name="account_synchronize_this_collection">sincronizar ésta colección</string>
-  <string name="account_read_only">solo lectura</string>
-  <string name="account_calendar">calendario</string>
-  <string name="account_task_list">lista de tareas</string>
-  <string name="account_refresh_address_book_list">Refrescar contactos</string>
-  <string name="account_create_new_address_book">Crear nueva agenda</string>
-  <string name="account_refresh_calendar_list">Refrescar calendario</string>
-  <string name="account_create_new_calendar">Crear nuevo calendario</string>
-  <string name="account_no_webcal_handler_found">No se encontró aplicación para administrar Webcal</string>
-  <string name="account_install_icsdroid">Instale ICSdroid</string>
-  <!--AddAccountActivity-->
-  <string name="login_title">Añadir cuenta</string>
-  <string name="login_type_email">Acceder con cuenta de correo</string>
-  <string name="login_email_address">Dirección de correo</string>
-  <string name="login_email_address_error">Se requiere una dirección de correo válida</string>
-  <string name="login_password">Contraseña</string>
-  <string name="login_password_required">Contraseña requerida</string>
-  <string name="login_type_url">Acceder con URL y nombre de usuario</string>
-  <string name="login_url_must_be_http_or_https">La URL debe comenzar con http(s)://</string>
-  <string name="login_url_must_be_https">El URL debe comenzar con https://</string>
-  <string name="login_url_host_name_required">Nombre de servidor requerido</string>
-  <string name="login_user_name">Nombre de usuario</string>
-  <string name="login_user_name_required">Nombre de usuario requerido</string>
-  <string name="login_base_url">URL base</string>
-  <string name="login_type_url_certificate">Iniciar sesión con URL y certificado del cliente</string>
-  <string name="login_select_certificate">Seleccionar un certificado</string>
-  <string name="login_login">Registrar</string>
-  <string name="login_back">Volver</string>
-  <string name="login_create_account">Crear cuenta</string>
-  <string name="login_account_name">Nombre de cuenta</string>
-  <string name="login_account_name_info">Usa tu dirección de correo como nombre de cuenta puesto que Android usará el nombre de la cuenta como campo de \"organizador\" en los eventos que cree. No puedes tener dos cuentas con el mismo nombre.</string>
-  <string name="login_account_contact_group_method">Método de contacto de grupo:</string>
-  <string name="login_account_name_required">Nombre de cuenta requerido</string>
-  <string name="login_account_not_created">La cuenta no pudo ser creada</string>
-  <string name="login_configuration_detection">Detectar configuración</string>
-  <string name="login_querying_server">Por favor espera, consultando al servidor...</string>
-  <string name="login_no_caldav_carddav">No se pudo encontrar el servicio CalDAV o CardDAV.</string>
-  <!--AccountSettingsActivity-->
-  <string name="settings_title">Ajustes: %s</string>
-  <string name="settings_authentication">Autenticación</string>
-  <string name="settings_username">Nombre de usuario</string>
-  <string name="settings_enter_username">Introduce tu nombre de usuario:</string>
-  <string name="settings_password">Contraseña</string>
-  <string name="settings_password_summary">Actualiza la contraseña de acuerdo a tu servidor.</string>
-  <string name="settings_enter_password">Introduce tu contraseña:</string>
-  <string name="settings_certificate_alias">Alias del certificado cliente</string>
-  <string name="settings_sync">Sincronización</string>
-  <string name="settings_sync_interval_contacts">Intervalo de sincronización de contactos</string>
-  <string name="settings_sync_summary_manually">Solo manualmente</string>
-  <string name="settings_sync_summary_periodically" tools:ignore="PluralsCandidate">Cada %d minutos + inmediatamente con cambios locales</string>
-  <string name="settings_sync_interval_calendars">Intervalo de sincronización de calendarios</string>
-  <string name="settings_sync_interval_tasks">Intervalo de sincronizacion de Tasks</string>
-  <string name="settings_sync_wifi_only">Sincronizar sólo sobre WiFi</string>
-  <string name="settings_sync_wifi_only_on">La sincronización está restringida a conexiones WiFi</string>
-  <string name="settings_sync_wifi_only_off">Tipo de conexión no tenido en cuenta</string>
-  <string name="settings_sync_wifi_only_ssids">Restricción WiFi SSID</string>
-  <string name="settings_sync_wifi_only_ssids_on">Solo se sincronizará a través de %s</string>
-  <string name="settings_sync_wifi_only_ssids_off">Todas las conexiones WiFi serán usadas</string>
-  <string name="settings_sync_wifi_only_ssids_message">Nombres separados por comas (SSIDs) de redes WiFi permitidas (deje vacío para todas)</string>
-  <string name="settings_carddav">CardDAV</string>
-  <string name="settings_contact_group_method">Método de contacto de grupo</string>
-  <string-array name="settings_contact_group_method_values">
-    <item>GROUP_VCARDS</item>
-    <item>CATEGORIES</item>
-  </string-array>
-  <string-array name="settings_contact_group_method_entries">
-    <item>Los groups tienen VCards separadas</item>
-    <item>Los groups tienen una categoría por contacto</item>
-  </string-array>
-  <string name="settings_contact_group_method_change">Cambie método de grupo</string>
-  <string name="settings_contact_group_method_change_reload_contacts">Esto requiere recargar todos los contactos. Cambios locales sin guardar serán descartados.</string>
-  <string name="settings_caldav">CalDAV</string>
-  <string name="settings_sync_time_range_past">Límite de tiempo de eventos pasados</string>
-  <string name="settings_sync_time_range_past_none">Todos los eventos serán sincronizados</string>
-  <plurals name="settings_sync_time_range_past_days">
-    <item quantity="one">Los eventos anteriores a un día serán ignorados</item>
-    <item quantity="other">Los eventos anteriores a %d días serán ignorados</item>
-  </plurals>
-  <string name="settings_sync_time_range_past_message">Los eventos anteriores a este número de días serán ignorados (puede ser 0). Deja en blanco el campo para sincronizar todos los eventos.</string>
-  <string name="settings_manage_calendar_colors">Colores de calendario</string>
-  <string name="settings_manage_calendar_colors_on">Los colores de los calendarios son administrados por DAVdroid</string>
-  <string name="settings_manage_calendar_colors_off">Los colores de los calendarios no son establecidos por DAVdroid</string>
-  <string name="settings_event_colors">Soporte de colores en eventos</string>
-  <string name="settings_event_colors_on">Sincronizar colores de eventos</string>
-  <string name="settings_event_colors_off">No sincronizar colores de eventos</string>
-  <string name="settings_event_colors_off_confirm">Desactivar colores de eventos podría remover colores de eventos ya sincronizados.</string>
-  <!--collection management-->
-  <string name="create_addressbook">Crear nueva agenda</string>
-  <string name="create_addressbook_display_name_hint">Agendas</string>
-  <string name="create_calendar">Crear colección CalDAV</string>
-  <string name="create_calendar_display_name_hint">Mi calendario</string>
-  <string name="create_calendar_time_zone">Zona horaria:</string>
-  <string name="create_calendar_type">Tipo de colección:</string>
-  <string name="create_calendar_type_only_events">Calendario (sólo eventos)</string>
-  <string name="create_calendar_type_only_tasks">Lista de tareas (sólo tareas)</string>
-  <string name="create_calendar_type_events_and_tasks">Combinado (eventos y tareas)</string>
-  <string name="create_collection_color">Establecer un color</string>
-  <string name="create_collection_creating">Crear colección</string>
-  <string name="create_collection_display_name">Nombre mostrado (título):</string>
-  <string name="create_collection_display_name_required">Título requerido</string>
-  <string name="create_collection_description">Descripción (opcional):</string>
-  <string name="create_collection_home_set">Establecer localización:</string>
-  <string name="create_collection_create">Crear</string>
-  <string name="delete_collection">Eliminar colección</string>
-  <string name="delete_collection_confirm_title">¿Estás seguro/a?</string>
-  <string name="delete_collection_confirm_warning">Esta colección (%s) y toda su información será eliminada del servidor.</string>
-  <string name="delete_collection_deleting_collection">Eliminando colección</string>
-  <string name="collection_force_read_only">Forzar solo-lectura</string>
-  <!--ExceptionInfoFragment-->
-  <string name="exception">Ocurrió un error.</string>
-  <string name="exception_httpexception">Ha ocurrido un error HTTP.</string>
-  <string name="exception_ioexception">Ha ocurrido un error I/O.</string>
-  <string name="exception_show_details">Mostrar detalles</string>
-  <!--sync adapters and DebugInfoActivity-->
-  <string name="debug_info_title">Información de depuración</string>
-  <string name="sync_contacts_read_only_address_book">Libro de direcciones solo-lectura</string>
-  <plurals name="sync_contacts_local_contact_changes_discarded">
-    <item quantity="one">Cambio de contacto local descartado</item>
-    <item quantity="other">%d cambios de contactos locales descartados</item>
-  </plurals>
-  <string name="sync_error_permissions">Permisos de DAVdroid</string>
-  <string name="sync_error_permissions_text">Permisos adicionales requeridos</string>
-  <string name="sync_error_opentasks_too_old">OpenTasks muy viejo</string>
-  <string name="sync_error_opentasks_required_version">Versión requerida: %1$s (actual %2$s)</string>
-  <string name="sync_error_authentication_failed">Falló la autenticación (revise credenciales de inicio de sesión)</string>
-  <string name="sync_error_io">Error de red o E/S – %s</string>
-  <string name="sync_error_http_dav">Error de servidor – %s</string>
-  <string name="sync_error_local_storage">Error de almacenamiento local – %s</string>
-  <string name="sync_error_retry">Reintentar</string>
-  <string name="sync_error_view_item">Ver item</string>
-  <!--cert4android-->
-  <string name="certificate_notification_connection_security">DAVdroid: Seguridad de conexión</string>
-  <string name="trust_certificate_unknown_certificate_found">DAVdroid ha encontrado un certificado desconocido. ¿Quieres que sea válido?</string>
-</resources>

app/src/davdroid/res/values-fr/strings.xml

@@ -1,206 +0,0 @@
-<?xml version='1.0' encoding='UTF-8'?>
-<resources xmlns:tools="http://schemas.android.com/tools">
-  <!--common strings-->
-  <string name="app_name">DAVdroid</string>
-  <string name="account_title_address_book">Carnet d\'adresses DAVdroid</string>
-  <string name="address_books_authority_title">Carnets d\'adresses</string>
-  <string name="help">Aide</string>
-  <string name="manage_accounts">Gestion des comptes</string>
-  <string name="please_wait">patientez ...</string>
-  <string name="send">Envoyer</string>
-  <!--startup dialogs-->
-  <string name="startup_battery_optimization_disable">Désactiver pour DAVdroid</string>
-  <string name="startup_dont_show_again">Ne plus afficher</string>
-  <string name="startup_donate">Open-Source Information</string>
-  <string name="startup_donate_message">Nous sommes heureux que vous utilisez DAVdroid, qui est un logiciel open-source (GPLv3). Parce que développer DAVdroid est un travail difficile et nous a pris de nombreuses heures, s\'il vous plaît envisager de faire un don.</string>
-  <string name="startup_donate_now">Faire un don</string>
-  <string name="startup_donate_later">Plus tard</string>
-  <string name="startup_google_play_accounts_removed">Erreur information Play Store DRM</string>
-  <string name="startup_google_play_accounts_removed_message">Dans certaines conditions, Play Store DRM peut provoquer la disparition de tous les comptes DAVdroid après un redémarrage ou après la mise à niveau de DAVdroid. Si vous êtes concerné par ce problème (et seulement alors), s\'il vous plaît installer \"DAVdroid JB Solution\" du Play Store.</string>
-  <string name="startup_opentasks_not_installed">L\'application OpenTasks n\'est pas installée</string>
-  <string name="startup_opentasks_reinstall_davdroid">Après l\'installation OpenTasks, vous devez RE-INSTALLER DAVdroid et ajoutez vos comptes à nouveau (bug Android).</string>
-  <string name="startup_opentasks_not_installed_install">Installer OpenTasks</string>
-  <!--AboutActivity-->
-  <string name="about_license_info_no_warranty">Ce programme est fourni sans AUCUNE GARANTIE. C\'est un logiciel libre, et vous êtes en droit de le redistribuer sous certaines conditions.</string>
-  <!--global settings-->
-  <string name="logging_davdroid_file_logging">DAVdroid fichier de journalisation</string>
-  <string name="logging_to_external_storage">Se connecter au stockage externe: %s</string>
-  <string name="logging_couldnt_create_file">Impossible de créer le fichier journal externe: %s</string>
-  <string name="logging_no_external_storage">Stockage externe introuvable</string>
-  <!--AccountsActivity-->
-  <string name="navigation_drawer_open">Ouvrir le tiroir de navigation</string>
-  <string name="navigation_drawer_close">Fermer le tiroir de navigation</string>
-  <string name="navigation_drawer_subtitle">Adaptateur de synchronisation CalDAV/CardDAV</string>
-  <string name="navigation_drawer_about">A propos / Licence</string>
-  <string name="navigation_drawer_settings">Paramètres</string>
-  <string name="navigation_drawer_news_updates">Actualités &amp; mises à jour</string>
-  <string name="navigation_drawer_external_links">Liens externes</string>
-  <string name="navigation_drawer_website">Site Web</string>
-  <string name="navigation_drawer_faq">Foire aux questions</string>
-  <string name="navigation_drawer_forums">Aide/Forum</string>
-  <string name="navigation_drawer_donate">Faire un don</string>
-  <string name="account_list_empty">Bienvenue sur DAVdroid!\n\nVous pouvez maintenant ajouter un compte CalDAV ou CardDAV.</string>
-  <string name="accounts_global_sync_disabled">La synchronisation automatique globale est désactivée</string>
-  <string name="accounts_global_sync_enable">Activer</string>
-  <!--DavService-->
-  <string name="dav_service_refresh_failed">La détection du service a échoué</string>
-  <string name="dav_service_refresh_couldnt_refresh">Impossible d\'actualiser la liste de collection</string>
-  <!--AppSettingsActivity-->
-  <string name="app_settings">Paramètres</string>
-  <string name="app_settings_user_interface">Interface utilisateur</string>
-  <string name="app_settings_reset_hints">Réinitialiser les astuces</string>
-  <string name="app_settings_reset_hints_summary">Réactiver les astuces qui ont été vues précédemment</string>
-  <string name="app_settings_reset_hints_success">Toutes les astuces seront affichés à nouveau</string>
-  <string name="app_settings_connection">Connexion</string>
-  <string name="app_settings_override_proxy">Ignorer les paramètres proxy</string>
-  <string name="app_settings_override_proxy_on">Utiliser des paramètres proxy personnalisés</string>
-  <string name="app_settings_override_proxy_off">Utiliser les paramètres proxy du système</string>
-  <string name="app_settings_override_proxy_host">Nom de l\'hôte du proxy HTTP</string>
-  <string name="app_settings_override_proxy_port">Port du proxy HTTP</string>
-  <string name="app_settings_security">Sécurité</string>
-  <string name="app_settings_distrust_system_certs">Révoquer les certificats du système</string>
-  <string name="app_settings_distrust_system_certs_on">Les certificats du système et ceux ajoutés par l\'utilisateur ne seront pas  dignes de confiance</string>
-  <string name="app_settings_distrust_system_certs_off">Les certificats du système et ceux ajoutés par l\'utilisateur seront dignes de confiance (recommandé)</string>
-  <string name="app_settings_reset_certificates">Réinitialiser les certificats de (non)confiance</string>
-  <string name="app_settings_reset_certificates_summary">Réinitialiser la confiance de tous les certificats personnalisés</string>
-  <string name="app_settings_reset_certificates_success">Tous les certificats personnalisés ont été effacés</string>
-  <string name="app_settings_debug">Débogage</string>
-  <string name="app_settings_log_to_external_storage">Journaliser dans un fichier externe</string>
-  <string name="app_settings_log_to_external_storage_on">Journaliser sur le stockage externe (si disponible)</string>
-  <string name="app_settings_log_to_external_storage_off">Le fichier externe n\'est pas disponible.</string>
-  <string name="app_settings_show_debug_info">Afficher les infos de débogage</string>
-  <string name="app_settings_show_debug_info_details">Voir/partager l\'application et les détails de configuration</string>
-  <!--AccountActivity-->
-  <string name="account_synchronize_now">Synchroniser maintenant</string>
-  <string name="account_synchronizing_now">Synchronisation en cours</string>
-  <string name="account_settings">Paramètres du compte</string>
-  <string name="account_rename">Renommer le compte</string>
-  <string name="account_rename_new_name">Les données locales non enregistrées pourraient être perdues. Une re-synchronisation est nécessaire après avoir renommé le compte. Nouveau nom du compte : </string>
-  <string name="account_rename_rename">Renommer</string>
-  <string name="account_delete">Supprimer le compte</string>
-  <string name="account_delete_confirmation_title">Voulez-vous vraiment supprimer le compte?</string>
-  <string name="account_delete_confirmation_text">Toutes les copies locales des carnets d\'adresses, des calendriers et des listes de tâches seront supprimées.</string>
-  <string name="account_carddav">CardDAV (les carnets d\'adresse) </string>
-  <string name="account_caldav">CalDAV (les agendas) </string>
-  <string name="account_webcal">WebCal (les anciens agenda)</string>
-  <string name="account_calendar">calendrier</string>
-  <string name="account_task_list">liste de tâche</string>
-  <string name="account_refresh_address_book_list">Actualiser le carnet d\'adresses</string>
-  <string name="account_create_new_address_book">Créer un nouveau carnet d\'adresses</string>
-  <string name="account_refresh_calendar_list">Actualiser le calendrier</string>
-  <string name="account_create_new_calendar">Créer un nouveau calendrier</string>
-  <string name="account_no_webcal_handler_found">Aucune application compatible WebCal</string>
-  <string name="account_install_icsdroid">Installer ICSdroid</string>
-  <!--AddAccountActivity-->
-  <string name="login_title">Ajouter un compte</string>
-  <string name="login_type_email">Connexion avec une adresse email</string>
-  <string name="login_email_address">Adresse mail</string>
-  <string name="login_email_address_error">Une adresse e-mail valide est requise</string>
-  <string name="login_password">Mot de passe</string>
-  <string name="login_password_required">Mot de passe requis</string>
-  <string name="login_type_url">Connexion avec une URL et un nom d\'utilisateur</string>
-  <string name="login_url_must_be_http_or_https">L\'URL doit commencer par http(s)://</string>
-  <string name="login_url_host_name_required">Nom d\'hôte requis</string>
-  <string name="login_user_name">Nom d\'utilisateur</string>
-  <string name="login_user_name_required">Nom d\'utilisateur requis</string>
-  <string name="login_base_url">URL de base</string>
-  <string name="login_login">Se connecter</string>
-  <string name="login_back">Retour</string>
-  <string name="login_create_account">Créer un compte</string>
-  <string name="login_account_name">Nom du compte</string>
-  <string name="login_account_name_info">Utilisez votre adresse e-mail comme nom de compte car Android utilisera ce nom en tant que champ ORGANISATEUR pour les événements que vous créerez. Vous ne pouvez pas avoir deux comptes avec le même nom.</string>
-  <string name="login_account_contact_group_method">Méthode pour les contacts de type groupe :</string>
-  <string name="login_account_name_required">Nom du compte requis</string>
-  <string name="login_account_not_created">Le compte n\'a pas pu être créé</string>
-  <string name="login_configuration_detection">Détection de la configuration</string>
-  <string name="login_querying_server">Veuillez patienter, nous interrogeons le serveur ...</string>
-  <string name="login_no_caldav_carddav">Aucun accès possible au service CalDAV ou CardDAV.</string>
-  <!--AccountSettingsActivity-->
-  <string name="settings_title">Paramètres: %s</string>
-  <string name="settings_authentication">Authentification</string>
-  <string name="settings_username">Nom d\'utilisateur</string>
-  <string name="settings_enter_username">Saisissez votre nom d\'utilisateur :</string>
-  <string name="settings_password">Mot de passe</string>
-  <string name="settings_password_summary">Mettre à jour le mot de passe </string>
-  <string name="settings_enter_password">Saisissez votre mot de passe :</string>
-  <string name="settings_sync">Synchronisation</string>
-  <string name="settings_sync_interval_contacts">Intervalle de synchronisation des carnets d\'adresses</string>
-  <string name="settings_sync_summary_manually">Manuellement</string>
-  <string name="settings_sync_summary_periodically" tools:ignore="PluralsCandidate">Toutes les %d minutes et immédiatement après un changement local</string>
-  <string name="settings_sync_interval_calendars">Intervalle de synchronisation des agendas</string>
-  <string name="settings_sync_interval_tasks">Intervalle de synchronisation des tâches</string>
-  <string-array name="settings_sync_interval_names">
-    <item>Manuellement</item>
-    <item>Tous les quarts d\'heure</item>
-    <item>Toutes les demi-heures</item>
-    <item>Toutes les heures</item>
-    <item>Toutes les deux heures</item>
-    <item>Toutes les quatre heures</item>
-    <item>Une fois par jour</item>
-  </string-array>
-  <string name="settings_sync_wifi_only">Synchronisation en Wifi seulement</string>
-  <string name="settings_sync_wifi_only_on">La synchronisation est limitée aux connexions WiFi</string>
-  <string name="settings_sync_wifi_only_off">Le type de connexion n\'est pas pris en charge</string>
-  <string name="settings_sync_wifi_only_ssids">Restriction WiFi SSID</string>
-  <string name="settings_sync_wifi_only_ssids_on">Synchronisation possible seulement en %s</string>
-  <string name="settings_sync_wifi_only_ssids_off">Toutes les connexions WiFi seront utilisées</string>
-  <string name="settings_sync_wifi_only_ssids_message">Liste des points d\'accès WiFi (SSID) autorisés, séparés par des virgules. (Laissez vide pour tous)</string>
-  <string name="settings_carddav">CardDAV</string>
-  <string name="settings_contact_group_method">Méthode pour les contacts de type groupe</string>
-  <string-array name="settings_contact_group_method_values">
-    <item>GROUP_VCARDS</item>
-    <item>CATEGORIES</item>
-  </string-array>
-  <string-array name="settings_contact_group_method_entries">
-    <item>Les groupes sont des VCards indépendantes</item>
-    <item>Les groupes sont des catégories pour chacun des contacts</item>
-  </string-array>
-  <string name="settings_caldav">CalDAV</string>
-  <string name="settings_sync_time_range_past">Limite des événements passés</string>
-  <string name="settings_sync_time_range_past_none">Tous les événements seront synchronisés</string>
-  <plurals name="settings_sync_time_range_past_days">
-    <item quantity="one">Les événements de plus d’un jour passé seront ignorés</item>
-    <item quantity="other">Les événements de plus de %d jours passés seront ignorés</item>
-  </plurals>
-  <string name="settings_sync_time_range_past_message">Les événements antérieurs à ce nombre de jours seront ignorés (peut être 0). Laissez vide pour synchroniser tous les événements.</string>
-  <string name="settings_manage_calendar_colors">Choisir couleur du calendrier</string>
-  <string name="settings_manage_calendar_colors_on">Les couleurs de calendrier sont gérées par DAVdroid</string>
-  <string name="settings_manage_calendar_colors_off">Les couleurs de calendrier ne sont pas gérées par DAVdroid</string>
-  <string name="settings_event_colors">Couleur associée aux événements</string>
-  <string name="settings_event_colors_on">Synchroniser la couleur associée aux événements</string>
-  <string name="settings_event_colors_off">Ne pas synchroniser la couleur associée aux événements</string>
-  <string name="settings_event_colors_off_confirm">Modifier la couleur associée aux événements peut affecter les valeurs déjà synchronisées.</string>
-  <!--collection management-->
-  <string name="create_addressbook">Créer un carnet d\'adresses</string>
-  <string name="create_addressbook_display_name_hint">Mon carnet d\'adresses</string>
-  <string name="create_calendar">Créer une collection CalDAV</string>
-  <string name="create_calendar_display_name_hint">Mon calendrier</string>
-  <string name="create_calendar_time_zone">Fuseau horaire:</string>
-  <string name="create_calendar_type">Type de collection:</string>
-  <string name="create_calendar_type_only_events">Calendrier (événements seulement)</string>
-  <string name="create_calendar_type_only_tasks">Liste de tâches (tâches seulement)</string>
-  <string name="create_calendar_type_events_and_tasks">Fusionner (événements et tâches)</string>
-  <string name="create_collection_color">Choisir une couleur pour la collection</string>
-  <string name="create_collection_creating">Création collection</string>
-  <string name="create_collection_display_name">Le nom affiché (titre) pour cette collection:</string>
-  <string name="create_collection_display_name_required">Titre requis</string>
-  <string name="create_collection_description">Description (facultatif)</string>
-  <string name="create_collection_home_set">Accueil:</string>
-  <string name="create_collection_create">Créer</string>
-  <string name="delete_collection">Supprimer la collection</string>
-  <string name="delete_collection_confirm_title">Êtes-vous sur?</string>
-  <string name="delete_collection_confirm_warning">Cette collection (%s) et toutes ses données seront supprimées du serveur.</string>
-  <string name="delete_collection_deleting_collection">Suppression de la collection</string>
-  <!--ExceptionInfoFragment-->
-  <string name="exception">Une erreur est survenue.</string>
-  <string name="exception_httpexception">Une erreur HTTP est survenue.</string>
-  <string name="exception_ioexception">Une erreur I/O est survenue.</string>
-  <string name="exception_show_details">Voir détails</string>
-  <!--sync adapters and DebugInfoActivity-->
-  <string name="debug_info_title">Infos de débogage</string>
-  <string name="sync_error_permissions">Autorisations DAVdroid</string>
-  <string name="sync_error_permissions_text">Autorisations supplémentaires demandées</string>
-  <!--cert4android-->
-  <string name="certificate_notification_connection_security">DAVdroid : Sécurité de la connexion</string>
-  <string name="trust_certificate_unknown_certificate_found">DAVdroid a rencontré un certificat inconnu. Voulez-vous lui faire confiance?</string>
-</resources>