Version bump to 2.4-beta1

.github/CODEOWNERS

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

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: true
-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

@@ -1,44 +0,0 @@
-name: Qualified Bug Report
-description: "For qualified bug reports. (Use Discussions if unsure.)"
-type: bug
-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

@@ -1,20 +0,0 @@
-name: Qualified Feature Request
-description: "For qualified feature requests. (Use Discussions if unsure.)"
-type: feature
-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/dependabot.yml

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

.github/pull_request_template.md

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

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

@@ -1,50 +0,0 @@
-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
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v6
-    - uses: actions/setup-java@v5
-      with:
-        distribution: temurin
-        java-version: 21
-    - uses: gradle/actions/setup-gradle@v5
-      with:
-        cache-encryption-key: ${{ secrets.gradle_encryption_key }}
-        cache-read-only: true         # gradle user home cache is generated by test jobs
-
-    # Initializes the CodeQL tools for scanning.
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v4
-      with:
-        languages: java-kotlin
-        build-mode: manual            # autobuild uses older JDK
-
-    - name: Build                     # we must not use build cache here
-      run: ./gradlew --no-daemon --configuration-cache app:assembleDebug
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v4
-      with:
-        category: "/language:${{matrix.language}}"

.github/workflows/dependency-submission.yml

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

.github/workflows/release.yml

@@ -1,47 +0,0 @@
-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@v6
-      - uses: actions/setup-java@v5
-        with:
-          distribution: temurin
-          java-version: 21
-      - uses: gradle/actions/setup-gradle@v5
-
-      - name: Prepare keystore
-        run: echo ${{ secrets.android_keystore_base64 }} | base64 -d >$GITHUB_WORKSPACE/keystore.jks
-
-      - name: Build signed package
-        # Use build cache to speed up building of build variants, but clean caches from previous tests before
-        run: ./gradlew --build-cache --configuration-cache --no-daemon app:clean app:assembleRelease
-        env:
-          ANDROID_KEYSTORE: ${{ github.workspace }}/keystore.jks
-          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.android_keystore_password }}
-          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

.github/workflows/test-dev.yml

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

.gitignore

@@ -8,14 +8,17 @@
 # Files for the Dalvik VM
 *.dex
 
-# Java/Kotlin
+# Java class files
 *.class
-.kotlin/
 
 # Generated files
 bin/
 gen/
 
+# Gradle files
+.gradle/
+build/
+
 # Local configuration file (sdk path, etc)
 local.properties
 

.gitlab-ci.yml

@@ -0,0 +1,30 @@
+image: registry.gitlab.com/bitfireat/davx5-ose:latest
+
+before_script:
+  - git submodule update --init --recursive
+  - export GRADLE_USER_HOME=`pwd`/.gradle; chmod +x gradlew
+
+cache:
+  paths:
+     - .gradle/
+
+test:
+  script:
+#   - (cd /sdk/emulator; ./emulator @test -no-audio -no-window & wait-for-emulator.sh)
+#   - ./gradlew check mergeAndroidReports
+    - ./gradlew check
+  artifacts:
+    paths:
+      - app/build/outputs/lint-results-debug.html
+      - app/build/reports
+      - build/reports
+
+pages:
+  script:
+    - ./gradlew app:dokka
+    - mkdir public && mv app/build/dokka public
+  artifacts:
+    paths:
+      - public
+  only:
+    - master-ose

.gitmodules

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

.idea/codeStyles/Project.xml

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

.idea/codeStyles/codeStyleConfig.xml

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

.idea/copyright/LICENSE.xml

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

.idea/copyright/profiles_settings.xml

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

AUTHORS

@@ -1,7 +0,0 @@
-You can view the list of people who have contributed to the code base in the version control history:
-https://github.com/bitfireAT/davx5-ose/graphs/contributors
-
-Translators are not mentioned in the history explicitly.
-The list of translators can be found in the About screen.
-
-Every contribution is welcome. There are many other forms of contributing besides writing code!

CONTRIBUTING.md

@@ -1,99 +0,0 @@
-
-**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 notice
-
-Make sure that every file that contains significant work (at least every code file)
-starts with the copyright header. Android Studio should do so automatically because the
-configuration is stored in the repository (`.idea/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/).
-

README.md

@@ -1,47 +1,38 @@
 
-[![Follow @davx5app@fosstodon.org](https://img.shields.io/mastodon/follow/109598783742737223?domain=https%3A%2F%2Ffosstodon.org&style=flat-square)](https://fosstodon.org/@davx5app)
-[![Website](https://img.shields.io/website?style=flat-square&up_color=%237cb342&url=https%3A%2F%2Fwww.davx5.com)](https://www.davx5.com/)
-[![License](https://img.shields.io/github/license/bitfireAT/davx5-ose?style=flat-square)](https://github.com/bitfireAT/davx5-ose/blob/main/LICENSE)
-[![F-Droid](https://img.shields.io/f-droid/v/at.bitfire.davdroid?style=flat-square)](https://f-droid.org/packages/at.bitfire.davdroid/)
-![GitHub Downloads (all assets, all releases)](https://img.shields.io/github/downloads/bitfireAT/davx5-ose/total?label=GitHub%20downloads)
-
 ![DAVx⁵ logo](app/src/main/res/mipmap-xxxhdpi/ic_launcher.png)
 
-
 DAVx⁵
 ========
 
-> [!IMPORTANT]
-> Please see the [DAVx⁵ Web site](https://www.davx5.com) for
-> comprehensive information about DAVx⁵, including a list of services it has been tested with,
-> a manual and FAQ.
+Please see the [DAVx⁵ Web site](https://www.davx5.com) for
+comprehensive information about DAVx⁵.
 
 DAVx⁵ is licensed under the [GPLv3 License](LICENSE).
 
-News and updates: 
+News and updates: [@davx5app](https://twitter.com/davx5app) on Twitter
 
-* [@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
-* [synctools](https://github.com/bitfireAT/synctools) – iCalendar/vCard/Tasks processing and content provider access
+Help, discussion, feature requests, bug reports: [DAVx⁵ forums](https://www.davx5.com/forums)
 
 **If you want to support DAVx⁵, please consider [donating to DAVx⁵](https://www.davx5.com/donate)
 or [purchasing it](https://www.davx5.com/download).**
 
+Generated KDoc: https://bitfireAT.gitlab.io/davx5-ose/dokka/app/
+
+Parts of DAVx⁵ have been outsourced into these libraries:
+
+* [cert4android](https://gitlab.com/bitfireAT/cert4android) – custom certificate management
+* [dav4jvm](https://gitlab.com/bitfireAT/dav4jvm) – WebDAV/CalDav/CardDAV framework
+* [ical4android](https://gitlab.com/bitfireAT/ical4android) – iCalendar processing and Calendar Provider access
+* [vcard4android](https://gitlab.com/bitfireAT/vcard4android) – vCard processing and Contacts Provider access
+
 
 USED THIRD-PARTY LIBRARIES
 ==========================
 
-The most important libraries which are used by DAVx⁵ (alphabetically):
+Those libraries 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)
+* [Color Picker](https://github.com/jaredrummler/ColorPicker) – [Apache License, Version 2.0](https://github.com/jaredrummler/ColorPicker/LICENSE)
+* [dnsjava](http://www.xbill.org/dnsjava/) – [BSD License](http://www.xbill.org/dnsjava/dnsjava-current/LICENSE)
+* [ez-vcard](https://github.com/mangstadt/ez-vcard) – [New BSD License](http://opensource.org/licenses/BSD-3-Clause)
+* [iCal4j](https://github.com/ical4j/ical4j) – [New BSD License](http://sourceforge.net/p/ical4j/ical4j/ci/default/tree/LICENSE)
 * [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

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

app/build.gradle

@@ -0,0 +1,115 @@
+/*
+ * 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: 'kotlin-kapt'
+apply plugin: 'org.jetbrains.dokka-android'
+
+android {
+    compileSdkVersion 28
+    buildToolsVersion '28.0.3'
+
+    defaultConfig {
+        applicationId "at.bitfire.davdroid"
+
+        versionCode 274
+        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
+        buildConfigField "boolean", "customCerts", "true"
+
+        minSdkVersion 19        // Android 4.4
+        targetSdkVersion 28     // Android 9.0
+
+        buildConfigField "String", "userAgent", "\"DAVx5\""
+
+        // when using this, make sure that notification icons are real bitmaps
+        vectorDrawables.useSupportLibrary = true
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
+    dataBinding.enabled = true
+
+    flavorDimensions "distribution"
+    productFlavors {
+        standard {
+            versionName "2.4-beta1-ose"
+        }
+    }
+
+    buildTypes {
+        debug {
+            minifyEnabled false
+        }
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+
+    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 "androidx.test.runner.AndroidJUnitRunner"
+    }
+}
+
+dependencies {
+    implementation project(':cert4android')
+    implementation project(':ical4android')
+    implementation project(':vcard4android')
+
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
+
+    implementation 'androidx.appcompat:appcompat:1.0.2'
+    implementation 'androidx.cardview:cardview:1.0.0'
+    implementation 'androidx.fragment:fragment-ktx:1.0.0'
+    implementation 'androidx.lifecycle:lifecycle-extensions:2.0.0'
+    implementation 'androidx.lifecycle:lifecycle-livedata:2.0.0'
+    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.0.0'
+    implementation 'androidx.preference:preference:1.0.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    implementation 'com.google.android:flexbox:1.1.0'
+    implementation 'com.google.android.material:material:1.0.0'
+
+    implementation(':dav4jvm') {
+        exclude group: 'org.ogce', module: 'xpp3'	// Android comes with its own XmlPullParser
+    }
+    implementation 'com.jaredrummler:colorpicker:1.1.0'
+    implementation 'com.mikepenz:aboutlibraries:6.2.3'
+
+    implementation 'com.squareup.okhttp3:logging-interceptor:3.12.2'
+    implementation 'commons-io:commons-io:2.6'
+    implementation 'dnsjava:dnsjava:2.1.8'
+    implementation 'org.apache.commons:commons-collections4:4.3'
+
+    // for tests
+    androidTestImplementation 'androidx.test:runner:1.1.1'
+    androidTestImplementation 'androidx.test:rules:1.1.1'
+    androidTestImplementation 'junit:junit:4.12'
+    androidTestImplementation 'com.squareup.okhttp3:mockwebserver:3.12.2'
+
+    testImplementation 'junit:junit:4.12'
+    testImplementation 'com.squareup.okhttp3:mockwebserver:3.12.2'
+}

app/build.gradle.kts

@@ -1,233 +0,0 @@
-/*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
- */
-
-plugins {
-    alias(libs.plugins.android.application)
-    alias(libs.plugins.compose.compiler)
-    alias(libs.plugins.hilt)
-    alias(libs.plugins.kotlin.serialization)
-    alias(libs.plugins.ksp)
-    alias(libs.plugins.mikepenz.aboutLibraries.android)
-}
-
-// Android configuration
-android {
-    compileSdk = 36
-
-    defaultConfig {
-        applicationId = "at.bitfire.davdroid"
-
-        versionCode = 405090005
-        versionName = "4.5.9"
-
-        base.archivesName = "davx5-$versionCode-$versionName"
-
-        minSdk = 24        // Android 7.0
-        targetSdk = 36     // Android 16
-
-        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 = "com.davx5.ose"
-
-    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")
-        }
-    }
-
-    lint {
-        disable += arrayOf("GoogleAppIndexingWarning", "ImpliedQuantity", "MissingQuantity", "MissingTranslation", "ExtraTranslation", "RtlEnabled", "RtlHardcoded", "Typos")
-    }
-
-    androidResources {
-        generateLocaleConfig = true
-    }
-
-    packaging {
-        resources {
-            // multiple (test) dependencies have LICENSE files at same location
-            merges += arrayOf("META-INF/LICENSE*")
-        }
-    }
-
-    @Suppress("UnstableApiUsage")
-    testOptions {
-        managedDevices {
-            localDevices {
-                create("virtual") {
-                    device = "Pixel 3"
-                    // TBD: API level 35 and higher causes network tests to fail sometimes, see https://github.com/bitfireAT/davx5-ose/issues/1525
-                    // Suspected reason: https://developer.android.com/about/versions/15/behavior-changes-all#background-network-access
-                    apiLevel = 34
-                    systemImageSource = "aosp-atd"
-                }
-            }
-        }
-    }
-}
-
-ksp {
-    arg("room.schemaLocation", "$projectDir/schemas")
-}
-
-aboutLibraries {
-    export {
-        // exclude timestamps for reproducible builds [https://github.com/bitfireAT/davx5-ose/issues/994]
-        excludeFields.add("generated")
-    }
-}
-
-dependencies {
-    // app core
-    implementation(project(":core"))
-
-    // Kotlin / Android
-    implementation(libs.kotlin.stdlib)
-    implementation(libs.kotlinx.coroutines)
-    coreLibraryDesugaring(libs.android.desugaring)
-
-    // Hilt
-    implementation(libs.hilt.android.base)
-    ksp(libs.androidx.hilt.compiler)
-    ksp(libs.hilt.android.compiler)
-
-    // support libs
-    implementation(libs.androidx.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.androidx.compose.bom))
-    implementation(libs.androidx.compose.material3)
-    implementation(libs.androidx.compose.material3.adaptive)
-    implementation(libs.androidx.compose.materialIconsExtended)
-    debugImplementation(libs.androidx.compose.ui.tooling)
-    implementation(libs.androidx.compose.ui.toolingPreview)
-
-    // Glance Widgets
-    implementation(libs.androidx.glance.base)
-    implementation(libs.androidx.glance.material3)
-
-    // Jetpack Room
-    implementation(libs.androidx.room.runtime)
-    implementation(libs.androidx.room.base)
-    implementation(libs.androidx.room.paging)
-    ksp(libs.androidx.room.compiler)
-
-    // own libraries
-    implementation(libs.bitfire.cert4android)
-    implementation(libs.bitfire.dav4jvm) {
-        exclude(group="junit")
-        exclude(group="org.ogce", module="xpp3")    // Android has its own XmlPullParser implementation
-    }
-    implementation(libs.bitfire.synctools) {
-        exclude(group="androidx.test")              // synctools declares test rules, but we don't want them in non-test code
-        exclude(group = "junit")
-    }
-
-    // third-party libs
-    implementation(libs.conscrypt)
-    implementation(libs.dnsjava)
-    implementation(libs.guava)
-    implementation(libs.ktor.client.content.negotiation)
-    implementation(libs.ktor.client.core)
-    implementation(libs.ktor.client.okhttp)
-    implementation(libs.ktor.serialization.kotlinx.json)
-    implementation(libs.mikepenz.aboutLibraries.m3)
-    implementation(libs.okhttp.base)
-    implementation(libs.okhttp.brotli)
-    implementation(libs.okhttp.logging)
-    implementation(libs.openid.appauth)
-    implementation(libs.unifiedpush) {
-        // UnifiedPush connector seems to be using a workaround by importing this library.
-        // Will be removed after https://github.com/tink-crypto/tink-java-apps/pull/5 is merged.
-        // See: https://codeberg.org/UnifiedPush/android-connector/src/commit/28cb0d622ed0a972996041ab9cc85b701abc48c6/connector/build.gradle#L56-L59
-        exclude(group = "com.google.crypto.tink", module = "tink")
-    }
-    implementation(libs.unifiedpush.fcm)
-
-    // force some versions for compatibility with our minSdk level (see version catalog for details)
-    implementation(libs.commons.codec)
-    implementation(libs.commons.lang)
-
-    // for tests
-    androidTestImplementation(libs.androidx.arch.core.testing)
-    androidTestImplementation(libs.androidx.room.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.kotlinx.coroutines.test)
-    androidTestImplementation(libs.mockk.android)
-    androidTestImplementation(libs.okhttp.mockwebserver)
-
-    testImplementation(libs.bitfire.dav4jvm)
-    testImplementation(libs.junit)
-    testImplementation(libs.mockk)
-    testImplementation(libs.okhttp.mockwebserver)
-    testImplementation(libs.robolectric)
-}

app/proguard-rules.txt

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

app/src/.gitignore

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

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

@@ -0,0 +1,74 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid
+
+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.Before
+import org.junit.Test
+
+class HttpClientTest {
+
+    lateinit var server: MockWebServer
+    lateinit var httpClient: HttpClient
+
+    @Before
+    fun setUp() {
+        httpClient = HttpClient.Builder().build()
+
+        server = MockWebServer()
+        server.start(30000)
+    }
+
+    @After
+    fun tearDown() {
+        server.shutdown()
+        httpClient.close()
+    }
+
+
+    @Test
+    fun testCookies() {
+        val url = server.url("/test")
+
+        // set cookie for root path (/) and /test path in first response
+        server.enqueue(MockResponse()
+                .setResponseCode(200)
+                .addHeader("Set-Cookie", "cookie1=1; path=/")
+                .addHeader("Set-Cookie", "cookie2=2")
+                .setBody("Cookie set"))
+        httpClient.okHttpClient.newCall(Request.Builder()
+                .get().url(url)
+                .build()).execute()
+        assertNull(server.takeRequest().getHeader("Cookie"))
+
+        // cookie should be sent with second request
+        // second response lets first cookie expire and overwrites second cookie
+        server.enqueue(MockResponse()
+                .addHeader("Set-Cookie", "cookie1=1a; path=/; Max-Age=0")
+                .addHeader("Set-Cookie", "cookie2=2a")
+                .setResponseCode(200))
+        httpClient.okHttpClient.newCall(Request.Builder()
+                .get().url(url)
+                .build()).execute()
+        assertEquals("cookie2=2; cookie1=1", server.takeRequest().getHeader("Cookie"))
+
+        server.enqueue(MockResponse()
+                .setResponseCode(200))
+        httpClient.okHttpClient.newCall(Request.Builder()
+                .get().url(url)
+                .build()).execute()
+        assertEquals("cookie2=2a", server.takeRequest().getHeader("Cookie"))
+    }
+
+}

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

@@ -0,0 +1,134 @@
+/*
+ * 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 androidx.test.filters.SmallTest
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.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)
+        assertTrue(info!!.privWriteContent)
+        assertTrue(info!!.privUnbind)
+        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)
+        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)
+    }
+
+    @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.PRIV_WRITE_CONTENT, 0)
+        values.put(Collections.PRIV_UNBIND, 0)
+        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)
+        assertFalse(info.privWriteContent)
+        assertFalse(info.privUnbind)
+        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/DefaultsSettingsProviderTest.kt

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

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

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

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

@@ -1,37 +1,32 @@
 /*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ * 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.servicedetection
+package at.bitfire.davdroid.ui.setup
 
-import at.bitfire.dav4jvm.okhttp.DavResource
-import at.bitfire.dav4jvm.property.carddav.CardDAV
-import at.bitfire.dav4jvm.property.webdav.WebDAV
-import at.bitfire.davdroid.network.HttpClientBuilder
-import at.bitfire.davdroid.servicedetection.DavResourceFinder.Configuration.ServiceInfo
-import at.bitfire.davdroid.settings.Credentials
-import at.bitfire.davdroid.util.SensitiveString.Companion.toSensitiveString
-import dagger.hilt.android.testing.HiltAndroidRule
-import dagger.hilt.android.testing.HiltAndroidTest
-import okhttp3.OkHttpClient
+import androidx.test.filters.SmallTest
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.property.AddressbookHomeSet
+import at.bitfire.dav4jvm.property.ResourceType
+import at.bitfire.davdroid.HttpClient
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.Credentials
+import at.bitfire.davdroid.ui.setup.DavResourceFinder.Configuration.ServiceInfo
 import okhttp3.mockwebserver.Dispatcher
 import okhttp3.mockwebserver.MockResponse
 import okhttp3.mockwebserver.MockWebServer
 import okhttp3.mockwebserver.RecordedRequest
 import org.junit.After
-import org.junit.Assert.assertArrayEquals
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertFalse
-import org.junit.Assert.assertNull
-import org.junit.Assert.assertTrue
+import org.junit.Assert.*
 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 {
@@ -45,53 +40,39 @@ class DavResourceFinderTest {
         private const val SUBPATH_ADDRESSBOOK = "/addressbooks/private-contacts"
     }
 
-    @get:Rule
-    val hiltRule = HiltAndroidRule(this)
+    val server = MockWebServer()
 
-    @Inject
-    lateinit var httpClientBuilder: HttpClientBuilder
-
-    @Inject
-    lateinit var logger: Logger
-
-    @Inject
-    lateinit var resourceFinderFactory: DavResourceFinder.Factory
-
-    private lateinit var server: MockWebServer
-    private lateinit var client: OkHttpClient
-    private lateinit var finder: DavResourceFinder
+    lateinit var finder: DavResourceFinder
+    lateinit var client: HttpClient
+    lateinit var loginInfo: LoginModel
 
     @Before
-    fun setUp() {
-        hiltRule.inject()
+    fun initServerAndClient() {
+        server.setDispatcher(TestDispatcher())
+        server.start()
 
-        server = MockWebServer().apply {
-            dispatcher = TestDispatcher(logger)
-            start()
-        }
+        loginInfo = LoginModel(URI.create("/"), Credentials("mock", "12345"))
+        finder = DavResourceFinder(InstrumentationRegistry.getInstrumentation().targetContext, loginInfo)
 
-        val credentials = Credentials(username = "mock", password = "12345".toSensitiveString())
-        client = httpClientBuilder
-                .authenticate(domain = null, getCredentials = { credentials })
+        client = HttpClient.Builder()
+                .addAuthentication(null, loginInfo.credentials)
                 .build()
-
-        val baseURI = URI.create("/")
-        finder = resourceFinderFactory.create(baseURI, credentials)
     }
 
     @After
-    fun tearDown() {
+    fun stopServer() {
         server.shutdown()
     }
 
 
     @Test
+    @SmallTest
     fun testRememberIfAddressBookOrHomeset() {
         // recognize home set
         var info = ServiceInfo()
-        DavResource(client, server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL))
-                .propfind(0, CardDAV.AddressbookHomeSet) { response, _ ->
-            finder.scanResponse(CardDAV.Addressbook, response, info)
+        DavResource(client.okHttpClient, server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL))
+                .propfind(0, AddressbookHomeSet.NAME) { response, _ ->
+            finder.scanCardDavResponse(response, info)
         }
         assertEquals(0, info.collections.size)
         assertEquals(1, info.homeSets.size)
@@ -99,9 +80,9 @@ class DavResourceFinderTest {
 
         // recognize address book
         info = ServiceInfo()
-        DavResource(client, server.url(PATH_CARDDAV + SUBPATH_ADDRESSBOOK))
-                .propfind(0, WebDAV.ResourceType) { response, _ ->
-            finder.scanResponse(CardDAV.Addressbook, response, info)
+        DavResource(client.okHttpClient, server.url(PATH_CARDDAV + SUBPATH_ADDRESSBOOK))
+                .propfind(0, ResourceType.NAME) { response, _ ->
+            finder.scanCardDavResponse(response, info)
         }
         assertEquals(1, info.collections.size)
         assertEquals(server.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK/"), info.collections.keys.first())
@@ -141,33 +122,21 @@ 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(
-        private val logger: Logger
-    ): Dispatcher() {
+    class TestDispatcher: Dispatcher() {
 
-        override fun dispatch(request: RecordedRequest): MockResponse {
-            if (!checkAuth(request)) {
+        override fun dispatch(rq: RecordedRequest): MockResponse {
+            if (!checkAuth(rq)) {
                 val authenticate = MockResponse().setResponseCode(401)
                 authenticate.setHeader("WWW-Authenticate", "Basic realm=\"test\"")
                 return authenticate
             }
 
-            val path = request.path!!
+            val path = rq.path
 
-            if (request.method.equals("OPTIONS", true)) {
+            if (rq.method.equals("OPTIONS", true)) {
                 val dav = when {
                     path.startsWith(PATH_CALDAV) -> "calendar-access"
                     path.startsWith(PATH_CARDDAV) -> "addressbook"
@@ -178,7 +147,7 @@ class DavResourceFinderTest {
                 if (dav != null)
                     response.addHeader("DAV", dav)
                 return response
-            } else if (request.method.equals("PROPFIND", true)) {
+            } else if (rq.method.equals("PROPFIND", true)) {
                 val props: String?
                 when (path) {
                     PATH_CALDAV,
@@ -196,21 +165,14 @@ 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.info("Sending props: $props")
+                Logger.log.info("Sending props: $props")
                 return MockResponse()
                         .setResponseCode(207)
-                        .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
+                        .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav'>" +
                                 "<response>" +
-                                "   <href>${request.path}</href>" +
+                                "   <href>${rq.path}</href>" +
                                 "   <propstat><prop>$props</prop></propstat>" +
                                 "</response>" +
                                 "</multistatus>")

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

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

app/src/main/AndroidManifest.xml

@@ -1,18 +1,189 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!--
-  ~ Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
-  -->
+<manifest package="at.bitfire.davdroid"
+          xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools"
+          android:installLocation="internalOnly">
 
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-        xmlns:tools="http://schemas.android.com/tools"
-        android:installLocation="internalOnly">
+    <!-- normal permissions -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.READ_SYNC_STATS"/>
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
 
-    <application android:name=".App">
+    <!-- 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"/>
 
-        <!-- Remove the node added by AppAuth (remove only from net.openid.appauth library, not from our flavor manifest files) -->
-        <activity android:name="net.openid.appauth.RedirectUriReceiverActivity"
-                tools:node="remove" tools:selector="net.openid.appauth"/>
+    <!-- other permissions -->
+    <!-- android.permission-group.CONTACTS -->
+    <uses-permission android:name="android.permission.READ_CONTACTS"/>
+    <uses-permission android:name="android.permission.WRITE_CONTACTS"/>
+    <!-- android.permission-group.CALENDAR -->
+    <uses-permission android:name="android.permission.READ_CALENDAR"/>
+    <uses-permission android:name="android.permission.WRITE_CALENDAR"/>
+
+    <!-- android.permission-group.LOCATION -->
+    <!-- required since Android 8.1 to get the WiFi name (for "sync in Wifi only" feature) -->
+    <uses-permission-sdk-23 android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+
+    <!-- ical4android declares task access permissions -->
+
+    <application
+        android:name=".App"
+        android:allowBackup="true"
+        android:fullBackupContent="false"
+        android:networkSecurityConfig="@xml/network_security_config"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/AppThemeExt"
+        tools:ignore="UnusedAttribute">
+
+        <service android:name=".DavService"/>
+
+        <activity
+            android:name=".ui.AccountsActivity"
+            android:label="@string/app_name"
+            android:theme="@style/AppTheme.NoActionBar">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+                <category android:name="android.intent.category.LAUNCHER"/>
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".ui.AboutActivity"
+            android:label="@string/navigation_drawer_about"
+            android:theme="@style/AppTheme.NoActionBar"
+            android:parentActivityName=".ui.AccountsActivity"/>
+
+        <activity
+            android:name=".ui.AppSettingsActivity"
+            android:label="@string/app_settings"
+            android:parentActivityName=".ui.AccountsActivity"
+            android:exported="true"/>
+
+        <activity
+            android:name=".ui.setup.LoginActivity"
+            android:label="@string/login_title"
+            android:parentActivityName=".ui.AccountsActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".ui.AccountActivity"
+            android:parentActivityName=".ui.AccountsActivity">
+        </activity>
+        <activity android:name=".ui.AccountSettingsActivity"/>
+        <activity android:name=".ui.CreateAddressBookActivity"
+            android:label="@string/create_addressbook"/>
+        <activity android:name=".ui.CreateCalendarActivity"
+                  android:label="@string/create_calendar"/>
+
+        <activity
+            android:name=".ui.DebugInfoActivity"
+            android:parentActivityName=".ui.AppSettingsActivity"
+            android:exported="true"
+            android:label="@string/debug_info_title">
+        </activity>
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="@string/authority_debug_provider"
+            android:grantUriPermissions="true"
+            android:exported="false">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/debug_paths" />
+        </provider>
+
+        <!-- account type "DAVx⁵" -->
+        <service
+            android:name=".syncadapter.AccountAuthenticatorService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.accounts.AccountAuthenticator"
+                android:resource="@xml/account_authenticator"/>
+        </service>
+        <service
+            android:name=".syncadapter.CalendarsSyncAdapterService"
+            android:exported="true"
+            tools:ignore="ExportedService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/sync_calendars"/>
+        </service>
+        <service
+            android:name=".syncadapter.TasksSyncAdapterService"
+            android:exported="true"
+            tools:ignore="ExportedService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/sync_tasks"/>
+        </service>
+
+        <!-- account type "DAVx⁵ Address book" -->
+        <service
+            android:name=".syncadapter.NullAuthenticatorService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.accounts.AccountAuthenticator"
+                android:resource="@xml/account_authenticator_address_book"/>
+        </service>
+        <provider
+            android:authorities="@string/address_books_authority"
+            android:exported="false"
+            android:label="@string/address_books_authority_title"
+            android:name=".syncadapter.AddressBookProvider"
+            android:multiprocess="false"/>
+        <service
+            android:name=".syncadapter.AddressBooksSyncAdapterService"
+            android:exported="true"
+            tools:ignore="ExportedService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/sync_address_books"/>
+        </service>
+        <service
+            android:name=".syncadapter.ContactsSyncAdapterService"
+            android:exported="true"
+            tools:ignore="ExportedService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/sync_contacts"/>
+            <meta-data
+                android:name="android.provider.CONTACTS_STRUCTURE"
+                android:resource="@xml/contacts"/>
+        </service>
 
     </application>
 
-</manifest>
+</manifest>

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

@@ -0,0 +1,82 @@
+/*
+ * 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.app.Application
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.graphics.Bitmap
+import android.graphics.drawable.BitmapDrawable
+import android.net.Uri
+import android.os.Build
+import android.os.StrictMode
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.appcompat.content.res.AppCompatResources
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.ui.NotificationUtils
+import kotlin.concurrent.thread
+
+@Suppress("unused")
+class App: Application() {
+
+    companion object {
+
+        fun getLauncherBitmap(context: Context): Bitmap? {
+            val drawableLogo = AppCompatResources.getDrawable(context, R.mipmap.ic_launcher)
+            return if (drawableLogo is BitmapDrawable)
+                drawableLogo.bitmap
+            else
+                null
+        }
+
+        fun homepageUrl(context: Context) =
+                Uri.parse(context.getString(R.string.homepage_url)).buildUpon()
+                        .appendQueryParameter("pk_campaign", BuildConfig.APPLICATION_ID)
+                        .appendQueryParameter("pk_kwd", context::class.java.simpleName)
+                        .appendQueryParameter("app-version", BuildConfig.VERSION_NAME)
+                        .build()!!
+
+    }
+
+
+    override fun onCreate() {
+        super.onCreate()
+        Logger.initialize(this)
+
+        if (BuildConfig.DEBUG)
+            StrictMode.setVmPolicy(StrictMode.VmPolicy.Builder()
+                    .detectActivityLeaks()
+                    .detectFileUriExposure()
+                    .detectLeakedClosableObjects()
+                    .detectLeakedRegistrationObjects()
+                    .detectLeakedSqlLiteObjects()
+                    .penaltyLog()
+                    .build())
+
+        if (Build.VERSION.SDK_INT <= 21)
+            AppCompatDelegate.setCompatVectorFromResourcesEnabled(true)
+
+        NotificationUtils.createChannels(this)
+
+        // don't block UI for some background checks
+        thread {
+            // watch installed/removed apps
+            val tasksFilter = IntentFilter()
+            tasksFilter.addAction(Intent.ACTION_PACKAGE_ADDED)
+            tasksFilter.addAction(Intent.ACTION_PACKAGE_FULLY_REMOVED)
+            tasksFilter.addDataScheme("package")
+            registerReceiver(PackageChangedReceiver(), tasksFilter)
+
+            // check whether a tasks app is currently installed
+            PackageChangedReceiver.updateTaskSync(this)
+        }
+    }
+
+}

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

@@ -0,0 +1,30 @@
+/*
+ * 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
+
+object Constants {
+
+    const val DAVDROID_GREEN_RGBA = 0xFF8bc34a.toInt()
+
+    const val DEFAULT_SYNC_INTERVAL = 4 * 3600L    // 4 hours
+
+    /**
+     * Context label for [org.apache.commons.lang3.exception.ContextedException].
+     * Context value is the [at.bitfire.davdroid.resource.LocalResource]
+     * which is related to the exception cause.
+     */
+    const val EXCEPTION_CONTEXT_LOCAL_RESOURCE = "localResource"
+
+    /**
+     * Context label for [org.apache.commons.lang3.exception.ContextedException].
+     * Context value is the [okhttp3.HttpUrl] of the remote resource
+     * which is related to the exception cause.
+     */
+    const val EXCEPTION_CONTEXT_REMOTE_RESOURCE = "remoteResource"
+
+}

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

@@ -0,0 +1,409 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid
+
+import android.accounts.Account
+import android.app.PendingIntent
+import android.app.Service
+import android.content.ContentResolver
+import android.content.ContentValues
+import android.content.Intent
+import android.database.DatabaseUtils
+import android.database.sqlite.SQLiteDatabase
+import android.os.Binder
+import android.os.Bundle
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.UrlUtils
+import at.bitfire.dav4jvm.exception.DavException
+import at.bitfire.dav4jvm.exception.HttpException
+import at.bitfire.dav4jvm.property.*
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB.*
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import java.io.IOException
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.logging.Level
+import kotlin.concurrent.thread
+
+class DavService: Service() {
+
+    companion object {
+        const val ACTION_REFRESH_COLLECTIONS = "refreshCollections"
+        const val EXTRA_DAV_SERVICE_ID = "davServiceID"
+
+        /** Initialize a forced synchronization. Expects intent data
+            to be an URI of this format:
+            contents://<authority>/<account.type>/<account name>
+         **/
+        const val ACTION_FORCE_SYNC = "forceSync"
+    }
+
+    private val runningRefresh = HashSet<Long>()
+    private val refreshingStatusListeners = LinkedList<WeakReference<RefreshingStatusListener>>()
+
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        intent?.let {
+            val id = intent.getLongExtra(EXTRA_DAV_SERVICE_ID, -1)
+
+            when (intent.action) {
+                ACTION_REFRESH_COLLECTIONS ->
+                    if (runningRefresh.add(id)) {
+                        thread { refreshCollections(id) }
+                        refreshingStatusListeners.forEach { listener ->
+                            listener.get()?.onDavRefreshStatusChanged(id, true)
+                        }
+                    }
+
+                ACTION_FORCE_SYNC -> {
+                    val uri = intent.data!!
+                    val authority = uri.authority!!
+                    val account = Account(
+                            uri.pathSegments[1],
+                            uri.pathSegments[0]
+                    )
+                    forceSync(authority, account)
+                }
+            }
+        }
+
+        return START_NOT_STICKY
+    }
+
+
+    /* BOUND SERVICE PART
+       for communicating with the activities
+    */
+
+    interface RefreshingStatusListener {
+        fun onDavRefreshStatusChanged(id: Long, refreshing: Boolean)
+    }
+
+    private val binder = InfoBinder()
+
+    inner class InfoBinder: Binder() {
+        fun isRefreshing(id: Long) = runningRefresh.contains(id)
+
+        fun addRefreshingStatusListener(listener: RefreshingStatusListener, callImmediate: Boolean) {
+            refreshingStatusListeners += WeakReference<RefreshingStatusListener>(listener)
+            if (callImmediate)
+                runningRefresh.forEach { id -> listener.onDavRefreshStatusChanged(id, true) }
+        }
+
+        fun removeRefreshingStatusListener(listener: RefreshingStatusListener) {
+            val iter = refreshingStatusListeners.iterator()
+            while (iter.hasNext()) {
+                val item = iter.next().get()
+                if (listener == item)
+                    iter.remove()
+            }
+        }
+    }
+
+    override fun onBind(intent: Intent?) = binder
+
+
+
+    /* ACTION RUNNABLES
+       which actually do the work
+     */
+
+    private fun forceSync(authority: String, account: Account) {
+        Logger.log.info("Forcing $authority synchronization of $account")
+        val extras = Bundle(2)
+        extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)        // manual sync
+        extras.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)     // run immediately (don't queue)
+        ContentResolver.requestSync(account, authority, extras)
+    }
+
+    private fun refreshCollections(service: Long) {
+        OpenHelper(this@DavService).use { dbHelper ->
+            val db = dbHelper.writableDatabase
+
+            val serviceType by lazy {
+                db.query(Services._TABLE, arrayOf(Services.SERVICE), "${Services.ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                    if (cursor.moveToNext())
+                        return@lazy cursor.getString(0)
+                } ?: throw IllegalArgumentException("Service not found")
+            }
+
+            val account by lazy {
+                db.query(Services._TABLE, arrayOf(Services.ACCOUNT_NAME), "${Services.ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                    if (cursor.moveToNext())
+                        return@lazy Account(cursor.getString(0), getString(R.string.account_type))
+                }
+                throw IllegalArgumentException("Account not found")
+            }
+
+            val homeSets by lazy {
+                val homeSets = mutableSetOf<HttpUrl>()
+                db.query(HomeSets._TABLE, arrayOf(HomeSets.URL), "${HomeSets.SERVICE_ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                    while (cursor.moveToNext())
+                        HttpUrl.parse(cursor.getString(0))?.let { homeSets += it }
+                }
+                homeSets
+            }
+
+            val collections by lazy {
+                val collections = mutableMapOf<HttpUrl, CollectionInfo>()
+                db.query(Collections._TABLE, null, "${Collections.SERVICE_ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                    while (cursor.moveToNext()) {
+                        val values = ContentValues(cursor.columnCount)
+                        DatabaseUtils.cursorRowToContentValues(cursor, values)
+                        values.getAsString(Collections.URL)?.let { url ->
+                            HttpUrl.parse(url)?.let { collections.put(it, CollectionInfo(values)) }
+                        }
+                    }
+                }
+                collections
+            }
+
+            fun readPrincipal(): HttpUrl? {
+                db.query(Services._TABLE, arrayOf(Services.PRINCIPAL), "${Services.ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                    if (cursor.moveToNext())
+                        cursor.getString(0)?.let { return HttpUrl.parse(it) }
+                }
+                return null
+            }
+
+            /**
+             * Checks if the given URL defines home sets and adds them to the home set list.
+             *
+             * @throws IOException
+             * @throws HttpException
+             * @throws DavException
+             */
+            fun queryHomeSets(client: OkHttpClient, url: HttpUrl, recurse: Boolean = true) {
+                var related = setOf<HttpUrl>()
+
+                fun findRelated(root: HttpUrl, dav: Response) {
+                    // refresh home sets: calendar-proxy-read/write-for
+                    dav[CalendarProxyReadFor::class.java]?.let {
+                        for (href in it.hrefs) {
+                            Logger.log.fine("Principal is a read-only proxy for $href, checking for home sets")
+                            root.resolve(href)?.let { proxyReadFor ->
+                                related += proxyReadFor
+                            }
+                        }
+                    }
+                    dav[CalendarProxyWriteFor::class.java]?.let {
+                        for (href in it.hrefs) {
+                            Logger.log.fine("Principal is a read/write proxy for $href, checking for home sets")
+                            root.resolve(href)?.let { proxyWriteFor ->
+                                related += proxyWriteFor
+                            }
+                        }
+                    }
+
+                    // refresh home sets: direct group memberships
+                    dav[GroupMembership::class.java]?.let {
+                        for (href in it.hrefs) {
+                            Logger.log.fine("Principal is member of group $href, checking for home sets")
+                            root.resolve(href)?.let { groupMembership ->
+                                related += groupMembership
+                            }
+                        }
+                    }
+                }
+
+                val dav = DavResource(client, url)
+                when (serviceType) {
+                    Services.SERVICE_CARDDAV ->
+                        try {
+                            dav.propfind(0, AddressbookHomeSet.NAME, GroupMembership.NAME) { response, _ ->
+                                response[AddressbookHomeSet::class.java]?.let { homeSet ->
+                                    for (href in homeSet.hrefs)
+                                        dav.location.resolve(href)?.let { homeSets += UrlUtils.withTrailingSlash(it) }
+                                }
+
+                                if (recurse)
+                                    findRelated(dav.location, response)
+                            }
+                        } catch (e: HttpException) {
+                            if (e.code/100 == 4)
+                                Logger.log.log(Level.INFO, "Ignoring Client Error 4xx while looking for addressbook home sets", e)
+                            else
+                                throw e
+                        }
+                    Services.SERVICE_CALDAV -> {
+                        try {
+                            dav.propfind(0, CalendarHomeSet.NAME, CalendarProxyReadFor.NAME, CalendarProxyWriteFor.NAME, GroupMembership.NAME) { response, _ ->
+                                response[CalendarHomeSet::class.java]?.let { homeSet ->
+                                    for (href in homeSet.hrefs)
+                                        dav.location.resolve(href)?.let { homeSets.add(UrlUtils.withTrailingSlash(it)) }
+                                }
+
+                                if (recurse)
+                                    findRelated(dav.location, response)
+                            }
+                        } catch (e: HttpException) {
+                            if (e.code/100 == 4)
+                                Logger.log.log(Level.INFO, "Ignoring Client Error 4xx while looking for calendar home sets", e)
+                            else
+                                throw e
+                        }
+                    }
+                }
+
+                for (resource in related)
+                    queryHomeSets(client, resource, false)
+            }
+
+            fun saveHomeSets() {
+                db.delete(HomeSets._TABLE, "${HomeSets.SERVICE_ID}=?", arrayOf(service.toString()))
+                for (homeSet in homeSets) {
+                    val values = ContentValues(2)
+                    values.put(HomeSets.SERVICE_ID, service)
+                    values.put(HomeSets.URL, homeSet.toString())
+                    db.insertOrThrow(HomeSets._TABLE, null, values)
+                }
+            }
+
+            fun saveCollections() {
+                db.delete(Collections._TABLE, "${HomeSets.SERVICE_ID}=?", arrayOf(service.toString()))
+                for ((_,collection) in collections) {
+                    val values = collection.toDB()
+                    Logger.log.log(Level.FINE, "Saving collection", values)
+                    values.put(Collections.SERVICE_ID, service)
+                    db.insertWithOnConflict(Collections._TABLE, null, values, SQLiteDatabase.CONFLICT_REPLACE)
+                }
+            }
+
+
+            try {
+                Logger.log.info("Refreshing $serviceType collections of service #$service")
+
+                // cancel previous notification
+                NotificationManagerCompat.from(this)
+                        .cancel(service.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS)
+
+                // create authenticating OkHttpClient (credentials taken from account settings)
+                HttpClient.Builder(this, AccountSettings(this, account))
+                        .setForeground(true)
+                        .build().use { client ->
+                    val httpClient = client.okHttpClient
+
+                    // refresh home set list (from principal)
+                    readPrincipal()?.let { principalUrl ->
+                        Logger.log.fine("Querying principal $principalUrl for home sets")
+                        queryHomeSets(httpClient, principalUrl)
+                    }
+
+                    // remember selected collections
+                    val selectedCollections = HashSet<HttpUrl>()
+                    collections.values
+                            .filter { it.selected }
+                            .forEach { (url, _) -> selectedCollections += url }
+
+                    // now refresh collections (taken from home sets)
+                    val itHomeSets = homeSets.iterator()
+                    while (itHomeSets.hasNext()) {
+                        val homeSetUrl = itHomeSets.next()
+                        Logger.log.fine("Listing home set $homeSetUrl")
+
+                        try {
+                            DavResource(httpClient, homeSetUrl).propfind(1, *CollectionInfo.DAV_PROPERTIES) { response, _ ->
+                                if (!response.isSuccess())
+                                    return@propfind
+
+                                val info = CollectionInfo(response)
+                                info.confirmed = true
+                                Logger.log.log(Level.FINE, "Found collection", info)
+
+                                if ((serviceType == Services.SERVICE_CARDDAV && info.type == CollectionInfo.Type.ADDRESS_BOOK) ||
+                                    (serviceType == Services.SERVICE_CALDAV && arrayOf(CollectionInfo.Type.CALENDAR, CollectionInfo.Type.WEBCAL).contains(info.type)))
+                                    collections[response.href] = info
+                            }
+                        } catch(e: HttpException) {
+                            if (e.code in arrayOf(403, 404, 410))
+                                // delete home set only if it was not accessible (40x)
+                                itHomeSets.remove()
+                        }
+                    }
+
+                    // check/refresh unconfirmed collections
+                    val itCollections = collections.entries.iterator()
+                    while (itCollections.hasNext()) {
+                        val (url, info) = itCollections.next()
+                        if (!info.confirmed)
+                            try {
+                                DavResource(httpClient, url).propfind(0, *CollectionInfo.DAV_PROPERTIES) { response, _ ->
+                                    if (!response.isSuccess())
+                                        return@propfind
+
+                                    val collectionInfo = CollectionInfo(response)
+                                    collectionInfo.confirmed = true
+
+                                    // remove unusable collections
+                                    if ((serviceType == Services.SERVICE_CARDDAV && collectionInfo.type != CollectionInfo.Type.ADDRESS_BOOK) ||
+                                        (serviceType == Services.SERVICE_CALDAV && !arrayOf(CollectionInfo.Type.CALENDAR, CollectionInfo.Type.WEBCAL).contains(collectionInfo.type)) ||
+                                        (collectionInfo.type == CollectionInfo.Type.WEBCAL && collectionInfo.source == null))
+                                        itCollections.remove()
+                                }
+                            } catch(e: HttpException) {
+                                if (e.code in arrayOf(403, 404, 410))
+                                // delete collection only if it was not accessible (40x)
+                                    itCollections.remove()
+                                else
+                                    throw e
+                            }
+                    }
+
+                    // restore selections
+                    for (url in selectedCollections)
+                        collections[url]?.let { it.selected = true }
+                }
+
+                db.beginTransactionNonExclusive()
+                try {
+                    saveHomeSets()
+                    saveCollections()
+                    db.setTransactionSuccessful()
+                } finally {
+                    db.endTransaction()
+                }
+
+            } catch(e: InvalidAccountException) {
+                Logger.log.log(Level.SEVERE, "Invalid account", e)
+            } catch(e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't refresh collection list", e)
+
+                val debugIntent = Intent(this, DebugInfoActivity::class.java)
+                debugIntent.putExtra(DebugInfoActivity.KEY_THROWABLE, e)
+                debugIntent.putExtra(DebugInfoActivity.KEY_ACCOUNT, account)
+
+                val notify = NotificationUtils.newBuilder(this, NotificationUtils.CHANNEL_GENERAL)
+                        .setSmallIcon(R.drawable.ic_sync_error_notification)
+                        .setContentTitle(getString(R.string.dav_service_refresh_failed))
+                        .setContentText(getString(R.string.dav_service_refresh_couldnt_refresh))
+                        .setContentIntent(PendingIntent.getActivity(this, 0, debugIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+                        .setSubText(account.name)
+                        .setCategory(NotificationCompat.CATEGORY_ERROR)
+                        .build()
+                NotificationManagerCompat.from(this)
+                        .notify(service.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS, notify)
+            } finally {
+                runningRefresh.remove(service)
+                refreshingStatusListeners.forEach { it.get()?.onDavRefreshStatusChanged(service, false) }
+            }
+        }
+
+    }
+
+}

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

@@ -0,0 +1,82 @@
+/*
+ * 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.annotation.TargetApi
+import android.content.Context
+import android.net.ConnectivityManager
+import android.os.Build
+import at.bitfire.davdroid.log.Logger
+import okhttp3.HttpUrl
+import org.xbill.DNS.*
+import java.util.*
+
+/**
+ * Some WebDAV and related network utility methods
+ */
+object DavUtils {
+
+    fun ARGBtoCalDAVColor(colorWithAlpha: Int): String {
+        val alpha = (colorWithAlpha shr 24) and 0xFF
+        val color = colorWithAlpha and 0xFFFFFF
+        return String.format("#%06X%02X", color, alpha)
+    }
+
+    fun lastSegmentOfUrl(url: HttpUrl): String {
+        // the list returned by HttpUrl.pathSegments() is unmodifiable, so we have to create a copy
+        val segments = LinkedList<String>(url.pathSegments())
+        segments.reverse()
+
+        return segments.firstOrNull { it.isNotEmpty() } ?: "/"
+    }
+
+    fun prepareLookup(context: Context, lookup: Lookup) {
+        @TargetApi(Build.VERSION_CODES.O)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            /* Since Android 8, the system properties net.dns1, net.dns2, ... are not available anymore.
+               The current version of dnsjava relies on these properties to find the default name servers,
+               so we have to add the servers explicitly (fortunately, there's an Android API to
+               get the active DNS servers). */
+            val connectivity = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+            val activeLink = connectivity.getLinkProperties(connectivity.activeNetwork)
+            val simpleResolvers = activeLink.dnsServers.map {
+                Logger.log.fine("Using DNS server ${it.hostAddress}")
+                val resolver = SimpleResolver()
+                resolver.setAddress(it)
+                resolver
+            }
+            val resolver = ExtendedResolver(simpleResolvers.toTypedArray())
+            lookup.setResolver(resolver)
+        }
+    }
+
+    fun selectSRVRecord(records: Array<Record>?): SRVRecord? {
+        val srvRecords = records?.filterIsInstance(SRVRecord::class.java)
+        srvRecords?.let {
+            if (it.size > 1)
+                Logger.log.warning("Multiple SRV records not supported yet; using first one")
+            return it.firstOrNull()
+        }
+        return null
+    }
+
+    fun pathsFromTXTRecords(records: Array<Record>?): List<String> {
+        val paths = LinkedList<String>()
+        records?.filterIsInstance(TXTRecord::class.java)?.forEach { txt ->
+            @Suppress("UNCHECKED_CAST")
+            for (segment in txt.strings as List<String>)
+                if (segment.startsWith("path=")) {
+                    paths.add(segment.substring(5))
+                    break
+                }
+        }
+        return paths
+    }
+
+}

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

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

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

@@ -0,0 +1,13 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid
+
+import android.accounts.Account
+
+class InvalidAccountException(account: Account): Exception("Invalid account: $account")

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

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

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

@@ -0,0 +1,64 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid
+
+import android.accounts.Account
+import android.annotation.SuppressLint
+import android.content.BroadcastReceiver
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.model.ServiceDB.Services
+import at.bitfire.davdroid.resource.LocalTaskList
+import at.bitfire.ical4android.TaskProvider
+import at.bitfire.ical4android.TaskProvider.ProviderName.OpenTasks
+
+class PackageChangedReceiver: BroadcastReceiver() {
+
+    @SuppressLint("MissingPermission")
+    override fun onReceive(context: Context, intent: Intent) {
+        if (intent.action == Intent.ACTION_PACKAGE_ADDED || intent.action == Intent.ACTION_PACKAGE_FULLY_REMOVED)
+            updateTaskSync(context)
+    }
+
+
+    companion object {
+
+        fun updateTaskSync(context: Context) {
+            val tasksInstalled = LocalTaskList.tasksProviderAvailable(context)
+            Logger.log.info("Package (un)installed; OpenTasks provider now available = $tasksInstalled")
+
+            // check all accounts and (de)activate OpenTasks if a CalDAV service is defined
+            ServiceDB.OpenHelper(context).use { dbHelper ->
+                val db = dbHelper.readableDatabase
+
+                db.query(Services._TABLE, arrayOf(Services.ACCOUNT_NAME),
+                        "${Services.SERVICE}=?", arrayOf(Services.SERVICE_CALDAV), null, null, null)?.use { cursor ->
+                    while (cursor.moveToNext()) {
+                        val account = Account(cursor.getString(0), context.getString(R.string.account_type))
+
+                        if (tasksInstalled) {
+                            if (ContentResolver.getIsSyncable(account, OpenTasks.authority) <= 0) {
+                                ContentResolver.setIsSyncable(account, OpenTasks.authority, 1)
+                                ContentResolver.addPeriodicSync(account, OpenTasks.authority, Bundle(), Constants.DEFAULT_SYNC_INTERVAL)
+                            }
+                        } else
+                            ContentResolver.setIsSyncable(account, TaskProvider.ProviderName.OpenTasks.authority, 0)
+
+                    }
+                }
+            }
+        }
+
+    }
+
+}

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

@@ -0,0 +1,50 @@
+/*
+ * 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.log
+
+import android.util.Log
+
+import org.apache.commons.lang3.math.NumberUtils
+
+import java.util.logging.Handler
+import java.util.logging.Level
+import java.util.logging.LogRecord
+
+object LogcatHandler: Handler() {
+
+    private const val MAX_LINE_LENGTH = 3000
+
+    init {
+        formatter = PlainTextFormatter.LOGCAT
+        level = Level.ALL
+    }
+
+    override fun publish(r: LogRecord) {
+        val text = formatter.format(r)
+        val level = r.level.intValue()
+
+        val end = text.length
+        var pos = 0
+        while (pos < end) {
+            val line = text.substring(pos, NumberUtils.min(pos + MAX_LINE_LENGTH, end))
+            when {
+                level >= Level.SEVERE.intValue()  -> Log.e(r.loggerName, line)
+                level >= Level.WARNING.intValue() -> Log.w(r.loggerName, line)
+                level >= Level.CONFIG.intValue()  -> Log.i(r.loggerName, line)
+                level >= Level.FINER.intValue()   -> Log.d(r.loggerName, line)
+                else                              -> Log.v(r.loggerName, line)
+            }
+            pos += MAX_LINE_LENGTH
+        }
+    }
+
+    override fun flush() {}
+    override fun close() {}
+
+}

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

@@ -0,0 +1,137 @@
+/*
+ * 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.log
+
+import android.annotation.SuppressLint
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.SharedPreferences
+import android.preference.PreferenceManager
+import android.util.Log
+import android.widget.Toast
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.FileProvider
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.ui.AppSettingsActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import java.io.File
+import java.io.IOException
+import java.util.logging.FileHandler
+import java.util.logging.Level
+
+@SuppressLint("StaticFieldLeak")    // we'll only keep an app context
+object Logger : SharedPreferences.OnSharedPreferenceChangeListener {
+
+    private const val LOG_TO_FILE = "log_to_file"
+
+    val log = java.util.logging.Logger.getLogger("davx5")!!
+
+    private lateinit var context: Context
+    private lateinit var preferences: SharedPreferences
+
+    fun initialize(someContext: Context) {
+        context = someContext.applicationContext
+        preferences = PreferenceManager.getDefaultSharedPreferences(context)
+        preferences.registerOnSharedPreferenceChangeListener(this)
+
+        reinitialize()
+    }
+
+    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String) {
+        if (key == LOG_TO_FILE) {
+            log.info("Logging settings changed; re-initializing logger")
+            reinitialize()
+        }
+    }
+
+    private fun reinitialize() {
+        val logToFile = preferences.getBoolean(LOG_TO_FILE, false)
+        val logVerbose = logToFile || Log.isLoggable(log.name, Log.DEBUG)
+
+        log.info("Verbose logging: $logVerbose; to file: $logToFile")
+
+        // set logging level according to preferences
+        val rootLogger = java.util.logging.Logger.getLogger("")
+        rootLogger.level = if (logVerbose) Level.ALL else Level.INFO
+
+        // remove all handlers and add our own logcat handler
+        rootLogger.useParentHandlers = false
+        rootLogger.handlers.forEach { rootLogger.removeHandler(it) }
+        rootLogger.addHandler(LogcatHandler)
+
+        val nm = NotificationManagerCompat.from(context)
+        // log to external file according to preferences
+        if (logToFile) {
+            val builder = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_DEBUG)
+            builder .setSmallIcon(R.drawable.ic_sd_storage_notification)
+                    .setContentTitle(context.getString(R.string.logging_notification_title))
+
+            val logDir = debugDir(context) ?: return
+            val logFile = File(logDir, "davx5-log.txt")
+
+            try {
+                val fileHandler = FileHandler(logFile.toString(), true)
+                fileHandler.formatter = PlainTextFormatter.DEFAULT
+                rootLogger.addHandler(fileHandler)
+
+                val prefIntent = Intent(context, AppSettingsActivity::class.java)
+                prefIntent.putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, LOG_TO_FILE)
+                prefIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+                builder .setContentText(logDir.path)
+                        .setCategory(NotificationCompat.CATEGORY_STATUS)
+                        .setPriority(NotificationCompat.PRIORITY_HIGH)
+                        .setContentText(context.getString(R.string.logging_notification_text))
+                        .setContentIntent(PendingIntent.getActivity(context, 0, prefIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+                        .setOngoing(true)
+
+                // add "Share" action
+                val logFileUri = FileProvider.getUriForFile(context, context.getString(R.string.authority_debug_provider), logFile)
+                log.fine("Now logging to file: $logFile -> $logFileUri")
+
+                val shareIntent = Intent(Intent.ACTION_SEND)
+                shareIntent.putExtra(Intent.EXTRA_SUBJECT, "DAVx⁵ logs")
+                shareIntent.putExtra(Intent.EXTRA_STREAM, logFileUri)
+                shareIntent.type = "text/plain"
+                shareIntent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+                val chooserIntent = Intent.createChooser(shareIntent, null)
+                val shareAction = NotificationCompat.Action.Builder(R.drawable.ic_share_action_notification,
+                        context.getString(R.string.logging_notification_send_log),
+                        PendingIntent.getActivity(context, 0, chooserIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+                builder.addAction(shareAction.build())
+            } catch(e: IOException) {
+                log.log(Level.SEVERE, "Couldn't create log file", e)
+                Toast.makeText(context, context.getString(R.string.logging_couldnt_create_file), Toast.LENGTH_LONG).show()
+            }
+
+            nm.notify(NotificationUtils.NOTIFY_EXTERNAL_FILE_LOGGING, builder.build())
+        } else {
+            nm.cancel(NotificationUtils.NOTIFY_EXTERNAL_FILE_LOGGING)
+
+            // delete old logs
+            debugDir(context)?.deleteRecursively()
+        }
+    }
+
+
+    private fun debugDir(context: Context): File? {
+        val dir = File(context.filesDir, "debug")
+        if (dir.exists() && dir.isDirectory)
+            return dir
+
+        if (dir.mkdir())
+            return dir
+
+        Toast.makeText(context, context.getString(R.string.logging_couldnt_create_file), Toast.LENGTH_LONG).show()
+        return null
+    }
+
+}

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

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

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

@@ -0,0 +1,31 @@
+/*
+ * 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.log
+
+import java.util.logging.Handler
+import java.util.logging.LogRecord
+
+class StringHandler: Handler() {
+
+    val builder = StringBuilder()
+
+    init {
+        formatter = PlainTextFormatter.DEFAULT
+    }
+
+    override fun publish(record: LogRecord) {
+        builder.append(formatter.format(record))
+    }
+
+    override fun flush() {}
+    override fun close() {}
+
+    override fun toString() = builder.toString()
+
+}

app/src/main/java/at/bitfire/davdroid/model/CollectionInfo.kt

@@ -0,0 +1,258 @@
+/*
+ * 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.os.Parcel
+import android.os.Parcelable
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.UrlUtils
+import at.bitfire.dav4jvm.property.*
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.ical4android.MiscUtils
+import okhttp3.HttpUrl
+
+/**
+ * Represents a WebDAV collection.
+ *
+ * @constructor always appends a trailing slash to the URL
+ */
+data class CollectionInfo(
+
+        /**
+         * URL of the collection (including trailing slash)
+         */
+        val url: HttpUrl,
+
+        var id: Long? = null,
+        var serviceID: Long? = null,
+
+        var type: Type? = null,
+
+        var privWriteContent: Boolean = true,
+        var privUnbind: Boolean = true,
+        var forceReadOnly: Boolean = false,
+        var displayName: String? = null,
+        var description: String? = null,
+        var color: Int? = null,
+
+        var timeZone: String? = null,
+        var supportsVEVENT: Boolean = false,
+        var supportsVTODO: Boolean = false,
+        var supportsVJOURNAL: Boolean = false,
+        var selected: Boolean = false,
+
+        // subscriptions
+        var source: String? = null,
+
+        // non-persistent properties
+        var confirmed: Boolean = false
+): Parcelable {
+
+    enum class Type {
+        ADDRESS_BOOK,
+        CALENDAR,
+        WEBCAL          // iCalendar subscription
+    }
+
+    constructor(dav: Response): this(UrlUtils.withTrailingSlash(dav.href)) {
+        dav[ResourceType::class.java]?.let { type ->
+            when {
+                type.types.contains(ResourceType.ADDRESSBOOK) -> this.type = Type.ADDRESS_BOOK
+                type.types.contains(ResourceType.CALENDAR)    -> this.type = Type.CALENDAR
+                type.types.contains(ResourceType.SUBSCRIBED)  -> this.type = Type.WEBCAL
+            }
+        }
+
+        dav[CurrentUserPrivilegeSet::class.java]?.let { privilegeSet ->
+            privWriteContent = privilegeSet.mayWriteContent
+            privUnbind = privilegeSet.mayUnbind
+        }
+
+        dav[DisplayName::class.java]?.let {
+            if (!it.displayName.isNullOrEmpty())
+                displayName = it.displayName
+        }
+
+        when (type) {
+            Type.ADDRESS_BOOK -> {
+                dav[AddressbookDescription::class.java]?.let { description = it.description }
+            }
+            Type.CALENDAR, Type.WEBCAL -> {
+                dav[CalendarDescription::class.java]?.let { description = it.description }
+                dav[CalendarColor::class.java]?.let { color = it.color }
+                dav[CalendarTimezone::class.java]?.let { timeZone = it.vTimeZone }
+
+                if (type == Type.CALENDAR) {
+                    supportsVEVENT = true
+                    supportsVTODO = true
+                    dav[SupportedCalendarComponentSet::class.java]?.let {
+                        supportsVEVENT = it.supportsEvents
+                        supportsVTODO = it.supportsTasks
+                    }
+                } else { // Type.WEBCAL
+                    dav[Source::class.java]?.let { source = it.hrefs.firstOrNull() }
+                    supportsVEVENT = true
+                }
+            }
+        }
+    }
+
+
+    constructor(values: ContentValues): this(UrlUtils.withTrailingSlash(HttpUrl.parse(values.getAsString(Collections.URL))!!)) {
+        id = values.getAsLong(Collections.ID)
+        serviceID = values.getAsLong(Collections.SERVICE_ID)
+        type = try {
+            Type.valueOf(values.getAsString(Collections.TYPE))
+        } catch (e: Exception) {
+            null
+        }
+
+        privWriteContent = values.getAsInteger(Collections.PRIV_WRITE_CONTENT) != 0
+        privUnbind = values.getAsInteger(Collections.PRIV_UNBIND) != 0
+        forceReadOnly = values.getAsInteger(Collections.FORCE_READ_ONLY) != 0
+        displayName = values.getAsString(Collections.DISPLAY_NAME)
+        description = values.getAsString(Collections.DESCRIPTION)
+
+        color = values.getAsInteger(Collections.COLOR)
+
+        timeZone = values.getAsString(Collections.TIME_ZONE)
+        supportsVEVENT = getAsBooleanOrNull(values, Collections.SUPPORTS_VEVENT) ?: false
+        supportsVTODO = getAsBooleanOrNull(values, Collections.SUPPORTS_VTODO) ?: false
+
+        source = values.getAsString(Collections.SOURCE)
+
+        selected = values.getAsInteger(Collections.SYNC) != 0
+    }
+
+    fun toDB(): ContentValues {
+        val values = ContentValues()
+        // Collections.SERVICE_ID is never changed
+        type?.let { values.put(Collections.TYPE, it.name) }
+
+        values.put(Collections.URL, url.toString())
+        values.put(Collections.PRIV_WRITE_CONTENT, if (privWriteContent) 1 else 0)
+        values.put(Collections.PRIV_UNBIND, if (privUnbind) 1 else 0)
+        values.put(Collections.FORCE_READ_ONLY, if (forceReadOnly) 1 else 0)
+        values.put(Collections.DISPLAY_NAME, displayName)
+        values.put(Collections.DESCRIPTION, description)
+        values.put(Collections.COLOR, color)
+
+        values.put(Collections.TIME_ZONE, timeZone)
+        values.put(Collections.SUPPORTS_VEVENT, if (supportsVEVENT) 1 else 0)
+        values.put(Collections.SUPPORTS_VTODO, if (supportsVTODO) 1 else 0)
+
+        values.put(Collections.SOURCE, source)
+
+        values.put(Collections.SYNC, if (selected) 1 else 0)
+        return values
+    }
+
+    fun title() = displayName ?: DavUtils.lastSegmentOfUrl(url)
+
+
+    private fun getAsBooleanOrNull(values: ContentValues, field: String): Boolean? {
+        val i = values.getAsInteger(field)
+        return if (i == null)
+            null
+        else
+            (i != 0)
+    }
+
+
+    override fun describeContents(): Int = 0
+    override fun writeToParcel(dest: Parcel, flags: Int) {
+        fun<T> writeOrNull(value: T?, write: (T) -> Unit) {
+            if (value == null)
+                dest.writeByte(0)
+            else {
+                dest.writeByte(1)
+                write(value)
+            }
+        }
+
+        dest.writeString(url.toString())
+
+        writeOrNull(id) { dest.writeLong(it) }
+        writeOrNull(serviceID) { dest.writeLong(it) }
+
+        dest.writeString(type?.name)
+
+        dest.writeByte(if (privWriteContent) 1 else 0)
+        dest.writeByte(if (privUnbind) 1 else 0)
+
+        dest.writeByte(if (forceReadOnly) 1 else 0)
+        dest.writeString(displayName)
+        dest.writeString(description)
+        writeOrNull(color) { dest.writeInt(it) }
+
+        dest.writeString(timeZone)
+        dest.writeByte(if (supportsVEVENT) 1 else 0)
+        dest.writeByte(if (supportsVTODO) 1 else 0)
+        dest.writeByte(if (supportsVJOURNAL) 1 else 0)
+        dest.writeByte(if (selected) 1 else 0)
+
+        dest.writeString(source)
+
+        dest.writeByte(if (confirmed) 1 else 0)
+    }
+
+    companion object CREATOR : Parcelable.Creator<CollectionInfo> {
+
+        val DAV_PROPERTIES = arrayOf(
+                ResourceType.NAME,
+                CurrentUserPrivilegeSet.NAME,
+                DisplayName.NAME,
+                AddressbookDescription.NAME, SupportedAddressData.NAME,
+                CalendarDescription.NAME, CalendarColor.NAME, SupportedCalendarComponentSet.NAME,
+                Source.NAME
+        )
+
+        override fun createFromParcel(parcel: Parcel): CollectionInfo {
+            fun<T> readOrNull(parcel: Parcel, read: () -> T): T? {
+                return if (parcel.readByte() == 0.toByte())
+                    null
+                else
+                    read()
+            }
+
+            return CollectionInfo(
+                    HttpUrl.parse(parcel.readString()!!)!!,
+
+                    readOrNull(parcel) { parcel.readLong() },
+                    readOrNull(parcel) { parcel.readLong() },
+
+                    parcel.readString()?.let { Type.valueOf(it) },
+
+                    parcel.readByte() != 0.toByte(),
+                    parcel.readByte() != 0.toByte(),
+
+                    parcel.readByte() != 0.toByte(),
+                    parcel.readString(),
+                    parcel.readString(),
+                    readOrNull(parcel) { parcel.readInt() },
+
+                    parcel.readString(),
+                    parcel.readByte() != 0.toByte(),
+                    parcel.readByte() != 0.toByte(),
+                    parcel.readByte() != 0.toByte(),
+                    parcel.readByte() != 0.toByte(),
+
+                    parcel.readString(),
+
+                    parcel.readByte() != 0.toByte()
+            )
+        }
+
+        override fun newArray(size: Int) = arrayOfNulls<CollectionInfo>(size)
+
+    }
+
+}

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

@@ -0,0 +1,38 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid.model
+
+class Credentials(
+        val userName: String? = null,
+        val password: String? = null,
+        val certificateAlias: String? = null
+) {
+
+    enum class Type {
+        UsernamePassword,
+        ClientCertificate
+    }
+
+    val type: Type
+
+    init {
+        type = when {
+            !certificateAlias.isNullOrEmpty() ->
+                Type.ClientCertificate
+            !userName.isNullOrEmpty() && !password.isNullOrEmpty() ->
+                Type.UsernamePassword
+            else ->
+                throw IllegalArgumentException("Either username/password or certificate alias must be set")
+        }
+    }
+
+    override fun toString() =
+            "Credentials(type=$type, userName=$userName, certificateAlias=$certificateAlias)"
+
+}

app/src/main/java/at/bitfire/davdroid/model/ServiceDB.kt

@@ -0,0 +1,237 @@
+/*
+ * 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.content.Context
+import android.database.sqlite.SQLiteDatabase
+import android.database.sqlite.SQLiteException
+import android.database.sqlite.SQLiteOpenHelper
+import android.preference.PreferenceManager
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.ui.StartupDialogFragment
+import java.util.logging.Level
+
+@Suppress("ObjectPropertyName")
+class ServiceDB {
+
+    object Services {
+        const val _TABLE = "services"
+        const val ID = "_id"
+        const val ACCOUNT_NAME = "accountName"
+        const val SERVICE = "service"
+        const val PRINCIPAL = "principal"
+
+        // allowed values for SERVICE column
+        const val SERVICE_CALDAV = "caldav"
+        const val SERVICE_CARDDAV = "carddav"
+    }
+
+    object HomeSets {
+        const val _TABLE = "homesets"
+        const val ID = "_id"
+        const val SERVICE_ID = "serviceID"
+        const val URL = "url"
+    }
+
+    object Collections {
+        const val _TABLE = "collections"
+        const val ID = "_id"
+        const val TYPE = "type"
+        const val SERVICE_ID = "serviceID"
+        const val URL = "url"
+        const val PRIV_WRITE_CONTENT = "privWriteContent"
+        const val PRIV_UNBIND = "privUnbind"
+        const val FORCE_READ_ONLY = "forceReadOnly"
+        const val DISPLAY_NAME = "displayName"
+        const val DESCRIPTION = "description"
+        const val COLOR = "color"
+        const val TIME_ZONE = "timezone"
+        const val SUPPORTS_VEVENT = "supportsVEVENT"
+        const val SUPPORTS_VTODO = "supportsVTODO"
+        const val SOURCE = "source"
+        const val SYNC = "sync"
+    }
+
+    companion object {
+
+        fun onRenameAccount(db: SQLiteDatabase, oldName: String, newName: String) {
+            val values = ContentValues(1)
+            values.put(Services.ACCOUNT_NAME, newName)
+            db.updateWithOnConflict(Services._TABLE, values, Services.ACCOUNT_NAME + "=?", arrayOf(oldName), SQLiteDatabase.CONFLICT_REPLACE)
+        }
+
+    }
+
+
+    class OpenHelper(
+            val context: Context
+    ): SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION), AutoCloseable {
+
+        companion object {
+            const val DATABASE_NAME = "services.db"
+            const val DATABASE_VERSION = 5
+        }
+
+        override fun onConfigure(db: SQLiteDatabase) {
+            setWriteAheadLoggingEnabled(true)
+            db.setForeignKeyConstraintsEnabled(true)
+        }
+
+        override fun onCreate(db: SQLiteDatabase) {
+            Logger.log.info("Creating database " + db.path)
+
+            db.execSQL("CREATE TABLE ${Services._TABLE}(" +
+                    "${Services.ID} INTEGER PRIMARY KEY AUTOINCREMENT," +
+                    "${Services.ACCOUNT_NAME} TEXT NOT NULL," +
+                    "${Services.SERVICE} TEXT NOT NULL," +
+                    "${Services.PRINCIPAL} TEXT NULL)")
+            db.execSQL("CREATE UNIQUE INDEX services_account ON ${Services._TABLE} (${Services.ACCOUNT_NAME},${Services.SERVICE})")
+
+            db.execSQL("CREATE TABLE ${HomeSets._TABLE}(" +
+                    "${HomeSets.ID} INTEGER PRIMARY KEY AUTOINCREMENT," +
+                    "${HomeSets.SERVICE_ID} INTEGER NOT NULL REFERENCES ${Services._TABLE} ON DELETE CASCADE," +
+                    "${HomeSets.URL} TEXT NOT NULL)")
+            db.execSQL("CREATE UNIQUE INDEX homesets_service_url ON ${HomeSets._TABLE}(${HomeSets.SERVICE_ID},${HomeSets.URL})")
+
+            db.execSQL("CREATE TABLE ${Collections._TABLE}(" +
+                    "${Collections.ID} INTEGER PRIMARY KEY AUTOINCREMENT," +
+                    "${Collections.SERVICE_ID} INTEGER NOT NULL REFERENCES ${Services._TABLE} ON DELETE CASCADE," +
+                    "${Collections.TYPE} TEXT NOT NULL," +
+                    "${Collections.URL} TEXT NOT NULL," +
+                    "${Collections.PRIV_WRITE_CONTENT} INTEGER DEFAULT 0 NOT NULL," +
+                    "${Collections.PRIV_UNBIND} INTEGER DEFAULT 0 NOT NULL," +
+                    "${Collections.FORCE_READ_ONLY} INTEGER DEFAULT 0 NOT NULL," +
+                    "${Collections.DISPLAY_NAME} TEXT NULL," +
+                    "${Collections.DESCRIPTION} TEXT NULL," +
+                    "${Collections.COLOR} INTEGER NULL," +
+                    "${Collections.TIME_ZONE} TEXT NULL," +
+                    "${Collections.SUPPORTS_VEVENT} INTEGER NULL," +
+                    "${Collections.SUPPORTS_VTODO} INTEGER NULL," +
+                    "${Collections.SOURCE} TEXT NULL," +
+                    "${Collections.SYNC} INTEGER DEFAULT 0 NOT NULL)")
+            db.execSQL("CREATE UNIQUE INDEX collections_service_url ON ${Collections._TABLE}(${Collections.SERVICE_ID},${Collections.URL})")
+        }
+
+        override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
+            for (upgradeFrom in oldVersion until newVersion) {
+                val upgradeTo = upgradeFrom + 1
+                Logger.log.info("Upgrading database from version $upgradeFrom to $upgradeTo")
+                try {
+                    val upgradeProc = this::class.java.getDeclaredMethod("upgrade_${upgradeFrom}_$upgradeTo", SQLiteDatabase::class.java)
+                    upgradeProc.invoke(this, db)
+                } catch(e: Exception) {
+                    Logger.log.log(Level.SEVERE, "Couldn't upgrade database", e)
+                }
+            }
+        }
+
+        @Suppress("unused")
+        private fun upgrade_4_5(db: SQLiteDatabase) {
+            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.PRIV_WRITE_CONTENT} INTEGER DEFAULT 0 NOT NULL")
+            db.execSQL("UPDATE ${Collections._TABLE} SET ${Collections.PRIV_WRITE_CONTENT}=NOT readOnly")
+
+            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.PRIV_UNBIND} INTEGER DEFAULT 0 NOT NULL")
+            db.execSQL("UPDATE ${Collections._TABLE} SET ${Collections.PRIV_UNBIND}=NOT readOnly")
+
+            // there's no DROP COLUMN in SQLite, so just keep the "readOnly" column
+        }
+
+        @Suppress("unused")
+        private fun upgrade_3_4(db: SQLiteDatabase) {
+            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.FORCE_READ_ONLY} INTEGER DEFAULT 0 NOT NULL")
+        }
+
+        @Suppress("unused")
+        private fun upgrade_2_3(db: SQLiteDatabase) {
+            val edit = PreferenceManager.getDefaultSharedPreferences(context).edit()
+            try {
+                db.query("settings", arrayOf("setting", "value"), null, null, null, null, null).use { cursor ->
+                    while (cursor.moveToNext()) {
+                        when (cursor.getString(0)) {
+                            "distrustSystemCerts" -> edit.putBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES, cursor.getInt(1) != 0)
+                            "overrideProxy" -> edit.putBoolean(Settings.OVERRIDE_PROXY, cursor.getInt(1) != 0)
+                            "overrideProxyHost" -> edit.putString(Settings.OVERRIDE_PROXY_HOST, cursor.getString(1))
+                            "overrideProxyPort" -> edit.putInt(Settings.OVERRIDE_PROXY_PORT, cursor.getInt(1))
+
+                            /*StartupDialogFragment.HINT_GOOGLE_PLAY_ACCOUNTS_REMOVED ->
+                                edit.putBoolean(StartupDialogFragment.HINT_GOOGLE_PLAY_ACCOUNTS_REMOVED, cursor.getInt(1) != 0)*/
+                            StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED ->
+                                edit.putBoolean(StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED, cursor.getInt(1) != 0)
+                        }
+                    }
+                }
+                db.execSQL("DROP TABLE settings")
+            } finally {
+                edit.apply()
+            }
+        }
+
+        @Suppress("unused")
+        private fun upgrade_1_2(db: SQLiteDatabase) {
+            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.TYPE} TEXT NOT NULL DEFAULT ''")
+            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.SOURCE} TEXT NULL")
+            db.execSQL("UPDATE ${Collections._TABLE} SET ${Collections.TYPE}=(" +
+                    "SELECT CASE ${Services.SERVICE} WHEN ? THEN ? ELSE ? END " +
+                    "FROM ${Services._TABLE} WHERE ${Services.ID}=${Collections._TABLE}.${Collections.SERVICE_ID}" +
+                    ")",
+                    arrayOf(Services.SERVICE_CALDAV, CollectionInfo.Type.CALENDAR, CollectionInfo.Type.ADDRESS_BOOK))
+        }
+
+
+        fun dump(sb: StringBuilder) {
+            val db = readableDatabase
+            db.beginTransactionNonExclusive()
+
+            // iterate through all tables
+            db.query("sqlite_master", arrayOf("name"), "type='table'", null, null, null, null).use { cursorTables ->
+                while (cursorTables.moveToNext()) {
+                    val table = cursorTables.getString(0)
+                    sb.append(table).append("\n")
+                    db.query(table, null, null, null, null, null, null).use { cursor ->
+                        // print columns
+                        val cols = cursor.columnCount
+                        sb.append("\t| ")
+                        for (i in 0 until cols)
+                            sb  .append(" ")
+                                .append(cursor.getColumnName(i))
+                                .append(" |")
+                        sb.append("\n")
+
+                        // print rows
+                        while (cursor.moveToNext()) {
+                            sb.append("\t| ")
+                            for (i in 0 until cols) {
+                                sb.append(" ")
+                                try {
+                                    val value = cursor.getString(i)
+                                    if (value != null)
+                                        sb.append(value
+                                                .replace("\r", "<CR>")
+                                                .replace("\n", "<LF>"))
+                                    else
+                                        sb.append("<null>")
+
+                                } catch (e: SQLiteException) {
+                                    sb.append("<unprintable>")
+                                }
+                                sb.append(" |")
+                            }
+                            sb.append("\n")
+                        }
+                        sb.append("----------\n")
+                    }
+                }
+                db.endTransaction()
+            }
+        }
+    }
+
+}

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

@@ -1,22 +1,26 @@
 /*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ * 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.resource
+package at.bitfire.davdroid.model
 
-import at.bitfire.dav4jvm.property.webdav.SyncToken
+import at.bitfire.dav4jvm.property.SyncToken
 import org.json.JSONException
 import org.json.JSONObject
 
 data class SyncState(
-    val type: Type,
-    val value: String,
+        val type: Type,
+        val value: String,
 
-    /**
-     * Whether this sync state occurred during an initial sync as described
-     * in RFC 6578, which means the initial sync is not complete yet.
-     */
-    var initialSync: Boolean? = null
+        /**
+         * Whether this sync state occurred during an initial sync as described
+         * in RFC 6578, which means the initial sync is not complete yet.
+         */
+        var initialSync: Boolean? = null
 ) {
 
     companion object {

app/src/main/java/at/bitfire/davdroid/model/UnknownProperties.kt

@@ -1,8 +1,12 @@
 /*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ * 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.resource.contactrow
+package at.bitfire.davdroid.model
 
 import android.provider.ContactsContract.RawContacts
 

app/src/main/java/at/bitfire/davdroid/resource/LocalAddress.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.resource
+
+import at.bitfire.vcard4android.Contact
+
+interface LocalAddress: LocalResource<Contact> {
+
+    fun resetDeleted()
+
+}

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

@@ -0,0 +1,332 @@
+/*
+ * 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.resource
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.annotation.TargetApi
+import android.content.*
+import android.os.Build
+import android.os.Bundle
+import android.os.RemoteException
+import android.provider.ContactsContract
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership
+import android.provider.ContactsContract.Groups
+import android.provider.ContactsContract.RawContacts
+import android.util.Base64
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.vcard4android.*
+import java.io.ByteArrayOutputStream
+import java.util.*
+import java.util.logging.Level
+
+/**
+ * A local address book. Requires an own Android account, because Android manages contacts per
+ * account and there is no such thing as "address books". So, DAVx5 creates a "DAVx5
+ * address book" account for every CardDAV address book. These accounts are bound to a
+ * DAVx5 main account.
+ */
+class LocalAddressBook(
+        private val context: Context,
+        account: Account,
+        provider: ContentProviderClient?
+): AndroidAddressBook<LocalContact, LocalGroup>(account, provider, LocalContact.Factory, LocalGroup.Factory), LocalCollection<LocalAddress> {
+
+    companion object {
+
+        const val USER_DATA_MAIN_ACCOUNT_TYPE = "real_account_type"
+        const val USER_DATA_MAIN_ACCOUNT_NAME = "real_account_name"
+        const val USER_DATA_URL = "url"
+        const val USER_DATA_READ_ONLY = "read_only"
+
+        fun create(context: Context, provider: ContentProviderClient, mainAccount: Account, info: CollectionInfo): LocalAddressBook {
+            val accountManager = AccountManager.get(context)
+
+            val account = Account(accountName(mainAccount, info), context.getString(R.string.account_type_address_book))
+            if (!accountManager.addAccountExplicitly(account, null, initialUserData(mainAccount, info.url.toString())))
+                throw IllegalStateException("Couldn't create address book account")
+
+            val addressBook = LocalAddressBook(context, account, provider)
+            ContentResolver.setSyncAutomatically(account, ContactsContract.AUTHORITY, true)
+
+            // initialize Contacts Provider Settings
+            val values = ContentValues(2)
+            values.put(ContactsContract.Settings.SHOULD_SYNC, 1)
+            values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, 1)
+            addressBook.settings = values
+
+            return addressBook
+        }
+
+        fun findAll(context: Context, provider: ContentProviderClient?, mainAccount: Account?) = AccountManager.get(context)
+                .getAccountsByType(context.getString(R.string.account_type_address_book))
+                .map { LocalAddressBook(context, it, provider) }
+                .filter { mainAccount == null || it.mainAccount == mainAccount }
+                .toList()
+
+        fun accountName(mainAccount: Account, info: CollectionInfo): String {
+            val baos = ByteArrayOutputStream()
+            baos.write(info.url.hashCode())
+            val hash = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP or Base64.NO_PADDING)
+
+            val sb = StringBuilder(info.displayName.let {
+                if (it.isNullOrEmpty())
+                    DavUtils.lastSegmentOfUrl(info.url)
+                else
+                    it
+            })
+            sb.append(" (${mainAccount.name} $hash)")
+            return sb.toString()
+        }
+
+        fun initialUserData(mainAccount: Account, url: String): Bundle {
+            val bundle = Bundle(3)
+            bundle.putString(USER_DATA_MAIN_ACCOUNT_NAME, mainAccount.name)
+            bundle.putString(USER_DATA_MAIN_ACCOUNT_TYPE, mainAccount.type)
+            bundle.putString(USER_DATA_URL, url)
+            return bundle
+        }
+
+        fun mainAccount(context: Context, account: Account): Account =
+                if (account.type == context.getString(R.string.account_type_address_book)) {
+                    val manager = AccountManager.get(context)
+                    Account(
+                            manager.getUserData(account, USER_DATA_MAIN_ACCOUNT_NAME),
+                            manager.getUserData(account, USER_DATA_MAIN_ACCOUNT_TYPE)
+                    )
+                } else
+                    account
+
+    }
+
+    override val title = account.name!!
+
+    /**
+     * Whether contact groups ([LocalGroup]) are included in query results
+     * and are affected by updates/deletes on generic members.
+     *
+     * For instance, if this option is disabled, [findDirty] will find only dirty [LocalContact]s,
+     * but if it is enabled, [findDirty] will find dirty [LocalContact]s and [LocalGroup]s.
+     */
+    var includeGroups = true
+
+    private var _mainAccount: Account? = null
+    var mainAccount: Account
+        get() {
+            _mainAccount?.let { return it }
+
+            AccountManager.get(context).let { accountManager ->
+                val name = accountManager.getUserData(account, USER_DATA_MAIN_ACCOUNT_NAME)
+                val type = accountManager.getUserData(account, USER_DATA_MAIN_ACCOUNT_TYPE)
+                if (name != null && type != null)
+                    return Account(name, type)
+                else
+                    throw IllegalStateException("Address book doesn't exist anymore")
+            }
+        }
+        set(newMainAccount) {
+            AccountManager.get(context).let { accountManager ->
+                accountManager.setUserData(account, USER_DATA_MAIN_ACCOUNT_NAME, newMainAccount.name)
+                accountManager.setUserData(account, USER_DATA_MAIN_ACCOUNT_TYPE, newMainAccount.type)
+            }
+
+            _mainAccount = newMainAccount
+        }
+
+    var url: String
+        get() = AccountManager.get(context).getUserData(account, USER_DATA_URL)
+                ?: throw IllegalStateException("Address book has no URL")
+        set(url) = AccountManager.get(context).setUserData(account, USER_DATA_URL, url)
+
+    var readOnly: Boolean
+        get() = AccountManager.get(context).getUserData(account, USER_DATA_READ_ONLY) != null
+        set(readOnly) = AccountManager.get(context).setUserData(account, USER_DATA_READ_ONLY, if (readOnly) "1" else null)
+
+    override var lastSyncState: SyncState?
+        get() = syncState?.let { SyncState.fromString(String(it)) }
+        set(state) {
+            syncState = state?.toString()?.toByteArray()
+        }
+
+
+    /* operations on the collection (address book) itself */
+
+    override fun markNotDirty(flags: Int): Int {
+        val values = ContentValues(1)
+        values.put(LocalContact.COLUMN_FLAGS, flags)
+        var number = provider!!.update(rawContactsSyncUri(), values, "${RawContacts.DIRTY}=0", null)
+
+        if (includeGroups) {
+            values.clear()
+            values.put(LocalGroup.COLUMN_FLAGS, flags)
+            number += provider.update(groupsSyncUri(), values, "${Groups.DIRTY}=0", null)
+        }
+
+        return number
+    }
+
+    override fun removeNotDirtyMarked(flags: Int): Int {
+        var number = provider!!.delete(rawContactsSyncUri(),
+                "${RawContacts.DIRTY}=0 AND ${LocalContact.COLUMN_FLAGS}=?", arrayOf(flags.toString()))
+
+        if (includeGroups)
+            number += provider.delete(groupsSyncUri(),
+                    "${Groups.DIRTY}=0 AND ${LocalGroup.COLUMN_FLAGS}=?", arrayOf(flags.toString()))
+
+        return number
+    }
+
+    fun update(info: CollectionInfo) {
+        val newAccountName = accountName(mainAccount, info)
+
+        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+        if (account.name != newAccountName && Build.VERSION.SDK_INT >= 21) {
+            // no need to re-assign contacts to new account, because they will be deleted by contacts provider in any case
+            val accountManager = AccountManager.get(context)
+            val future = accountManager.renameAccount(account, newAccountName, null, null)
+            account = future.result
+        }
+
+        Constants.log.info("Address book write permission? = ${info.privWriteContent}")
+        readOnly = !info.privWriteContent || info.forceReadOnly
+
+        // make sure it will still be synchronized when contacts are updated
+        ContentResolver.setSyncAutomatically(account, ContactsContract.AUTHORITY, true)
+    }
+
+    fun delete() {
+        val accountManager = AccountManager.get(context)
+        @Suppress("DEPRECATION")
+        if (Build.VERSION.SDK_INT >= 22)
+            accountManager.removeAccount(account, null, null, null)
+        else
+            accountManager.removeAccount(account, null, null)
+    }
+
+
+    /* operations on members (contacts/groups) */
+
+    override fun findByName(name: String): LocalAddress? {
+        val result = queryContacts("${AndroidContact.COLUMN_FILENAME}=?", arrayOf(name)).firstOrNull()
+        return if (includeGroups)
+            result ?: queryGroups("${AndroidGroup.COLUMN_FILENAME}=?", arrayOf(name)).firstOrNull()
+        else
+            result
+    }
+
+
+    /**
+     * Returns an array of local contacts/groups which have been deleted locally. (DELETED != 0).
+     * @throws RemoteException on content provider errors
+     */
+    override fun findDeleted() =
+            if (includeGroups)
+                findDeletedContacts() + findDeletedGroups()
+            else
+                findDeletedContacts()
+
+    fun findDeletedContacts() = queryContacts("${RawContacts.DELETED}!=0", null)
+    fun findDeletedGroups() = queryGroups("${Groups.DELETED}!=0", null)
+
+    /**
+     * Returns an array of local contacts/groups which have been changed locally (DIRTY != 0).
+     * @throws RemoteException on content provider errors
+     */
+    override fun findDirty() =
+            if (includeGroups)
+                findDirtyContacts() + findDirtyGroups()
+            else
+                findDirtyContacts()
+
+    fun findDirtyContacts() = queryContacts("${RawContacts.DIRTY}!=0", null)
+    fun findDirtyGroups() = queryGroups("${Groups.DIRTY}!=0", null)
+
+
+    /**
+     * Queries all contacts with DIRTY flag and checks whether their data checksum has changed, i.e.
+     * if they're "really dirty" (= data has changed, not only metadata, which is not hashed).
+     * The DIRTY flag is removed from contacts which are not "really dirty", i.e. from contacts
+     * whose contact data checksum has not changed.
+     * @return number of "really dirty" contacts
+     * @throws RemoteException on content provider errors
+     */
+    fun verifyDirty(): Int {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N || Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+            throw IllegalStateException("verifyDirty() should not be called on Android != 7")
+
+        var reallyDirty = 0
+        for (contact in findDirtyContacts()) {
+            val lastHash = contact.getLastHashCode()
+            val currentHash = contact.dataHashCode()
+            if (lastHash == currentHash) {
+                // hash is code still the same, contact is not "really dirty" (only metadata been have changed)
+                Logger.log.log(Level.FINE, "Contact data hash has not changed, resetting dirty flag", contact)
+                contact.resetDirty()
+            } else {
+                Logger.log.log(Level.FINE, "Contact data has changed from hash $lastHash to $currentHash", contact)
+                reallyDirty++
+            }
+        }
+
+        if (includeGroups)
+            reallyDirty += findDirtyGroups().size
+
+        return reallyDirty
+    }
+
+    fun getByGroupMembership(groupID: Long): List<LocalContact> {
+        val ids = HashSet<Long>()
+        provider!!.query(syncAdapterURI(ContactsContract.Data.CONTENT_URI),
+                arrayOf(RawContacts.Data.RAW_CONTACT_ID),
+                "(${GroupMembership.MIMETYPE}=? AND ${GroupMembership.GROUP_ROW_ID}=?) OR (${CachedGroupMembership.MIMETYPE}=? AND ${CachedGroupMembership.GROUP_ID}=?)",
+                arrayOf(GroupMembership.CONTENT_ITEM_TYPE, groupID.toString(), CachedGroupMembership.CONTENT_ITEM_TYPE, groupID.toString()),
+                null)?.use { cursor ->
+            while (cursor.moveToNext())
+                ids += cursor.getLong(0)
+        }
+
+        return ids.map { findContactByID(it) }
+    }
+
+
+    /* special group operations */
+
+    /**
+     * Finds the first group with the given title. If there is no group with this
+     * title, a new group is created.
+     * @param title title of the group to look for
+     * @return id of the group with given title
+     * @throws RemoteException on content provider errors
+     */
+    fun findOrCreateGroup(title: String): Long {
+        provider!!.query(syncAdapterURI(Groups.CONTENT_URI), arrayOf(Groups._ID),
+                "${Groups.TITLE}=?", arrayOf(title), null)?.use { cursor ->
+            if (cursor.moveToNext())
+                return cursor.getLong(0)
+        }
+
+        val values = ContentValues(1)
+        values.put(Groups.TITLE, title)
+        val uri = provider.insert(syncAdapterURI(Groups.CONTENT_URI), values)
+        return ContentUris.parseId(uri)
+    }
+
+    fun removeEmptyGroups() {
+        // find groups without members
+        /** should be done using {@link Groups.SUMMARY_COUNT}, but it's not implemented in Android yet */
+        queryGroups(null, null).filter { it.getMembers().isEmpty() }.forEach { group ->
+            Logger.log.log(Level.FINE, "Deleting group", group)
+            group.delete()
+        }
+    }
+
+}

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

@@ -0,0 +1,225 @@
+/*
+ * 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.resource
+
+import android.accounts.Account
+import android.content.ContentProviderClient
+import android.content.ContentProviderOperation
+import android.content.ContentUris
+import android.content.ContentValues
+import android.net.Uri
+import android.provider.CalendarContract
+import android.provider.CalendarContract.*
+import at.bitfire.davdroid.Constants
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.ical4android.AndroidCalendar
+import at.bitfire.ical4android.AndroidCalendarFactory
+import at.bitfire.ical4android.BatchOperation
+import at.bitfire.ical4android.DateUtils
+import java.util.*
+import java.util.logging.Level
+
+class LocalCalendar private constructor(
+        account: Account,
+        provider: ContentProviderClient,
+        id: Long
+): AndroidCalendar<LocalEvent>(account, provider, LocalEvent.Factory, id), LocalCollection<LocalEvent> {
+
+    companion object {
+
+        private const val COLUMN_SYNC_STATE = Calendars.CAL_SYNC1
+
+        fun create(account: Account, provider: ContentProviderClient, info: CollectionInfo): Uri {
+            val values = valuesFromCollectionInfo(info, true)
+
+            // ACCOUNT_NAME and ACCOUNT_TYPE are required (see docs)! If it's missing, other apps will crash.
+            values.put(Calendars.ACCOUNT_NAME, account.name)
+            values.put(Calendars.ACCOUNT_TYPE, account.type)
+            values.put(Calendars.OWNER_ACCOUNT, account.name)
+
+            // flag as visible & synchronizable at creation, might be changed by user at any time
+            values.put(Calendars.VISIBLE, 1)
+            values.put(Calendars.SYNC_EVENTS, 1)
+            return create(account, provider, values)
+        }
+
+        private fun valuesFromCollectionInfo(info: CollectionInfo, withColor: Boolean): ContentValues {
+            val values = ContentValues()
+            values.put(Calendars.NAME, info.url.toString())
+            values.put(Calendars.CALENDAR_DISPLAY_NAME, if (info.displayName.isNullOrBlank()) DavUtils.lastSegmentOfUrl(info.url) else info.displayName)
+
+            if (withColor)
+                values.put(Calendars.CALENDAR_COLOR, info.color ?: Constants.DAVDROID_GREEN_RGBA)
+
+            if (info.privWriteContent && !info.forceReadOnly) {
+                values.put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_OWNER)
+                values.put(Calendars.CAN_MODIFY_TIME_ZONE, 1)
+                values.put(Calendars.CAN_ORGANIZER_RESPOND, 1)
+            } else
+                values.put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_READ)
+
+            info.timeZone?.let { tzData ->
+                try {
+                    val timeZone = DateUtils.parseVTimeZone(tzData)
+                    timeZone.timeZoneId?.let { tzId ->
+                        values.put(Calendars.CALENDAR_TIME_ZONE, DateUtils.findAndroidTimezoneID(tzId.value))
+                    }
+                } catch(e: IllegalArgumentException) {
+                    Logger.log.log(Level.WARNING, "Couldn't parse calendar default time zone", e)
+                }
+            }
+            values.put(Calendars.ALLOWED_REMINDERS, "${Reminders.METHOD_ALERT},${Reminders.METHOD_EMAIL}")
+            values.put(Calendars.ALLOWED_AVAILABILITY, "${Reminders.AVAILABILITY_TENTATIVE},${Reminders.AVAILABILITY_FREE},${Reminders.AVAILABILITY_BUSY}")
+            values.put(Calendars.ALLOWED_ATTENDEE_TYPES, "${CalendarContract.Attendees.TYPE_OPTIONAL},${CalendarContract.Attendees.TYPE_REQUIRED},${CalendarContract.Attendees.TYPE_RESOURCE}")
+            return values
+        }
+    }
+
+    override val title: String
+        get() = displayName ?: id.toString()
+
+    override var lastSyncState: SyncState?
+        get() = provider.query(calendarSyncURI(), arrayOf(COLUMN_SYNC_STATE), null, null, null)?.use { cursor ->
+                    if (cursor.moveToNext())
+                        return SyncState.fromString(cursor.getString(0))
+                    else
+                        null
+                }
+        set(state) {
+            val values = ContentValues(1)
+            values.put(COLUMN_SYNC_STATE, state.toString())
+            provider.update(calendarSyncURI(), values, null, null)
+        }
+
+
+    fun update(info: CollectionInfo, updateColor: Boolean) =
+            update(valuesFromCollectionInfo(info, updateColor))
+
+
+    override fun findDeleted() =
+            queryEvents("${Events.DELETED}!=0 AND ${Events.ORIGINAL_ID} IS NULL", null)
+
+    override fun findDirty(): List<LocalEvent> {
+        val dirty = LinkedList<LocalEvent>()
+
+        // get dirty events which are required to have an increased SEQUENCE value
+        for (localEvent in queryEvents("${Events.DIRTY}!=0 AND ${Events.ORIGINAL_ID} IS NULL", null)) {
+            val event = localEvent.event!!
+            val sequence = event.sequence
+            if (event.sequence == null)      // sequence has not been assigned yet (i.e. this event was just locally created)
+                event.sequence = 0
+            else if (localEvent.weAreOrganizer)
+                event.sequence = sequence!! + 1
+            dirty += localEvent
+        }
+
+        return dirty
+    }
+
+    override fun findByName(name: String) =
+            queryEvents("${Events._SYNC_ID}=?", arrayOf(name)).firstOrNull()
+
+
+    override fun markNotDirty(flags: Int): Int {
+        val values = ContentValues(1)
+        values.put(LocalEvent.COLUMN_FLAGS, flags)
+        return provider.update(eventsSyncURI(), values,
+                "${Events.CALENDAR_ID}=? AND ${Events.DIRTY}=0 AND ${Events.ORIGINAL_ID} IS NULL",
+                arrayOf(id.toString()))
+    }
+
+    override fun removeNotDirtyMarked(flags: Int) =
+            provider.delete(eventsSyncURI(),
+                    "${Events.CALENDAR_ID}=? AND ${Events.DIRTY}=0 AND ${Events.ORIGINAL_ID} IS NULL AND ${LocalEvent.COLUMN_FLAGS}=?",
+                    arrayOf(id.toString(), flags.toString()))
+
+
+    fun processDirtyExceptions() {
+        // process deleted exceptions
+        Logger.log.info("Processing deleted exceptions")
+        provider.query(
+                syncAdapterURI(Events.CONTENT_URI),
+                arrayOf(Events._ID, Events.ORIGINAL_ID, LocalEvent.COLUMN_SEQUENCE),
+                "${Events.CALENDAR_ID}=? AND ${Events.DELETED}!=0 AND ${Events.ORIGINAL_ID} IS NOT NULL",
+                arrayOf(id.toString()), null)?.use { cursor ->
+            while (cursor.moveToNext()) {
+                Logger.log.fine("Found deleted exception, removing and re-scheduling original event (if available)")
+                val id = cursor.getLong(0)             // can't be null (by definition)
+                val originalID = cursor.getLong(1)     // can't be null (by query)
+
+                val batch = BatchOperation(provider)
+
+                // get original event's SEQUENCE
+                provider.query(
+                        syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, originalID)),
+                        arrayOf(LocalEvent.COLUMN_SEQUENCE),
+                        null, null, null)?.use { cursor2 ->
+                    if (cursor2.moveToNext()) {
+                        // original event is available
+                        val originalSequence = if (cursor2.isNull(0)) 0 else cursor2.getInt(0)
+
+                        // re-schedule original event and set it to DIRTY
+                        batch.enqueue(BatchOperation.Operation(
+                                ContentProviderOperation.newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, originalID)))
+                                        .withValue(LocalEvent.COLUMN_SEQUENCE, originalSequence + 1)
+                                        .withValue(Events.DIRTY, 1)
+                        ))
+                    }
+                }
+
+                // completely remove deleted exception
+                batch.enqueue(BatchOperation.Operation(
+                        ContentProviderOperation.newDelete(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, id)))
+                ))
+                batch.commit()
+            }
+        }
+
+        // process dirty exceptions
+        Logger.log.info("Processing dirty exceptions")
+        provider.query(
+                syncAdapterURI(Events.CONTENT_URI),
+                arrayOf(Events._ID, Events.ORIGINAL_ID, LocalEvent.COLUMN_SEQUENCE),
+                "${Events.CALENDAR_ID}=? AND ${Events.DIRTY}!=0 AND ${Events.ORIGINAL_ID} IS NOT NULL",
+                arrayOf(id.toString()), null)?.use { cursor ->
+            while (cursor.moveToNext()) {
+                Logger.log.fine("Found dirty exception, increasing SEQUENCE to re-schedule")
+                val id = cursor.getLong(0)             // can't be null (by definition)
+                val originalID = cursor.getLong(1)     // can't be null (by query)
+                val sequence = if (cursor.isNull(2)) 0 else cursor.getInt(2)
+
+                val batch = BatchOperation(provider)
+                // original event to DIRTY
+                batch.enqueue(BatchOperation.Operation (
+                        ContentProviderOperation.newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, originalID)))
+                                .withValue(Events.DIRTY, 1)
+                ))
+                // increase SEQUENCE and set DIRTY to 0
+                batch.enqueue(BatchOperation.Operation (
+                        ContentProviderOperation.newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, id)))
+                                .withValue(LocalEvent.COLUMN_SEQUENCE, sequence + 1)
+                                .withValue(Events.DIRTY, 0)
+                ))
+                batch.commit()
+            }
+        }
+    }
+
+
+    object Factory: AndroidCalendarFactory<LocalCalendar> {
+
+        override fun newInstance(account: Account, provider: ContentProviderClient, id: Long) =
+            LocalCalendar(account, provider, id)
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/resource/LocalCollection.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.resource
+
+import android.provider.CalendarContract.Events
+import at.bitfire.davdroid.model.SyncState
+
+interface LocalCollection<out T: LocalResource<*>> {
+
+    /** collection title (used for user notifications etc.) **/
+    val title: String
+
+    var lastSyncState: SyncState?
+
+    fun findDeleted(): List<T>
+    fun findDirty(): List<T>
+
+    fun findByName(name: String): T?
+
+
+    /**
+     * Sets the [LocalEvent.COLUMN_FLAGS] value for entries which are not dirty ([Events.DIRTY] is 0)
+     * and have an [Events.ORIGINAL_ID] of null.
+     *
+     * @param flags    value of flags to set (for instance, [LocalResource.FLAG_REMOTELY_PRESENT]])
+     *
+     * @return         number of marked entries
+     */
+    fun markNotDirty(flags: Int): Int
+
+    /**
+     * Removes entries which are not dirty ([Events.DIRTY] is 0 and an [Events.ORIGINAL_ID] is null) with
+     * a given flag combination.
+     *
+     * @param flags    exact flags value to remove entries with (for instance, if this is [LocalResource.FLAG_REMOTELY_PRESENT]],
+     *                 all entries with exactly this flag will be removed)
+     *
+     * @return         number of removed entries
+     */
+    fun removeNotDirtyMarked(flags: Int): Int
+
+}

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

@@ -0,0 +1,253 @@
+/*
+ * 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.resource
+
+import android.content.ContentProviderOperation
+import android.content.ContentValues
+import android.os.Build
+import android.os.RemoteException
+import android.provider.ContactsContract
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership
+import android.provider.ContactsContract.RawContacts.Data
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.UnknownProperties
+import at.bitfire.vcard4android.*
+import ezvcard.Ezvcard
+import java.io.FileNotFoundException
+import java.util.*
+
+class LocalContact: AndroidContact, LocalAddress {
+
+    companion object {
+        init {
+            Contact.productID = "+//IDN bitfire.at//${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ez-vcard/" + Ezvcard.VERSION
+        }
+
+        const val COLUMN_FLAGS = ContactsContract.RawContacts.SYNC4
+        const val COLUMN_HASHCODE = ContactsContract.RawContacts.SYNC3
+    }
+
+    private val cachedGroupMemberships = HashSet<Long>()
+    private val groupMemberships = HashSet<Long>()
+
+    override var flags: Int = 0
+
+    constructor(addressBook: AndroidAddressBook<LocalContact,*>, values: ContentValues)
+            : super(addressBook, values) {
+        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
+    }
+
+    constructor(addressBook: AndroidAddressBook<LocalContact,*>, contact: Contact, fileName: String?, eTag: String?, flags: Int)
+            : super(addressBook, contact, fileName, eTag) {
+        this.flags = flags
+    }
+
+
+    override fun assignNameAndUID() {
+        val uid = UUID.randomUUID().toString()
+        val newFileName = "$uid.vcf"
+
+        val values = ContentValues(2)
+        values.put(COLUMN_FILENAME, newFileName)
+        values.put(COLUMN_UID, uid)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+
+        fileName = newFileName
+    }
+
+    override fun clearDirty(eTag: String?) {
+        val values = ContentValues(3)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(ContactsContract.RawContacts.DIRTY, 0)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
+            val hashCode = dataHashCode()
+            values.put(COLUMN_HASHCODE, hashCode)
+            Logger.log.finer("Clearing dirty flag with eTag = $eTag, contact hash = $hashCode")
+        }
+
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+
+        this.eTag = eTag
+    }
+
+    override fun resetDeleted() {
+        val values = ContentValues(1)
+        values.put(ContactsContract.Groups.DELETED, 0)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+    }
+
+    fun resetDirty() {
+        val values = ContentValues(1)
+        values.put(ContactsContract.RawContacts.DIRTY, 0)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+    }
+
+    override fun updateFlags(flags: Int) {
+        val values = ContentValues(1)
+        values.put(LocalContact.COLUMN_FLAGS, flags)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+
+        this.flags = flags
+    }
+
+
+    override fun populateData(mimeType: String, row: ContentValues) {
+        when (mimeType) {
+            CachedGroupMembership.CONTENT_ITEM_TYPE ->
+                cachedGroupMemberships += row.getAsLong(CachedGroupMembership.GROUP_ID)
+            GroupMembership.CONTENT_ITEM_TYPE ->
+                groupMemberships += row.getAsLong(GroupMembership.GROUP_ROW_ID)
+            UnknownProperties.CONTENT_ITEM_TYPE ->
+                contact!!.unknownProperties = row.getAsString(UnknownProperties.UNKNOWN_PROPERTIES)
+        }
+    }
+
+    override fun insertDataRows(batch: BatchOperation) {
+        super.insertDataRows(batch)
+
+        contact!!.unknownProperties?.let { unknownProperties ->
+            val op: BatchOperation.Operation
+            val builder = ContentProviderOperation.newInsert(dataSyncURI())
+            if (id == null)
+                op = BatchOperation.Operation(builder, UnknownProperties.RAW_CONTACT_ID, 0)
+            else {
+                op = BatchOperation.Operation(builder)
+                builder.withValue(UnknownProperties.RAW_CONTACT_ID, id)
+            }
+            builder .withValue(UnknownProperties.MIMETYPE, UnknownProperties.CONTENT_ITEM_TYPE)
+                    .withValue(UnknownProperties.UNKNOWN_PROPERTIES, unknownProperties)
+            batch.enqueue(op)
+        }
+    }
+
+
+    /**
+     * Calculates a hash code from the contact's data (VCard) and group memberships.
+     * Attention: re-reads {@link #contact} from the database, discarding all changes in memory
+     * @return hash code of contact data (including group memberships)
+     */
+    internal fun dataHashCode(): Int {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N || Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+            throw IllegalStateException("dataHashCode() should not be called on Android != 7")
+
+        // reset contact so that getContact() reads from database
+        contact = null
+
+        // groupMemberships is filled by getContact()
+        val dataHash = contact!!.hashCode()
+        val groupHash = groupMemberships.hashCode()
+        Logger.log.finest("Calculated data hash = $dataHash, group memberships hash = $groupHash")
+        return dataHash xor groupHash
+    }
+
+    fun updateHashCode(batch: BatchOperation?) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N || Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+            throw IllegalStateException("updateHashCode() should not be called on Android != 7")
+
+        val values = ContentValues(1)
+        val hashCode = dataHashCode()
+        Logger.log.fine("Storing contact hash = $hashCode")
+        values.put(COLUMN_HASHCODE, hashCode)
+
+        if (batch == null)
+            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+        else {
+            val builder = ContentProviderOperation
+                    .newUpdate(rawContactSyncURI())
+                    .withValues(values)
+            batch.enqueue(BatchOperation.Operation(builder))
+        }
+    }
+
+    fun getLastHashCode(): Int {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N || Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
+            throw IllegalStateException("getLastHashCode() should not be called on Android != 7")
+
+        addressBook.provider!!.query(rawContactSyncURI(), arrayOf(COLUMN_HASHCODE), null, null, null)?.use { c ->
+            if (c.moveToNext() && !c.isNull(0))
+                return c.getInt(0)
+        }
+        return 0
+    }
+
+
+    fun addToGroup(batch: BatchOperation, groupID: Long) {
+        batch.enqueue(BatchOperation.Operation(
+                ContentProviderOperation.newInsert(dataSyncURI())
+                        .withValue(GroupMembership.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE)
+                        .withValue(GroupMembership.RAW_CONTACT_ID, id)
+                        .withValue(GroupMembership.GROUP_ROW_ID, groupID)
+        ))
+        groupMemberships += groupID
+
+        batch.enqueue(BatchOperation.Operation(
+                ContentProviderOperation.newInsert(dataSyncURI())
+                        .withValue(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
+                        .withValue(CachedGroupMembership.RAW_CONTACT_ID, id)
+                        .withValue(CachedGroupMembership.GROUP_ID, groupID)
+                        .withYieldAllowed(true)
+        ))
+        cachedGroupMemberships += groupID
+    }
+
+    fun removeGroupMemberships(batch: BatchOperation) {
+        batch.enqueue(BatchOperation.Operation(
+                ContentProviderOperation.newDelete(dataSyncURI())
+                        .withSelection(
+                                Data.RAW_CONTACT_ID + "=? AND " + Data.MIMETYPE + " IN (?,?)",
+                                arrayOf(id.toString(), GroupMembership.CONTENT_ITEM_TYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
+                        )
+                        .withYieldAllowed(true)
+        ))
+        groupMemberships.clear()
+        cachedGroupMemberships.clear()
+    }
+
+    /**
+     * Returns the IDs of all groups the contact was member of (cached memberships).
+     * Cached memberships are kept in sync with memberships by DAVx5 and are used to determine
+     * whether a membership has been deleted/added when a raw contact is dirty.
+     * @return set of {@link GroupMembership#GROUP_ROW_ID} (may be empty)
+     * @throws FileNotFoundException if the current contact can't be found
+     * @throws RemoteException on contacts provider errors
+     */
+    fun getCachedGroupMemberships(): Set<Long> {
+        contact
+        return cachedGroupMemberships
+    }
+
+    /**
+     * Returns the IDs of all groups the contact is member of.
+     * @return set of {@link GroupMembership#GROUP_ROW_ID}s (may be empty)
+     * @throws FileNotFoundException if the current contact can't be found
+     * @throws RemoteException on contacts provider errors
+     */
+    fun getGroupMemberships(): Set<Long> {
+        contact
+        return groupMemberships
+    }
+
+
+    // data rows
+    override fun buildContact(builder: ContentProviderOperation.Builder, update: Boolean) {
+        builder.withValue(COLUMN_FLAGS, flags)
+        super.buildContact(builder, update)
+    }
+
+    // factory
+
+    object Factory: AndroidContactFactory<LocalContact> {
+        override fun fromProvider(addressBook: AndroidAddressBook<LocalContact, *>, values: ContentValues) =
+                LocalContact(addressBook, values)
+    }
+
+}

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

@@ -0,0 +1,131 @@
+/*
+ * 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.resource
+
+import android.content.ContentProviderOperation
+import android.content.ContentValues
+import android.provider.CalendarContract
+import android.provider.CalendarContract.Events
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.ical4android.*
+import net.fortuna.ical4j.model.property.ProdId
+import java.util.*
+
+class LocalEvent: AndroidEvent, LocalResource<Event> {
+
+    companion object {
+        init {
+            ICalendar.prodId = ProdId("+//IDN bitfire.at//${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ical4j/" + Constants.ical4jVersion)
+        }
+
+        const val COLUMN_ETAG = CalendarContract.Events.SYNC_DATA1
+        const val COLUMN_FLAGS = CalendarContract.Events.SYNC_DATA2
+        const val COLUMN_SEQUENCE = CalendarContract.Events.SYNC_DATA3
+    }
+
+    override var fileName: String? = null
+        private set
+
+    override var eTag: String? = null
+
+    override var flags: Int = 0
+        private set
+
+    var weAreOrganizer = true
+
+
+    constructor(calendar: AndroidCalendar<*>, event: Event, fileName: String?, eTag: String?, flags: Int): super(calendar, event) {
+        this.fileName = fileName
+        this.eTag = eTag
+        this.flags = flags
+    }
+
+    private constructor(calendar: AndroidCalendar<*>, values: ContentValues): super(calendar, values) {
+        fileName = values.getAsString(Events._SYNC_ID)
+        eTag = values.getAsString(COLUMN_ETAG)
+        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
+    }
+
+    override fun populateEvent(row: ContentValues) {
+        super.populateEvent(row)
+        val event = requireNotNull(event)
+
+        event.uid = row.getAsString(Events.UID_2445)
+        event.sequence = row.getAsInteger(COLUMN_SEQUENCE)
+
+        val isOrganizer = row.getAsInteger(Events.IS_ORGANIZER)
+        weAreOrganizer = isOrganizer != null && isOrganizer != 0
+    }
+
+    override fun buildEvent(recurrence: Event?, builder: ContentProviderOperation.Builder) {
+        super.buildEvent(recurrence, builder)
+        val event = requireNotNull(event)
+
+        val buildException = recurrence != null
+        val eventToBuild = recurrence ?: event
+
+        builder .withValue(Events.UID_2445, event.uid)
+                .withValue(COLUMN_SEQUENCE, eventToBuild.sequence)
+                .withValue(CalendarContract.Events.DIRTY, 0)
+                .withValue(CalendarContract.Events.DELETED, 0)
+                .withValue(LocalEvent.COLUMN_FLAGS, flags)
+
+        if (buildException)
+            builder .withValue(Events.ORIGINAL_SYNC_ID, fileName)
+        else
+            builder .withValue(Events._SYNC_ID, fileName)
+                    .withValue(COLUMN_ETAG, eTag)
+    }
+
+
+    override fun assignNameAndUID() {
+        var uid: String? = null
+        calendar.provider.query(eventSyncURI(), arrayOf(Events.UID_2445), null, null, null)?.use { cursor ->
+            if (cursor.moveToNext())
+                uid = cursor.getString(0)
+        }
+        if (uid == null)
+            uid = UUID.randomUUID().toString()
+
+        val newFileName = "$uid.ics"
+
+        val values = ContentValues(2)
+        values.put(Events._SYNC_ID, newFileName)
+        values.put(Events.UID_2445, uid)
+        calendar.provider.update(eventSyncURI(), values, null, null)
+
+        fileName = newFileName
+        event!!.uid = uid
+    }
+
+    override fun clearDirty(eTag: String?) {
+        val values = ContentValues(2)
+        values.put(CalendarContract.Events.DIRTY, 0)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(COLUMN_SEQUENCE, event!!.sequence)
+        calendar.provider.update(eventSyncURI(), values, null, null)
+
+        this.eTag = eTag
+    }
+
+    override fun updateFlags(flags: Int) {
+        val values = ContentValues(1)
+        values.put(COLUMN_FLAGS, flags)
+        calendar.provider.update(eventSyncURI(), values, null, null)
+
+        this.flags = flags
+    }
+
+
+    object Factory: AndroidEventFactory<LocalEvent> {
+        override fun fromProvider(calendar: AndroidCalendar<*>, values: ContentValues) =
+                LocalEvent(calendar, values)
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/resource/LocalGroup.kt

@@ -0,0 +1,246 @@
+/*
+ * 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.resource
+
+import android.content.ContentProviderOperation
+import android.content.ContentUris
+import android.content.ContentValues
+import android.net.Uri
+import android.os.Build
+import android.os.Parcel
+import android.os.RemoteException
+import android.provider.ContactsContract
+import android.provider.ContactsContract.CommonDataKinds.GroupMembership
+import android.provider.ContactsContract.Groups
+import android.provider.ContactsContract.RawContacts
+import android.provider.ContactsContract.RawContacts.Data
+import at.bitfire.dav4jvm.Constants
+import at.bitfire.vcard4android.*
+import java.util.*
+
+class LocalGroup: AndroidGroup, LocalAddress {
+
+    companion object {
+
+        const val COLUMN_FLAGS = Groups.SYNC4
+
+        /** marshaled list of member UIDs, as sent by server */
+        const val COLUMN_PENDING_MEMBERS = Groups.SYNC3
+
+        /**
+         * Processes all groups with non-null {@link #COLUMN_PENDING_MEMBERS}: the pending memberships
+         * are (if possible) applied, keeping cached memberships in sync.
+         * @param addressBook    address book to take groups from
+         */
+        fun applyPendingMemberships(addressBook: LocalAddressBook) {
+            addressBook.provider!!.query(
+                    addressBook.groupsSyncUri(),
+                    arrayOf(Groups._ID, COLUMN_PENDING_MEMBERS),
+                    "$COLUMN_PENDING_MEMBERS IS NOT NULL", null,
+                    null
+            )?.use { cursor ->
+                val batch = BatchOperation(addressBook.provider)
+                while (cursor.moveToNext()) {
+                    val id = cursor.getLong(0)
+                    Constants.log.fine("Assigning members to group $id")
+
+                    // required for workaround for Android 7 which sets DIRTY flag when only meta-data is changed
+                    val changeContactIDs = HashSet<Long>()
+
+                    // delete all memberships and cached memberships for this group
+                    for (contact in addressBook.getByGroupMembership(id)) {
+                        contact.removeGroupMemberships(batch)
+                        changeContactIDs += contact.id!!
+                    }
+
+                    // extract list of member UIDs
+                    val members = LinkedList<String>()
+                    val raw = cursor.getBlob(1)
+                    val parcel = Parcel.obtain()
+                    try {
+                        parcel.unmarshall(raw, 0, raw.size)
+                        parcel.setDataPosition(0)
+                        parcel.readStringList(members)
+                    } finally {
+                        parcel.recycle()
+                    }
+
+                    // insert memberships
+                    for (uid in members) {
+                        Constants.log.fine("Assigning member: $uid")
+                        addressBook.findContactByUID(uid)?.let { member ->
+                            member.addToGroup(batch, id)
+                            changeContactIDs += member.id!!
+                        } ?: Constants.log.warning("Group member not found: $uid")
+                    }
+
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+                        // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
+                        changeContactIDs
+                                .map { addressBook.findContactByID(it) }
+                                .forEach { it.updateHashCode(batch) }
+
+                    // remove pending memberships
+                    batch.enqueue(BatchOperation.Operation(
+                            ContentProviderOperation.newUpdate(addressBook.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, id)))
+                                    .withValue(COLUMN_PENDING_MEMBERS, null)
+                                    .withYieldAllowed(true)
+                            ))
+
+                    batch.commit()
+                }
+            }
+        }
+
+    }
+
+
+    override var flags: Int = 0
+
+
+    constructor(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, values: ContentValues)
+        : super(addressBook, values) {
+        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
+    }
+
+    constructor(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, contact: Contact, fileName: String?, eTag: String?, flags: Int)
+        : super(addressBook, contact, fileName, eTag) {
+        this.flags = flags
+    }
+
+
+    override fun contentValues(): ContentValues  {
+        val values = super.contentValues()
+        values.put(COLUMN_FLAGS, flags)
+
+        val members = Parcel.obtain()
+        try {
+            members.writeStringList(contact!!.members)
+            values.put(COLUMN_PENDING_MEMBERS, members.marshall())
+        } finally {
+            members.recycle()
+        }
+        return values
+    }
+
+
+    override fun assignNameAndUID() {
+        val uid = UUID.randomUUID().toString()
+        val newFileName = "$uid.vcf"
+
+        val values = ContentValues(2)
+        values.put(COLUMN_FILENAME, newFileName)
+        values.put(COLUMN_UID, uid)
+        update(values)
+
+        fileName = newFileName
+    }
+
+    override fun clearDirty(eTag: String?) {
+        val id = requireNotNull(id)
+
+        val values = ContentValues(2)
+        values.put(Groups.DIRTY, 0)
+        values.put(COLUMN_ETAG, eTag)
+        this.eTag = eTag
+        update(values)
+
+        // update cached group memberships
+        val batch = BatchOperation(addressBook.provider!!)
+
+        // delete cached group memberships
+        batch.enqueue(BatchOperation.Operation(
+                ContentProviderOperation.newDelete(addressBook.syncAdapterURI(ContactsContract.Data.CONTENT_URI))
+                        .withSelection(
+                                CachedGroupMembership.MIMETYPE + "=? AND " + CachedGroupMembership.GROUP_ID + "=?",
+                                arrayOf(CachedGroupMembership.CONTENT_ITEM_TYPE, id.toString())
+                        )
+        ))
+
+        // insert updated cached group memberships
+        for (member in getMembers())
+            batch.enqueue(BatchOperation.Operation(
+                    ContentProviderOperation.newInsert(addressBook.syncAdapterURI(ContactsContract.Data.CONTENT_URI))
+                            .withValue(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
+                            .withValue(CachedGroupMembership.RAW_CONTACT_ID, member)
+                            .withValue(CachedGroupMembership.GROUP_ID, id)
+                            .withYieldAllowed(true)
+            ))
+
+        batch.commit()
+    }
+
+    /**
+     * Marks all members of the current group as dirty.
+     */
+    fun markMembersDirty() {
+        val batch = BatchOperation(addressBook.provider!!)
+
+        for (member in getMembers())
+            batch.enqueue(BatchOperation.Operation(
+                    ContentProviderOperation.newUpdate(addressBook.syncAdapterURI(ContentUris.withAppendedId(RawContacts.CONTENT_URI, member)))
+                            .withValue(RawContacts.DIRTY, 1)
+                            .withYieldAllowed(true)
+            ))
+
+        batch.commit()
+    }
+
+    override fun resetDeleted() {
+        val values = ContentValues(1)
+        values.put(Groups.DELETED, 0)
+        addressBook.provider!!.update(groupSyncUri(), values, null, null)
+    }
+
+    override fun updateFlags(flags: Int) {
+        val values = ContentValues(1)
+        values.put(LocalGroup.COLUMN_FLAGS, flags)
+        addressBook.provider!!.update(groupSyncUri(), values, null, null)
+
+        this.flags = flags
+    }
+
+
+    // helpers
+
+    private fun groupSyncUri(): Uri {
+        val id = requireNotNull(id)
+        return ContentUris.withAppendedId(addressBook.groupsSyncUri(), id)
+    }
+
+    /**
+     * Lists all members of this group.
+     * @return list of all members' raw contact IDs
+     * @throws RemoteException on contact provider errors
+     */
+    internal fun getMembers(): List<Long> {
+        val id = requireNotNull(id)
+        val members = LinkedList<Long>()
+        addressBook.provider!!.query(
+                addressBook.syncAdapterURI(ContactsContract.Data.CONTENT_URI),
+                arrayOf(Data.RAW_CONTACT_ID),
+                "${GroupMembership.MIMETYPE}=? AND ${GroupMembership.GROUP_ROW_ID}=?",
+                arrayOf(GroupMembership.CONTENT_ITEM_TYPE, id.toString()),
+                null
+        )?.use { cursor ->
+            while (cursor.moveToNext())
+                members += cursor.getLong(0)
+        }
+        return members
+    }
+
+
+    // factory
+
+    object Factory: AndroidGroupFactory<LocalGroup> {
+        override fun fromProvider(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, values: ContentValues) =
+                LocalGroup(addressBook, values)
+    }
+
+}

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

@@ -0,0 +1,57 @@
+/*
+ * 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.resource
+
+import android.net.Uri
+
+interface LocalResource<in TData: Any> {
+
+    companion object {
+        /**
+         * Resource is present on remote server. This flag is used to identify resources
+         * which are not present on the remote server anymore and can be deleted at the end
+         * of the synchronization.
+         */
+        const val FLAG_REMOTELY_PRESENT = 1
+    }
+
+
+    /**
+     * Unique ID which identifies the resource in the local storage. May be null if the
+     * resource has not been saved yet.
+     */
+    val id: Long?
+
+    val fileName: String?
+    var eTag: String?
+    val flags: Int
+
+    fun assignNameAndUID()
+    fun clearDirty(eTag: String?)
+    fun updateFlags(flags: Int)
+
+    /**
+     * Adds the data object to the content provider and ensures that the dirty flag is clear.
+     * @return content URI of the created row (e.g. event URI)
+     */
+    fun add(): Uri
+
+    /**
+     * Updates the data object in the content provider and ensures that the dirty flag is clear.
+     * @return content URI of the updated row (e.g. event URI)
+     */
+    fun update(data: TData): Uri
+
+    /**
+     * Deletes the data object from the content provider.
+     * @return number of affected rows
+     */
+    fun delete(): Int
+
+}

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

@@ -0,0 +1,101 @@
+/*
+ * 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.resource
+
+import android.content.ContentProviderOperation
+import android.content.ContentValues
+import at.bitfire.ical4android.AndroidTask
+import at.bitfire.ical4android.AndroidTaskFactory
+import at.bitfire.ical4android.AndroidTaskList
+import at.bitfire.ical4android.Task
+import org.dmfs.tasks.contract.TaskContract.Tasks
+import java.util.*
+
+class LocalTask: AndroidTask, LocalResource<Task> {
+
+    companion object {
+        const val COLUMN_ETAG = Tasks.SYNC1
+        const val COLUMN_FLAGS = Tasks.SYNC2
+    }
+
+    override var fileName: String? = null
+    override var eTag: String? = null
+
+    override var flags = 0
+        private set
+
+
+    constructor(taskList: AndroidTaskList<*>, task: Task, fileName: String?, eTag: String?, flags: Int)
+            : super(taskList, task) {
+        this.fileName = fileName
+        this.eTag = eTag
+        this.flags = flags
+    }
+
+    private constructor(taskList: AndroidTaskList<*>, values: ContentValues): super(taskList) {
+        id = values.getAsLong(Tasks._ID)
+        fileName = values.getAsString(Tasks._SYNC_ID)
+        eTag = values.getAsString(COLUMN_ETAG)
+        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
+    }
+
+
+    /* process LocalTask-specific fields */
+
+    override fun buildTask(builder: ContentProviderOperation.Builder, update: Boolean) {
+        super.buildTask(builder, update)
+
+        builder .withValue(Tasks._SYNC_ID, fileName)
+                .withValue(COLUMN_ETAG, eTag)
+                .withValue(COLUMN_FLAGS, flags)
+    }
+
+
+    /* custom queries */
+
+    override fun assignNameAndUID() {
+        val uid = UUID.randomUUID().toString()
+        val newFileName = "$uid.ics"
+
+        val values = ContentValues(2)
+        values.put(Tasks._SYNC_ID, newFileName)
+        values.put(Tasks._UID, uid)
+        taskList.provider.client.update(taskSyncURI(), values, null, null)
+
+        fileName = newFileName
+
+        task!!.uid = uid
+    }
+
+    override fun clearDirty(eTag: String?) {
+        val values = ContentValues(3)
+        values.put(Tasks._DIRTY, 0)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(Tasks.SYNC_VERSION, task!!.sequence)
+        taskList.provider.client.update(taskSyncURI(), values, null, null)
+
+        this.eTag = eTag
+    }
+
+    override fun updateFlags(flags: Int) {
+        if (id != null) {
+            val values = ContentValues(1)
+            values.put(COLUMN_FLAGS, flags)
+            taskList.provider.client.update(taskSyncURI(), values, null, null)
+        }
+
+        this.flags = flags
+    }
+
+
+    object Factory: AndroidTaskFactory<LocalTask> {
+        override fun fromProvider(taskList: AndroidTaskList<*>, values: ContentValues) =
+                LocalTask(taskList, values)
+    }
+}

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

@@ -0,0 +1,159 @@
+/*
+ * 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.resource
+
+import android.accounts.Account
+import android.annotation.SuppressLint
+import android.content.ContentProviderClient
+import android.content.ContentResolver
+import android.content.ContentValues
+import android.content.Context
+import android.net.Uri
+import android.os.Build
+import at.bitfire.davdroid.Constants
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.ical4android.AndroidTaskList
+import at.bitfire.ical4android.AndroidTaskListFactory
+import at.bitfire.ical4android.TaskProvider
+import org.dmfs.tasks.contract.TaskContract.TaskLists
+import org.dmfs.tasks.contract.TaskContract.Tasks
+import java.util.logging.Level
+
+class LocalTaskList private constructor(
+        account: Account,
+        provider: TaskProvider,
+        id: Long
+): AndroidTaskList<LocalTask>(account, provider, LocalTask.Factory, id), LocalCollection<LocalTask> {
+
+    companion object {
+
+        fun tasksProviderAvailable(context: Context): Boolean {
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+                return context.packageManager.resolveContentProvider(TaskProvider.ProviderName.OpenTasks.authority, 0) != null
+            else {
+                val provider = TaskProvider.acquire(context, TaskProvider.ProviderName.OpenTasks)
+                provider?.use { return true }
+                return false
+            }
+        }
+
+        fun create(account: Account, provider: TaskProvider, info: CollectionInfo): Uri {
+            val values = valuesFromCollectionInfo(info, true)
+            values.put(TaskLists.OWNER, account.name)
+            values.put(TaskLists.SYNC_ENABLED, 1)
+            values.put(TaskLists.VISIBLE, 1)
+            return create(account, provider, values)
+        }
+
+        @SuppressLint("Recycle")
+        @Throws(Exception::class)
+        fun onRenameAccount(resolver: ContentResolver, oldName: String, newName: String) {
+            var client: ContentProviderClient? = null
+            try {
+                client = resolver.acquireContentProviderClient(TaskProvider.ProviderName.OpenTasks.authority)
+                client?.use {
+                    val values = ContentValues(1)
+                    values.put(Tasks.ACCOUNT_NAME, newName)
+                    it.update(Tasks.getContentUri(TaskProvider.ProviderName.OpenTasks.authority), values, "${Tasks.ACCOUNT_NAME}=?", arrayOf(oldName))
+                }
+            } finally {
+                @Suppress("DEPRECATION")
+                if (Build.VERSION.SDK_INT >= 24)
+                    client?.close()
+                else
+                    client?.release()
+            }
+        }
+
+        private fun valuesFromCollectionInfo(info: CollectionInfo, withColor: Boolean): ContentValues {
+            val values = ContentValues(3)
+            values.put(TaskLists._SYNC_ID, info.url.toString())
+            values.put(TaskLists.LIST_NAME, if (info.displayName.isNullOrBlank()) DavUtils.lastSegmentOfUrl(info.url) else info.displayName)
+
+            if (withColor)
+                values.put(TaskLists.LIST_COLOR, info.color ?: Constants.DAVDROID_GREEN_RGBA)
+
+            return values
+        }
+
+    }
+
+    override val title: String
+        get() = name ?: id.toString()
+
+    override var lastSyncState: SyncState?
+        get() {
+            try {
+                provider.client.query(taskListSyncUri(), arrayOf(TaskLists.SYNC_VERSION),
+                        null, null, null)?.use { cursor ->
+                    if (cursor.moveToNext())
+                        cursor.getString(0)?.let {
+                            return SyncState.fromString(it)
+                        }
+                }
+            } catch (e: Exception) {
+                Logger.log.log(Level.WARNING, "Couldn't read sync state", e)
+            }
+            return null
+        }
+        set(state) {
+            val values = ContentValues(1)
+            values.put(TaskLists.SYNC_VERSION, state?.toString())
+            provider.client.update(taskListSyncUri(), values, null, null)
+        }
+
+
+    fun update(info: CollectionInfo, updateColor: Boolean) =
+            update(valuesFromCollectionInfo(info, updateColor))
+
+
+    override fun findDeleted() = queryTasks("${Tasks._DELETED}!=0", null)
+
+    override fun findDirty(): List<LocalTask> {
+        val tasks = queryTasks("${Tasks._DIRTY}!=0", null)
+        for (localTask in tasks) {
+            val task = requireNotNull(localTask.task)
+            val sequence = task.sequence
+            if (sequence == null)    // sequence has not been assigned yet (i.e. this task was just locally created)
+                task.sequence = 0
+            else
+                task.sequence = sequence + 1
+        }
+        return tasks
+    }
+
+    override fun findByName(name: String) =
+            queryTasks("${Tasks._SYNC_ID}=?", arrayOf(name)).firstOrNull()
+
+
+    override fun markNotDirty(flags: Int): Int {
+        val values = ContentValues(1)
+        values.put(LocalTask.COLUMN_FLAGS, flags)
+        return provider.client.update(tasksSyncUri(), values,
+                "${Tasks.LIST_ID}=? AND ${Tasks._DIRTY}=0",
+                arrayOf(id.toString()))
+    }
+
+    override fun removeNotDirtyMarked(flags: Int) =
+            provider.client.delete(tasksSyncUri(),
+                    "${Tasks.LIST_ID}=? AND ${Tasks._DIRTY}=0 AND ${LocalTask.COLUMN_FLAGS}=?",
+                    arrayOf(id.toString(), flags.toString()))
+
+
+    object Factory: AndroidTaskListFactory<LocalTaskList> {
+
+        override fun newInstance(account: Account, provider: TaskProvider, id: Long) =
+                LocalTaskList(account, provider, id)
+
+    }
+
+}

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

@@ -0,0 +1,568 @@
+/*
+ * 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.accounts.Account
+import android.accounts.AccountManager
+import android.annotation.SuppressLint
+import android.content.*
+import android.os.Build
+import android.os.Bundle
+import android.os.Parcel
+import android.os.RemoteException
+import android.provider.CalendarContract
+import android.provider.ContactsContract
+import at.bitfire.davdroid.*
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.Credentials
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.model.ServiceDB.*
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.resource.LocalCalendar
+import at.bitfire.davdroid.resource.LocalTaskList
+import at.bitfire.ical4android.AndroidCalendar
+import at.bitfire.ical4android.AndroidTaskList
+import at.bitfire.ical4android.CalendarStorageException
+import at.bitfire.ical4android.TaskProvider
+import at.bitfire.ical4android.TaskProvider.ProviderName.OpenTasks
+import at.bitfire.vcard4android.ContactsStorageException
+import at.bitfire.vcard4android.GroupMethod
+import okhttp3.HttpUrl
+import org.apache.commons.lang3.StringUtils
+import org.dmfs.tasks.contract.TaskContract
+import java.util.*
+import java.util.logging.Level
+
+/**
+ * Manages settings of an account.
+ *
+ * @throws InvalidAccountException on construction when the account doesn't exist (anymore)
+ */
+class AccountSettings(
+        val context: Context,
+        val account: Account
+) {
+
+    companion object {
+
+        const val CURRENT_VERSION = 9
+        const val KEY_SETTINGS_VERSION = "version"
+
+        const val KEY_USERNAME = "user_name"
+        const val KEY_CERTIFICATE_ALIAS = "certificate_alias"
+
+        const val KEY_WIFI_ONLY = "wifi_only"               // sync on WiFi only (default: false)
+        const val WIFI_ONLY_DEFAULT = false
+        const val KEY_WIFI_ONLY_SSIDS = "wifi_only_ssids"   // restrict sync to specific WiFi SSIDs
+
+        /** Time range limitation to the past [in days]
+        value = null            default value (DEFAULT_TIME_RANGE_PAST_DAYS)
+        < 0 (-1)          no limit
+        >= 0              entries more than n days in the past won't be synchronized
+         */
+        const val KEY_TIME_RANGE_PAST_DAYS = "time_range_past_days"
+        const val DEFAULT_TIME_RANGE_PAST_DAYS = 90
+
+        /* Whether DAVx5 sets the local calendar color to the value from service DB at every sync
+           value = null (not existing)     true (default)
+                   "0"                     false */
+        const val KEY_MANAGE_CALENDAR_COLORS = "manage_calendar_colors"
+
+        /* Whether DAVx5 populates and uses CalendarContract.Colors
+           value = null (not existing)     false (default)
+                   "1"                     true */
+        const val KEY_EVENT_COLORS = "event_colors"
+
+        /** Contact group method:
+        value = null (not existing)     groups as separate VCards (default)
+        "CATEGORIES"            groups are per-contact CATEGORIES
+         */
+        const val KEY_CONTACT_GROUP_METHOD = "contact_group_method"
+
+        const val SYNC_INTERVAL_MANUALLY = -1L
+
+        fun initialUserData(credentials: Credentials): Bundle {
+            val bundle = Bundle(2)
+            bundle.putString(KEY_SETTINGS_VERSION, CURRENT_VERSION.toString())
+
+            when (credentials.type) {
+                Credentials.Type.UsernamePassword ->
+                    bundle.putString(KEY_USERNAME, credentials.userName)
+                Credentials.Type.ClientCertificate ->
+                    bundle.putString(KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
+            }
+
+            return bundle
+        }
+
+    }
+    
+    
+    val accountManager: AccountManager = AccountManager.get(context)
+    val settings = Settings.getInstance(context)
+
+    init {
+        synchronized(AccountSettings::class.java) {
+            val versionStr = accountManager.getUserData(account, KEY_SETTINGS_VERSION) ?: throw InvalidAccountException(account)
+            var version = 0
+            try {
+                version = Integer.parseInt(versionStr)
+            } catch (e: NumberFormatException) {
+            }
+            Logger.log.fine("Account ${account.name} has version $version, current version: $CURRENT_VERSION")
+
+            if (version < CURRENT_VERSION)
+                update(version)
+        }
+    }
+
+
+    // authentication settings
+
+    fun credentials() = Credentials(
+            accountManager.getUserData(account, KEY_USERNAME),
+            accountManager.getPassword(account),
+            accountManager.getUserData(account, KEY_CERTIFICATE_ALIAS)
+    )
+
+    fun credentials(credentials: Credentials) {
+        accountManager.setUserData(account, KEY_USERNAME, credentials.userName)
+        accountManager.setPassword(account, credentials.password)
+        accountManager.setUserData(account, KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
+    }
+
+
+    // sync. settings
+
+    fun getSyncInterval(authority: String): Long? {
+        if (ContentResolver.getIsSyncable(account, authority) <= 0)
+            return null
+
+        return if (ContentResolver.getSyncAutomatically(account, authority))
+            ContentResolver.getPeriodicSyncs(account, authority).firstOrNull()?.period ?: SYNC_INTERVAL_MANUALLY
+        else
+            SYNC_INTERVAL_MANUALLY
+    }
+
+    fun setSyncInterval(authority: String, seconds: Long) {
+        if (seconds == SYNC_INTERVAL_MANUALLY) {
+            ContentResolver.setSyncAutomatically(account, authority, false)
+        } else {
+            ContentResolver.setSyncAutomatically(account, authority, true)
+            ContentResolver.addPeriodicSync(account, authority, Bundle(), seconds)
+        }
+    }
+
+    fun getSyncWifiOnly() = if (settings.has(KEY_WIFI_ONLY))
+            settings.getBoolean(KEY_WIFI_ONLY) ?: WIFI_ONLY_DEFAULT
+                else
+            accountManager.getUserData(account, KEY_WIFI_ONLY) != null
+    fun setSyncWiFiOnly(wiFiOnly: Boolean) =
+            accountManager.setUserData(account, KEY_WIFI_ONLY, if (wiFiOnly) "1" else null)
+
+    fun getSyncWifiOnlySSIDs(): List<String>? = (if (settings.has(KEY_WIFI_ONLY_SSIDS))
+                settings.getString(KEY_WIFI_ONLY_SSIDS)
+            else
+                accountManager.getUserData(account, KEY_WIFI_ONLY_SSIDS))?.split(',')
+    fun setSyncWifiOnlySSIDs(ssids: List<String>?) =
+            accountManager.setUserData(account, KEY_WIFI_ONLY_SSIDS, StringUtils.trimToNull(ssids?.joinToString(",")))
+
+
+    // CalDAV settings
+
+    fun getTimeRangePastDays(): Int? {
+        val strDays = accountManager.getUserData(account, KEY_TIME_RANGE_PAST_DAYS)
+        return if (strDays != null) {
+            val days = Integer.valueOf(strDays)
+            if (days < 0) null else days
+        } else
+            DEFAULT_TIME_RANGE_PAST_DAYS
+    }
+
+    fun setTimeRangePastDays(days: Int?) =
+            accountManager.setUserData(account, KEY_TIME_RANGE_PAST_DAYS, (days ?: -1).toString())
+
+    fun getManageCalendarColors() = if (settings.has(KEY_MANAGE_CALENDAR_COLORS))
+        settings.getBoolean(KEY_MANAGE_CALENDAR_COLORS) ?: false
+    else
+        accountManager.getUserData(account, KEY_MANAGE_CALENDAR_COLORS) == null
+    fun setManageCalendarColors(manage: Boolean) =
+            accountManager.setUserData(account, KEY_MANAGE_CALENDAR_COLORS, if (manage) null else "0")
+
+    fun getEventColors() = if (settings.has(KEY_EVENT_COLORS))
+            settings.getBoolean(KEY_EVENT_COLORS) ?: false
+                else
+            accountManager.getUserData(account, KEY_EVENT_COLORS) != null
+    fun setEventColors(useColors: Boolean) =
+            accountManager.setUserData(account, KEY_EVENT_COLORS, if (useColors) "1" else null)
+
+    // CardDAV settings
+
+    fun getGroupMethod(): GroupMethod {
+        val name = settings.getString(KEY_CONTACT_GROUP_METHOD) ?:
+                accountManager.getUserData(account, KEY_CONTACT_GROUP_METHOD)
+        if (name != null)
+            try {
+                return GroupMethod.valueOf(name)
+            }
+            catch (e: IllegalArgumentException) {
+            }
+        return GroupMethod.GROUP_VCARDS
+    }
+
+    fun setGroupMethod(method: GroupMethod) {
+        accountManager.setUserData(account, KEY_CONTACT_GROUP_METHOD, method.name)
+    }
+
+
+    // update from previous account settings
+
+    private fun update(baseVersion: Int) {
+        for (toVersion in baseVersion+1 ..CURRENT_VERSION) {
+            val fromVersion = toVersion-1
+            Logger.log.info("Updating account ${account.name} from version $fromVersion to $toVersion")
+            try {
+                val updateProc = this::class.java.getDeclaredMethod("update_${fromVersion}_$toVersion")
+                updateProc.invoke(this)
+
+                Logger.log.info("Account version update successful")
+                accountManager.setUserData(account, KEY_SETTINGS_VERSION, toVersion.toString())
+            } catch (e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't update account settings", e)
+            }
+        }
+    }
+
+
+    @Suppress("unused")
+    @SuppressLint("Recycle")
+    /**
+     * It seems that somehow some non-CalDAV accounts got OpenTasks syncable, which caused battery problems.
+     * Disable it on those accounts for the future.
+     */
+    private fun update_8_9() {
+        ServiceDB.OpenHelper(context).use { dbHelper ->
+            val db = dbHelper.readableDatabase
+            db.query(ServiceDB.Services._TABLE, null, "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
+                    arrayOf(account.name, ServiceDB.Services.SERVICE_CALDAV), null, null, null).use { result ->
+                val hasCalDAV = result.count >= 1
+                if (!hasCalDAV && ContentResolver.getIsSyncable(account, OpenTasks.authority) != 0) {
+                    Logger.log.info("Disabling OpenTasks sync for $account")
+                    ContentResolver.setIsSyncable(account, OpenTasks.authority, 0)
+                }
+            }
+        }
+    }
+
+    @Suppress("unused")
+    @SuppressLint("Recycle")
+    /**
+     * There is a mistake in this method. [TaskContract.Tasks.SYNC_VERSION] is used to store the
+     * SEQUENCE and should not be used for the eTag.
+     */
+    private fun update_7_8() {
+        TaskProvider.acquire(context, TaskProvider.ProviderName.OpenTasks)?.let { provider ->
+            // ETag is now in sync_version instead of sync1
+            // UID  is now in _uid         instead of sync2
+            provider.client.query(TaskProvider.syncAdapterUri(provider.tasksUri(), account),
+                    arrayOf(TaskContract.Tasks._ID, TaskContract.Tasks.SYNC1, TaskContract.Tasks.SYNC2),
+                    "${TaskContract.Tasks.ACCOUNT_TYPE}=? AND ${TaskContract.Tasks.ACCOUNT_NAME}=?",
+                    arrayOf(account.type, account.name), null)!!.use { cursor ->
+                while (cursor.moveToNext()) {
+                    val id = cursor.getLong(0)
+                    val eTag = cursor.getString(1)
+                    val uid = cursor.getString(2)
+                    val values = ContentValues(4)
+                    values.put(TaskContract.Tasks._UID, uid)
+                    values.put(TaskContract.Tasks.SYNC_VERSION, eTag)
+                    values.putNull(TaskContract.Tasks.SYNC1)
+                    values.putNull(TaskContract.Tasks.SYNC2)
+                    Logger.log.log(Level.FINER, "Updating task $id", values)
+                    provider.client.update(
+                            TaskProvider.syncAdapterUri(ContentUris.withAppendedId(provider.tasksUri(), id), account),
+                            values, null, null)
+                }
+            }
+        }
+    }
+
+    @Suppress("unused")
+    @SuppressLint("Recycle")
+    private fun update_6_7() {
+        // add calendar colors
+        context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { provider ->
+            try {
+                AndroidCalendar.insertColors(provider, account)
+            } finally {
+                @Suppress("DEPRECATION")
+                if (Build.VERSION.SDK_INT >= 24)
+                    provider.close()
+                else
+                    provider.release()
+            }
+        }
+
+        // update allowed WiFi settings key
+        val onlySSID = accountManager.getUserData(account, "wifi_only_ssid")
+        accountManager.setUserData(account, KEY_WIFI_ONLY_SSIDS, onlySSID)
+        accountManager.setUserData(account, "wifi_only_ssid", null)
+    }
+
+    @Suppress("unused")
+    @SuppressLint("Recycle", "ParcelClassLoader")
+    private fun update_5_6() {
+        context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.let { provider ->
+            val parcel = Parcel.obtain()
+            try {
+                // don't run syncs during the migration
+                ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 0)
+                ContentResolver.setIsSyncable(account, context.getString(R.string.address_books_authority), 0)
+                ContentResolver.cancelSync(account, null)
+
+                // get previous address book settings (including URL)
+                val raw = ContactsContract.SyncState.get(provider, account)
+                if (raw == null)
+                    Logger.log.info("No contacts sync state, ignoring account")
+                else {
+                    parcel.unmarshall(raw, 0, raw.size)
+                    parcel.setDataPosition(0)
+                    val params = parcel.readBundle()!!
+                    val url = params.getString("url")?.let { HttpUrl.parse(it) }
+                    if (url == null)
+                        Logger.log.info("No address book URL, ignoring account")
+                    else {
+                        // create new address book
+                        val info = CollectionInfo(url)
+                        info.type = CollectionInfo.Type.ADDRESS_BOOK
+                        info.displayName = account.name
+                        Logger.log.log(Level.INFO, "Creating new address book account", url)
+                        val addressBookAccount = Account(LocalAddressBook.accountName(account, info), context.getString(R.string.account_type_address_book))
+                        if (!accountManager.addAccountExplicitly(addressBookAccount, null, LocalAddressBook.initialUserData(account, info.url.toString())))
+                            throw ContactsStorageException("Couldn't create address book account")
+
+                        // move contacts to new address book
+                        Logger.log.info("Moving contacts from $account to $addressBookAccount")
+                        val newAccount = ContentValues(2)
+                        newAccount.put(ContactsContract.RawContacts.ACCOUNT_NAME, addressBookAccount.name)
+                        newAccount.put(ContactsContract.RawContacts.ACCOUNT_TYPE, addressBookAccount.type)
+                        val affected = provider.update(ContactsContract.RawContacts.CONTENT_URI.buildUpon()
+                                .appendQueryParameter(ContactsContract.RawContacts.ACCOUNT_NAME, account.name)
+                                .appendQueryParameter(ContactsContract.RawContacts.ACCOUNT_TYPE, account.type)
+                                .appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true").build(),
+                                newAccount,
+                                "${ContactsContract.RawContacts.ACCOUNT_NAME}=? AND ${ContactsContract.RawContacts.ACCOUNT_TYPE}=?",
+                                arrayOf(account.name, account.type))
+                        Logger.log.info("$affected contacts moved to new address book")
+                    }
+
+                    ContactsContract.SyncState.set(provider, account, null)
+                }
+            } catch(e: RemoteException) {
+                throw ContactsStorageException("Couldn't migrate contacts to new address book", e)
+            } finally {
+                parcel.recycle()
+                @Suppress("DEPRECATION")
+                if (Build.VERSION.SDK_INT >= 24)
+                    provider.close()
+                else
+                    provider.release()
+            }
+        }
+
+        // update version number so that further syncs don't repeat the migration
+        accountManager.setUserData(account, KEY_SETTINGS_VERSION, "6")
+
+        // request sync of new address book account
+        ContentResolver.setIsSyncable(account, context.getString(R.string.address_books_authority), 1)
+        setSyncInterval(context.getString(R.string.address_books_authority), Constants.DEFAULT_SYNC_INTERVAL)
+    }
+
+    /* Android 7.1.1 OpenTasks fix */
+    @Suppress("unused")
+    private fun update_4_5() {
+        // call PackageChangedReceiver which then enables/disables OpenTasks sync when it's (not) available
+        PackageChangedReceiver.updateTaskSync(context)
+    }
+
+    @Suppress("unused")
+    private fun update_3_4() {
+        setGroupMethod(GroupMethod.CATEGORIES)
+    }
+
+    @Suppress("unused")
+    @SuppressLint("Recycle")
+    private fun update_2_3() {
+        // Don't show a warning for Android updates anymore
+        accountManager.setUserData(account, "last_android_version", null)
+
+        var serviceCardDAV: Long? = null
+        var serviceCalDAV: Long? = null
+
+        ServiceDB.OpenHelper(context).use { dbHelper ->
+            val db = dbHelper.writableDatabase
+            // we have to create the WebDAV Service database only from the old address book, calendar and task list URLs
+
+            // CardDAV: migrate address books
+            context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.let { client ->
+                try {
+                    val addrBook = LocalAddressBook(context, account, client)
+                    val url = addrBook.url
+                    Logger.log.fine("Migrating address book $url")
+
+                    // insert CardDAV service
+                    val values = ContentValues(3)
+                    values.put(Services.ACCOUNT_NAME, account.name)
+                    values.put(Services.SERVICE, Services.SERVICE_CARDDAV)
+                    serviceCardDAV = db.insert(Services._TABLE, null, values)
+
+                    // insert address book
+                    values.clear()
+                    values.put(Collections.SERVICE_ID, serviceCardDAV)
+                    values.put(Collections.URL, url)
+                    values.put(Collections.SYNC, 1)
+                    db.insert(Collections._TABLE, null, values)
+
+                    // insert home set
+                    HttpUrl.parse(url)?.let {
+                        val homeSet = it.resolve("../")
+                        values.clear()
+                        values.put(HomeSets.SERVICE_ID, serviceCardDAV)
+                        values.put(HomeSets.URL, homeSet.toString())
+                        db.insert(HomeSets._TABLE, null, values)
+                    }
+                } catch (e: ContactsStorageException) {
+                    Logger.log.log(Level.SEVERE, "Couldn't migrate address book", e)
+                } finally {
+                    if (Build.VERSION.SDK_INT >= 24)
+                        client.close()
+                    else
+                        @Suppress("deprecation")
+                        client.release()
+                }
+            }
+
+            // CalDAV: migrate calendars + task lists
+            val collections = HashSet<String>()
+            val homeSets = HashSet<HttpUrl>()
+
+            context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { client ->
+                try {
+                    val calendars = AndroidCalendar.find(account, client, LocalCalendar.Factory, null, null)
+                    for (calendar in calendars)
+                        calendar.name?.let { url ->
+                            Logger.log.fine("Migrating calendar $url")
+                            collections.add(url)
+                            HttpUrl.parse(url)?.resolve("../")?.let { homeSets.add(it) }
+                        }
+                } catch (e: CalendarStorageException) {
+                    Logger.log.log(Level.SEVERE, "Couldn't migrate calendars", e)
+                } finally {
+                    if (Build.VERSION.SDK_INT >= 24)
+                        client.close()
+                    else
+                        @Suppress("deprecation")
+                        client.release()
+                }
+            }
+
+            AndroidTaskList.acquireTaskProvider(context)?.use { provider ->
+                try {
+                    val taskLists = AndroidTaskList.find(account, provider, LocalTaskList.Factory, null, null)
+                    for (taskList in taskLists)
+                        taskList.syncId?.let { url ->
+                            Logger.log.fine("Migrating task list $url")
+                            collections.add(url)
+                            HttpUrl.parse(url)?.resolve("../")?.let { homeSets.add(it) }
+                        }
+                } catch (e: CalendarStorageException) {
+                    Logger.log.log(Level.SEVERE, "Couldn't migrate task lists", e)
+                }
+            }
+
+            if (!collections.isEmpty()) {
+                // insert CalDAV service
+                val values = ContentValues(3)
+                values.put(Services.ACCOUNT_NAME, account.name)
+                values.put(Services.SERVICE, Services.SERVICE_CALDAV)
+                serviceCalDAV = db.insert(Services._TABLE, null, values)
+
+                // insert collections
+                for (url in collections) {
+                    values.clear()
+                    values.put(Collections.SERVICE_ID, serviceCalDAV)
+                    values.put(Collections.URL, url)
+                    values.put(Collections.SYNC, 1)
+                    db.insert(Collections._TABLE, null, values)
+                }
+
+                // insert home sets
+                for (homeSet in homeSets) {
+                    values.clear()
+                    values.put(HomeSets.SERVICE_ID, serviceCalDAV)
+                    values.put(HomeSets.URL, homeSet.toString())
+                    db.insert(HomeSets._TABLE, null, values)
+                }
+            }
+        }
+
+        // initiate service detection (refresh) to get display names, colors etc.
+        val refresh = Intent(context, DavService::class.java)
+        refresh.action = DavService.ACTION_REFRESH_COLLECTIONS
+        serviceCardDAV?.let {
+            refresh.putExtra(DavService.EXTRA_DAV_SERVICE_ID, it)
+            context.startService(refresh)
+        }
+        serviceCalDAV?.let {
+            refresh.putExtra(DavService.EXTRA_DAV_SERVICE_ID, it)
+            context.startService(refresh)
+        }
+    }
+
+    @Suppress("unused")
+    @SuppressLint("Recycle")
+    private fun update_1_2() {
+        /* - KEY_ADDRESSBOOK_URL ("addressbook_url"),
+           - KEY_ADDRESSBOOK_CTAG ("addressbook_ctag"),
+           - KEY_ADDRESSBOOK_VCARD_VERSION ("addressbook_vcard_version") are not used anymore (now stored in ContactsContract.SyncState)
+           - KEY_LAST_ANDROID_VERSION ("last_android_version") has been added
+        */
+
+        // move previous address book model to ContactsContract.SyncState
+        val provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY) ?:
+            throw ContactsStorageException("Couldn't access Contacts provider")
+
+        try {
+            val addr = LocalAddressBook(context, account, provider)
+
+            // until now, ContactsContract.settings.UNGROUPED_VISIBLE was not set explicitly
+            val values = ContentValues()
+            values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, 1)
+            addr.settings = values
+
+            val url = accountManager.getUserData(account, "addressbook_url")
+            if (!url.isNullOrEmpty())
+                addr.url = url
+            accountManager.setUserData(account, "addressbook_url", null)
+
+            val cTag = accountManager.getUserData (account, "addressbook_ctag")
+            if (!cTag.isNullOrEmpty())
+                addr.lastSyncState = SyncState(SyncState.Type.CTAG, cTag)
+            accountManager.setUserData(account, "addressbook_ctag", null)
+        } finally {
+            if (Build.VERSION.SDK_INT >= 24)
+                provider.close()
+            else
+                @Suppress("deprecation")
+                provider.release()
+        }
+    }
+
+}

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

@@ -0,0 +1,78 @@
+/*
+ * 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.content.Context
+
+open class DefaultsProvider(
+        private val allowOverride: Boolean = true
+): SettingsProvider {
+
+    open val booleanDefaults = mapOf(
+            Pair(Settings.DISTRUST_SYSTEM_CERTIFICATES, Settings.DISTRUST_SYSTEM_CERTIFICATES_DEFAULT),
+            Pair(Settings.OVERRIDE_PROXY, Settings.OVERRIDE_PROXY_DEFAULT)
+    )
+
+    open val intDefaults = mapOf(
+            Pair(Settings.OVERRIDE_PROXY_PORT, Settings.OVERRIDE_PROXY_PORT_DEFAULT)
+    )
+
+    open val longDefaults = mapOf<String, Long>()
+
+    open val stringDefaults = mapOf(
+            Pair(Settings.OVERRIDE_PROXY_HOST, Settings.OVERRIDE_PROXY_HOST_DEFAULT)
+    )
+
+    override fun forceReload() {
+    }
+
+    override fun close() {
+    }
+
+
+    private fun hasKey(key: String) =
+            booleanDefaults.containsKey(key) ||
+            intDefaults.containsKey(key) ||
+            longDefaults.containsKey(key) ||
+            stringDefaults.containsKey(key)
+
+    override fun has(key: String): Pair<Boolean, Boolean> {
+        val has = hasKey(key)
+        return Pair(has, allowOverride || !has)
+    }
+
+
+    override fun getBoolean(key: String) =
+            Pair(booleanDefaults[key], allowOverride || !booleanDefaults.containsKey(key))
+
+    override fun getInt(key: String) =
+            Pair(intDefaults[key], allowOverride || !intDefaults.containsKey(key))
+
+    override fun getLong(key: String) =
+            Pair(longDefaults[key], allowOverride || !longDefaults.containsKey(key))
+
+    override fun getString(key: String) =
+            Pair(stringDefaults[key], allowOverride || !stringDefaults.containsKey(key))
+
+
+    override fun isWritable(key: String) = Pair(false, allowOverride || !hasKey(key))
+
+    override fun putBoolean(key: String, value: Boolean?) = false
+    override fun putInt(key: String, value: Int?) = false
+    override fun putLong(key: String, value: Long?) = false
+    override fun putString(key: String, value: String?) = false
+
+    override fun remove(key: String) = false
+
+
+    class Factory : ISettingsProviderFactory {
+        override fun getProviders(context: Context) = listOf(DefaultsProvider())
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/settings/ISettingsProviderFactory.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.content.Context
+
+interface ISettingsProviderFactory {
+
+    fun getProviders(context: Context): List<SettingsProvider>
+
+}

app/src/main/java/at/bitfire/davdroid/settings/Settings.kt

@@ -0,0 +1,187 @@
+/*
+ * 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.content.Context
+import at.bitfire.davdroid.log.Logger
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.logging.Level
+
+class Settings(
+        appContext: Context
+) {
+
+    companion object {
+
+        // settings keys and default values
+        const val DISTRUST_SYSTEM_CERTIFICATES = "distrust_system_certs"
+        const val DISTRUST_SYSTEM_CERTIFICATES_DEFAULT = false
+        const val OVERRIDE_PROXY = "override_proxy"
+        const val OVERRIDE_PROXY_DEFAULT = false
+        const val OVERRIDE_PROXY_HOST = "override_proxy_host"
+        const val OVERRIDE_PROXY_PORT = "override_proxy_port"
+
+        const val OVERRIDE_PROXY_HOST_DEFAULT = "localhost"
+        const val OVERRIDE_PROXY_PORT_DEFAULT = 8118
+
+
+        private var singleton: Settings? = null
+
+        fun getInstance(context: Context): Settings {
+            singleton?.let { return it }
+
+            val newInstance = Settings(context.applicationContext)
+            singleton = newInstance
+            return newInstance
+        }
+
+    }
+
+    private val providers = LinkedList<SettingsProvider>()
+    private val observers = LinkedList<WeakReference<OnChangeListener>>()
+
+    init {
+        val factories = ServiceLoader.load(ISettingsProviderFactory::class.java)
+        Logger.log.fine("Loading settings providers from ${factories.count()} factories")
+        factories.forEach { factory ->
+            providers.addAll(factory.getProviders(appContext))
+        }
+    }
+
+    fun forceReload() {
+        providers.forEach {
+            it.forceReload()
+        }
+        onSettingsChanged()
+    }
+
+
+    /*** OBSERVERS ***/
+
+    fun addOnChangeListener(observer: OnChangeListener) {
+        observers += WeakReference(observer)
+    }
+
+    fun removeOnChangeListener(observer: OnChangeListener) {
+        observers.removeAll { it.get() == null || it.get() == observer }
+    }
+
+    fun onSettingsChanged() {
+        observers.mapNotNull { it.get() }.forEach {
+            it.onSettingsChanged()
+        }
+    }
+
+
+    /*** SETTINGS ACCESS ***/
+
+    fun has(key: String): Boolean {
+        Logger.log.fine("Looking for setting $key")
+        var result = false
+        for (provider in providers)
+            try {
+                val (value, further) = provider.has(key)
+                Logger.log.finer("${provider::class.java.simpleName}: has $key = $value, continue: $further")
+                if (value) {
+                    result = true
+                    break
+                }
+                if (!further)
+                    break
+            } catch(e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't look up setting in $provider", e)
+            }
+        Logger.log.fine("Looking for setting $key -> $result")
+        return result
+    }
+
+    private fun<T> getValue(key: String, reader: (SettingsProvider) -> Pair<T?, Boolean>): T? {
+        Logger.log.fine("Looking up setting $key")
+        var result: T? = null
+        for (provider in providers)
+            try {
+                val (value, further) = reader(provider)
+                Logger.log.finer("${provider::class.java.simpleName}: value = $value, continue: $further")
+                value?.let { result = it }
+                if (!further)
+                    break
+            } catch(e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't read setting from $provider", e)
+            }
+        Logger.log.fine("Looked up setting $key -> $result")
+        return result
+    }
+
+    fun getBoolean(key: String) =
+            getValue(key) { provider -> provider.getBoolean(key) }
+
+    fun getInt(key: String) =
+            getValue(key) { provider -> provider.getInt(key) }
+
+    fun getLong(key: String) =
+            getValue(key) { provider -> provider.getLong(key) }
+
+    fun getString(key: String) =
+            getValue(key) { provider -> provider.getString(key) }
+
+
+    fun isWritable(key: String): Boolean {
+        for (provider in providers) {
+            val (value, further) = provider.isWritable(key)
+            if (value)
+                return true
+            if (!further)
+                return false
+        }
+        return false
+    }
+
+    private fun<T> putValue(key: String, value: T?, writer: (SettingsProvider) -> Boolean): Boolean {
+        Logger.log.fine("Trying to write setting $key = $value")
+        for (provider in providers) {
+            val (writable, further) = provider.isWritable(key)
+            Logger.log.finer("${provider::class.java.simpleName}: writable = $writable, continue: $further")
+            if (writable)
+                return try {
+                    writer(provider)
+                } catch (e: Exception) {
+                    Logger.log.log(Level.SEVERE, "Couldn't write setting to $provider", e)
+                    false
+                }
+            if (!further)
+                return false
+        }
+        return false
+    }
+
+    fun putBoolean(key: String, value: Boolean?) =
+            putValue(key, value) { provider -> provider.putBoolean(key, value) }
+
+    fun putInt(key: String, value: Int?) =
+            putValue(key, value) { provider -> provider.putInt(key, value) }
+
+    fun putLong(key: String, value: Long?) =
+            putValue(key, value) { provider -> provider.putLong(key, value) }
+
+    fun putString(key: String, value: String?) =
+            putValue(key, value) { provider -> provider.putString(key, value) }
+
+    fun remove(key: String): Boolean {
+        var deleted = false
+        providers.forEach { deleted = deleted || it.remove(key) }
+        return deleted
+    }
+
+
+    interface OnChangeListener {
+        fun onSettingsChanged()
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/settings/SettingsProvider.kt

@@ -0,0 +1,32 @@
+/*
+ * 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
+
+interface SettingsProvider {
+
+    fun forceReload()
+    fun close()
+
+    fun has(key: String): Pair<Boolean, Boolean>
+
+    fun getBoolean(key: String): Pair<Boolean?, Boolean>
+    fun getInt(key: String): Pair<Int?, Boolean>
+    fun getLong(key: String): Pair<Long?, Boolean>
+    fun getString(key: String): Pair<String?, Boolean>
+
+    fun isWritable(key: String): Pair<Boolean, Boolean>
+
+    fun putBoolean(key: String, value: Boolean?): Boolean
+    fun putInt(key: String, value: Int?): Boolean
+    fun putLong(key: String, value: Long?): Boolean
+    fun putString(key: String, value: String?): Boolean
+
+    fun remove(key: String): Boolean
+
+}

app/src/main/java/at/bitfire/davdroid/settings/SharedPreferencesProvider.kt

@@ -0,0 +1,132 @@
+/*
+ * 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.content.Context
+import android.content.Context.MODE_PRIVATE
+import android.content.SharedPreferences
+import android.preference.PreferenceManager
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.ServiceDB
+
+class SharedPreferencesProvider(
+        val context: Context
+): SettingsProvider, SharedPreferences.OnSharedPreferenceChangeListener {
+
+    companion object {
+        private const val META_VERSION = "version"
+        private const val CURRENT_VERSION = 0
+    }
+
+    private val preferences = PreferenceManager.getDefaultSharedPreferences(context)
+
+    init {
+        val meta = context.getSharedPreferences("meta", MODE_PRIVATE)
+        val version = meta.getInt(META_VERSION, -1)
+        if (version == -1) {
+            // first call, check whether to migrate from SQLite database (DAVdroid <1.9)
+            firstCall(context)
+            meta.edit().putInt(META_VERSION, CURRENT_VERSION).apply()
+        }
+
+        preferences.registerOnSharedPreferenceChangeListener(this)
+    }
+
+    override fun forceReload() {
+    }
+
+    override fun close() {
+        preferences.unregisterOnSharedPreferenceChangeListener(this)
+    }
+
+    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String) {
+        Settings.getInstance(context).onSettingsChanged()
+    }
+
+
+    override fun has(key: String) =
+            Pair(preferences.contains(key), true)
+
+    private fun<T> getValue(key: String, reader: (SharedPreferences) -> T): Pair<T?, Boolean> {
+        if (preferences.contains(key))
+            return Pair(
+                    try { reader(preferences) } catch(e: ClassCastException) { null },
+                    true)
+
+        return Pair(null, true)
+    }
+
+    override fun getBoolean(key: String): Pair<Boolean?, Boolean> =
+            getValue(key) { preferences -> preferences.getBoolean(key, /* will never be used: */ false) }
+
+    override fun getInt(key: String): Pair<Int?, Boolean> =
+            getValue(key) { preferences -> preferences.getInt(key, /* will never be used: */ -1) }
+
+    override fun getLong(key: String): Pair<Long?, Boolean> =
+            getValue(key) { preferences -> preferences.getLong(key, /* will never be used: */ -1) }
+
+    override fun getString(key: String): Pair<String?, Boolean> =
+            getValue(key) { preferences -> preferences.getString(key, /* will never be used: */ null) }
+
+
+    override fun isWritable(key: String) =
+            Pair(true, true)
+
+    private fun<T> putValue(key: String, value: T?, writer: (SharedPreferences.Editor, T) -> Unit): Boolean {
+        return if (value == null)
+            remove(key)
+        else {
+            Logger.log.fine("Writing setting $key = $value")
+            val edit = preferences.edit()
+            writer(edit, value)
+            edit.apply()
+            true
+        }
+    }
+
+    override fun putBoolean(key: String, value: Boolean?) =
+            putValue(key, value) { editor, v -> editor.putBoolean(key, v) }
+
+    override fun putInt(key: String, value: Int?) =
+            putValue(key, value) { editor, v -> editor.putInt(key, v) }
+
+    override fun putLong(key: String, value: Long?) =
+            putValue(key, value) { editor, v -> editor.putLong(key, v) }
+
+    override fun putString(key: String, value: String?) =
+            putValue(key, value) { editor, v -> editor.putString(key, v) }
+
+    override fun remove(key: String): Boolean {
+        Logger.log.fine("Removing setting $key")
+        preferences.edit()
+                .remove(key)
+                .apply()
+        return true
+    }
+
+
+    private fun firstCall(context: Context) {
+        // remove possible artifacts from DAVdroid <1.9
+        val edit = preferences.edit()
+        edit.remove("override_proxy")
+        edit.remove("proxy_host")
+        edit.remove("proxy_port")
+        edit.remove("log_to_external_storage")
+        edit.apply()
+
+        // open ServiceDB to upgrade it and possibly migrate settings
+        ServiceDB.OpenHelper(context).use { it.readableDatabase }
+    }
+
+
+    class Factory : ISettingsProviderFactory {
+        override fun getProviders(context: Context) = listOf(SharedPreferencesProvider(context))
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/AccountAuthenticatorService.kt

@@ -0,0 +1,116 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.*
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.database.DatabaseUtils
+import android.os.Bundle
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.ui.setup.LoginActivity
+import java.util.*
+import java.util.logging.Level
+
+
+/**
+ * Account authenticator for the main DAVx5 account type.
+ *
+ * Gets started when a DAVx5 account is removed, too, so it also watches for account removals
+ * and contains the corresponding cleanup code.
+ */
+class AccountAuthenticatorService: Service(), OnAccountsUpdateListener {
+
+    companion object {
+
+        fun cleanupAccounts(context: Context) {
+            Logger.log.info("Cleaning up orphaned accounts")
+
+            ServiceDB.OpenHelper(context).use { dbHelper ->
+                val db = dbHelper.writableDatabase
+
+                val sqlAccountNames = LinkedList<String>()
+                val accountNames = HashSet<String>()
+                val accountManager = AccountManager.get(context)
+                for (account in accountManager.getAccountsByType(context.getString(R.string.account_type))) {
+                    sqlAccountNames.add(DatabaseUtils.sqlEscapeString(account.name))
+                    accountNames += account.name
+                }
+
+                // delete orphaned address book accounts
+                accountManager.getAccountsByType(context.getString(R.string.account_type_address_book))
+                        .map { LocalAddressBook(context, it, null) }
+                        .forEach {
+                            try {
+                                if (!accountNames.contains(it.mainAccount.name))
+                                    it.delete()
+                            } catch(e: Exception) {
+                                Logger.log.log(Level.SEVERE, "Couldn't delete address book account", e)
+                            }
+                        }
+
+                // delete orphaned services in DB
+                if (sqlAccountNames.isEmpty())
+                    db.delete(ServiceDB.Services._TABLE, null, null)
+                else
+                    db.delete(ServiceDB.Services._TABLE, "${ServiceDB.Services.ACCOUNT_NAME} NOT IN (${sqlAccountNames.joinToString(",")})", null)
+            }
+        }
+
+    }
+
+
+    private lateinit var accountManager: AccountManager
+    private lateinit var accountAuthenticator: AccountAuthenticator
+
+    override fun onCreate() {
+        accountManager = AccountManager.get(this)
+        accountManager.addOnAccountsUpdatedListener(this, null, true)
+
+        accountAuthenticator = AccountAuthenticator(this)
+    }
+
+    override fun onDestroy() {
+        super.onDestroy()
+        accountManager.removeOnAccountsUpdatedListener(this)
+    }
+
+    override fun onBind(intent: Intent?) =
+            accountAuthenticator.iBinder.takeIf { intent?.action == android.accounts.AccountManager.ACTION_AUTHENTICATOR_INTENT }
+
+
+    override fun onAccountsUpdated(accounts: Array<out Account>?) {
+        cleanupAccounts(this)
+    }
+
+
+    private class AccountAuthenticator(
+            val context: Context
+    ): AbstractAccountAuthenticator(context) {
+
+        override fun addAccount(response: AccountAuthenticatorResponse?, accountType: String?, authTokenType: String?, requiredFeatures: Array<String>?, options: Bundle?): Bundle {
+            val intent = Intent(context, LoginActivity::class.java)
+            intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response)
+            val bundle = Bundle(1)
+            bundle.putParcelable(AccountManager.KEY_INTENT, intent)
+            return bundle
+        }
+
+        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/main/java/at/bitfire/davdroid/syncadapter/AddressBookProvider.kt

@@ -0,0 +1,24 @@
+/*
+ * 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.syncadapter
+
+import android.content.ContentProvider
+import android.content.ContentValues
+import android.net.Uri
+
+class AddressBookProvider: ContentProvider() {
+
+    override fun onCreate() = false
+    override fun insert(p0: Uri?, p1: ContentValues?) = null
+    override fun query(p0: Uri?, p1: Array<out String>?, p2: String?, p3: Array<out String>?, p4: String?) = null
+    override fun update(p0: Uri?, p1: ContentValues?, p2: String?, p3: Array<out String>?) = 0
+    override fun delete(p0: Uri?, p1: String?, p2: Array<out String>?) = 0
+    override fun getType(p0: Uri?) = null
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/AddressBooksSyncAdapterService.kt

@@ -0,0 +1,158 @@
+/*
+ * 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.syncadapter
+
+import android.Manifest
+import android.accounts.Account
+import android.content.*
+import android.content.pm.PackageManager
+import android.database.DatabaseUtils
+import android.os.Build
+import android.os.Bundle
+import android.provider.ContactsContract
+import androidx.core.content.ContextCompat
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.AccountActivity
+import okhttp3.HttpUrl
+import java.util.logging.Level
+
+class AddressBooksSyncAdapterService : SyncAdapterService() {
+
+    override fun syncAdapter() = AddressBooksSyncAdapter(this)
+
+
+    class AddressBooksSyncAdapter(
+            context: Context
+    ) : SyncAdapter(context) {
+
+        override fun sync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
+            try {
+                val accountSettings = AccountSettings(context, account)
+
+                /* don't run sync if
+                   - sync conditions (e.g. "sync only in WiFi") are not met AND
+                   - this is is an automatic sync (i.e. manual syncs are run regardless of sync conditions)
+                 */
+                if (!extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL) && !checkSyncConditions(accountSettings))
+                    return
+
+                updateLocalAddressBooks(account, syncResult)
+
+                for (addressBookAccount in LocalAddressBook.findAll(context, null, account).map { it.account }) {
+                    Logger.log.log(Level.INFO, "Running sync for address book", addressBookAccount)
+                    val syncExtras = Bundle(extras)
+                    syncExtras.putBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_SETTINGS, true)
+                    syncExtras.putBoolean(ContentResolver.SYNC_EXTRAS_IGNORE_BACKOFF, true)
+                    ContentResolver.requestSync(addressBookAccount, ContactsContract.AUTHORITY, syncExtras)
+                }
+            } catch (e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't sync address books", e)
+            }
+
+            Logger.log.info("Address book sync complete")
+        }
+
+        private fun updateLocalAddressBooks(account: Account, syncResult: SyncResult) {
+            ServiceDB.OpenHelper(context).use { dbHelper ->
+                val db = dbHelper.readableDatabase
+
+                fun getService() =
+                        db.query(ServiceDB.Services._TABLE, arrayOf(ServiceDB.Services.ID),
+                                "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
+                                arrayOf(account.name, ServiceDB.Services.SERVICE_CARDDAV), null, null, null)?.use { c ->
+                            if (c.moveToNext())
+                                c.getLong(0)
+                            else
+                                null
+                        }
+
+                fun remoteAddressBooks(service: Long?): MutableMap<HttpUrl, CollectionInfo> {
+                    val collections = mutableMapOf<HttpUrl, CollectionInfo>()
+                    service?.let {
+                        db.query(Collections._TABLE, null,
+                                Collections.SERVICE_ID + "=? AND " + Collections.SYNC, arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                            while (cursor.moveToNext()) {
+                                val values = ContentValues(cursor.columnCount)
+                                DatabaseUtils.cursorRowToContentValues(cursor, values)
+                                val info = CollectionInfo(values)
+                                collections[info.url] = info
+                            }
+                        }
+                    }
+                    return collections
+                }
+
+                // enumerate remote and local address books
+                val service = getService()
+                val remote = remoteAddressBooks(service)
+
+                if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
+                    if (remote.isEmpty()) {
+                        Logger.log.info("No contacts permission, but no address book selected for synchronization")
+                        return
+                    } else {
+                        // no contacts permission, but address books should be synchronized -> show notification
+                        val intent = Intent(context, AccountActivity::class.java)
+                        intent.putExtra(AccountActivity.EXTRA_ACCOUNT, account)
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+                        notifyPermissions(intent)
+                    }
+                }
+
+                val contactsProvider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)
+                try {
+                    if (contactsProvider == null) {
+                        Logger.log.severe("Couldn't access contacts provider")
+                        syncResult.databaseError = true
+                        return
+                    }
+
+                    // delete/update local address books
+                    for (addressBook in LocalAddressBook.findAll(context, contactsProvider, account)) {
+                        val url = HttpUrl.parse(addressBook.url)!!
+                        val info = remote[url]
+                        if (info == null) {
+                            Logger.log.log(Level.INFO, "Deleting obsolete local address book", url)
+                            addressBook.delete()
+                        } else {
+                            // remote CollectionInfo found for this local collection, update data
+                            try {
+                                Logger.log.log(Level.FINE, "Updating local address book $url", info)
+                                addressBook.update(info)
+                            } catch (e: Exception) {
+                                Logger.log.log(Level.WARNING, "Couldn't rename address book account", e)
+                            }
+                            // we already have a local address book for this remote collection, don't take into consideration anymore
+                            remote -= url
+                        }
+                    }
+
+                    // create new local address books
+                    for ((_, info) in remote) {
+                        Logger.log.log(Level.INFO, "Adding local address book", info)
+                        LocalAddressBook.create(context, contactsProvider, account, info)
+                    }
+                } finally {
+                    @Suppress("DEPRECATION")
+                    if (Build.VERSION.SDK_INT >= 24)
+                        contactsProvider?.close()
+                    else
+                        contactsProvider?.release()
+                }
+            }
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/CalendarSyncManager.kt

@@ -0,0 +1,192 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.Account
+import android.content.Context
+import android.content.SyncResult
+import android.os.Bundle
+import at.bitfire.dav4jvm.DavCalendar
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.DavResponseCallback
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.exception.DavException
+import at.bitfire.dav4jvm.property.*
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.LocalCalendar
+import at.bitfire.davdroid.resource.LocalEvent
+import at.bitfire.davdroid.resource.LocalResource
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.ical4android.Event
+import at.bitfire.ical4android.InvalidCalendarException
+import okhttp3.HttpUrl
+import okhttp3.RequestBody
+import java.io.ByteArrayOutputStream
+import java.io.Reader
+import java.io.StringReader
+import java.util.*
+import java.util.logging.Level
+
+/**
+ * Synchronization manager for CalDAV collections; handles events (VEVENT)
+ */
+class CalendarSyncManager(
+        context: Context,
+        account: Account,
+        accountSettings: AccountSettings,
+        extras: Bundle,
+        authority: String,
+        syncResult: SyncResult,
+        localCalendar: LocalCalendar
+): SyncManager<LocalEvent, LocalCalendar, DavCalendar>(context, account, accountSettings, extras, authority, syncResult, localCalendar) {
+
+    override fun prepare(): Boolean {
+        collectionURL = HttpUrl.parse(localCollection.name ?: return false) ?: return false
+        davCollection = DavCalendar(httpClient.okHttpClient, collectionURL)
+
+        // if there are dirty exceptions for events, mark their master events as dirty, too
+        localCollection.processDirtyExceptions()
+
+        return true
+    }
+
+    override fun queryCapabilities(): SyncState? =
+            useRemoteCollection {
+                var syncState: SyncState? = null
+                it.propfind(0, SupportedReportSet.NAME, GetCTag.NAME, SyncToken.NAME) { response, relation ->
+                    if (relation == Response.HrefRelation.SELF) {
+                        response[SupportedReportSet::class.java]?.let { supported ->
+                            hasCollectionSync = supported.reports.contains(SupportedReportSet.SYNC_COLLECTION)
+                        }
+
+                        syncState = syncState(response)
+                    }
+                }
+
+                Logger.log.info("Server supports Collection Sync: $hasCollectionSync")
+                syncState
+            }
+
+    override fun syncAlgorithm() = if (accountSettings.getTimeRangePastDays() != null || !hasCollectionSync)
+                SyncAlgorithm.PROPFIND_REPORT
+            else
+                SyncAlgorithm.COLLECTION_SYNC
+
+    override fun prepareUpload(resource: LocalEvent): RequestBody = useLocal(resource) {
+        val event = requireNotNull(resource.event)
+        Logger.log.log(Level.FINE, "Preparing upload of event ${resource.fileName}", event)
+
+        val os = ByteArrayOutputStream()
+        event.write(os)
+
+        RequestBody.create(
+                DavCalendar.MIME_ICALENDAR_UTF8,
+                os.toByteArray()
+        )
+    }
+
+    override fun listAllRemote(callback: DavResponseCallback) {
+        // calculate time range limits
+        var limitStart: Date? = null
+        accountSettings.getTimeRangePastDays()?.let { pastDays ->
+            val calendar = Calendar.getInstance()
+            calendar.add(Calendar.DAY_OF_MONTH, -pastDays)
+            limitStart = calendar.time
+        }
+
+        return useRemoteCollection { remote ->
+            Logger.log.info("Querying events since $limitStart")
+            remote.calendarQuery("VEVENT", limitStart, null, callback)
+        }
+    }
+
+    override fun downloadRemote(bunch: List<HttpUrl>) {
+        Logger.log.info("Downloading ${bunch.size} iCalendars: $bunch")
+        if (bunch.size == 1) {
+            val remote = bunch.first()
+            // only one contact, use GET
+            useRemote(DavResource(httpClient.okHttpClient, remote)) { resource ->
+                resource.get(DavCalendar.MIME_ICALENDAR.toString()) { response ->
+                    // CalDAV servers MUST return ETag on GET [https://tools.ietf.org/html/rfc4791#section-5.3.4]
+                    val eTag = response.header("ETag")?.let { GetETag(it).eTag }
+                            ?: throw DavException("Received CalDAV GET response without ETag")
+
+                    response.body()!!.use {
+                        processVEvent(resource.fileName(), eTag, it.charStream())
+                    }
+                }
+            }
+        } else
+            // multiple iCalendars, use calendar-multi-get
+            useRemoteCollection {
+                it.multiget(bunch) { response, _ ->
+                    useRemote(response) {
+                        if (!response.isSuccess()) {
+                            Logger.log.warning("Received non-successful multiget response for ${response.href}")
+                            return@useRemote
+                        }
+
+                        val eTag = response[GetETag::class.java]?.eTag
+                                ?: throw DavException("Received multi-get response without ETag")
+
+                        val calendarData = response[CalendarData::class.java]
+                        val iCal = calendarData?.iCalendar
+                                ?: throw DavException("Received multi-get response without address data")
+
+                        processVEvent(DavUtils.lastSegmentOfUrl(response.href), eTag, StringReader(iCal))
+                    }
+                }
+            }
+    }
+
+    override fun postProcess() {
+    }
+
+
+    // helpers
+
+    private fun processVEvent(fileName: String, eTag: String, reader: Reader) {
+        val events: List<Event>
+        try {
+            events = Event.fromReader(reader)
+        } catch (e: InvalidCalendarException) {
+            Logger.log.log(Level.SEVERE, "Received invalid iCalendar, ignoring", e)
+            notifyInvalidResource(e, fileName)
+            return
+        }
+
+        if (events.size == 1) {
+            val newData = events.first()
+
+            // delete local event, if it exists
+            useLocal(localCollection.findByName(fileName)) { local ->
+                if (local != null) {
+                    Logger.log.log(Level.INFO, "Updating $fileName in local calendar", newData)
+                    local.eTag = eTag
+                    local.update(newData)
+                    syncResult.stats.numUpdates++
+                } else {
+                    Logger.log.log(Level.INFO, "Adding $fileName to local calendar", newData)
+                    useLocal(LocalEvent(localCollection, newData, fileName, eTag, LocalResource.FLAG_REMOTELY_PRESENT)) {
+                        it.add()
+                    }
+                    syncResult.stats.numInserts++
+                }
+            }
+        } else
+            Logger.log.info("Received VCALENDAR with not exactly one VEVENT with UID and without RECURRENCE-ID; ignoring $fileName")
+    }
+
+    override fun notifyInvalidResourceTitle(): String =
+            context.getString(R.string.sync_invalid_event)
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/CalendarsSyncAdapterService.kt

@@ -0,0 +1,128 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.Account
+import android.content.*
+import android.database.DatabaseUtils
+import android.os.Bundle
+import android.provider.CalendarContract
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.davdroid.resource.LocalCalendar
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.ical4android.AndroidCalendar
+import okhttp3.HttpUrl
+import java.util.logging.Level
+
+class CalendarsSyncAdapterService: SyncAdapterService() {
+
+    override fun syncAdapter() = CalendarsSyncAdapter(this)
+
+
+	class CalendarsSyncAdapter(
+            context: Context
+    ): SyncAdapter(context) {
+
+        override fun sync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
+            try {
+                val accountSettings = AccountSettings(context, account)
+
+                /* don't run sync if
+                   - sync conditions (e.g. "sync only in WiFi") are not met AND
+                   - this is is an automatic sync (i.e. manual syncs are run regardless of sync conditions)
+                 */
+                if (!extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL) && !checkSyncConditions(accountSettings))
+                    return
+
+                if (accountSettings.getEventColors())
+                    AndroidCalendar.insertColors(provider, account)
+                else
+                    AndroidCalendar.removeColors(provider, account)
+
+                updateLocalCalendars(provider, account, accountSettings)
+
+                for (calendar in AndroidCalendar.find(account, provider, LocalCalendar.Factory, "${CalendarContract.Calendars.SYNC_EVENTS}!=0", null)) {
+                    Logger.log.info("Synchronizing calendar #${calendar.id}, URL: ${calendar.name}")
+                    CalendarSyncManager(context, account, accountSettings, extras, authority, syncResult, calendar).use {
+                        it.performSync()
+                    }
+                }
+            } catch(e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't sync calendars", e)
+            }
+            Logger.log.info("Calendar sync complete")
+        }
+
+        private fun updateLocalCalendars(provider: ContentProviderClient, account: Account, settings: AccountSettings) {
+            ServiceDB.OpenHelper(context).use { dbHelper ->
+                val db = dbHelper.readableDatabase
+
+                fun getService() =
+                        db.query(ServiceDB.Services._TABLE, arrayOf(ServiceDB.Services.ID),
+                                "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
+                                arrayOf(account.name, ServiceDB.Services.SERVICE_CALDAV), null, null, null)?.use { c ->
+                            if (c.moveToNext())
+                                c.getLong(0)
+                            else
+                                null
+                        }
+
+                fun remoteCalendars(service: Long?): MutableMap<HttpUrl, CollectionInfo> {
+                    val collections = mutableMapOf<HttpUrl, CollectionInfo>()
+                    service?.let {
+                        db.query(Collections._TABLE, null,
+                                "${Collections.SERVICE_ID}=? AND ${Collections.SUPPORTS_VEVENT}!=0 AND ${Collections.SYNC}",
+                                arrayOf(service.toString()), null, null, null).use { cursor ->
+                            while (cursor.moveToNext()) {
+                                val values = ContentValues(cursor.columnCount)
+                                DatabaseUtils.cursorRowToContentValues(cursor, values)
+                                val info = CollectionInfo(values)
+                                collections[info.url] = info
+                            }
+                        }
+                    }
+                    return collections
+                }
+
+                // enumerate remote and local calendars
+                val service = getService()
+                val remote = remoteCalendars(service)
+
+                // delete/update local calendars
+                val updateColors = settings.getManageCalendarColors()
+
+                for (calendar in AndroidCalendar.find(account, provider, LocalCalendar.Factory, null, null))
+                    calendar.name?.let {
+                        val url = HttpUrl.parse(it)!!
+                        val info = remote[url]
+                        if (info == null) {
+                            Logger.log.log(Level.INFO, "Deleting obsolete local calendar", url)
+                            calendar.delete()
+                        } else {
+                            // remote CollectionInfo found for this local collection, update data
+                            Logger.log.log(Level.FINE, "Updating local calendar $url", info)
+                            calendar.update(info, updateColors)
+                            // we already have a local calendar for this remote collection, don't take into consideration anymore
+                            remote -= url
+                        }
+                    }
+
+                // create new local calendars
+                for ((_, info) in remote) {
+                    Logger.log.log(Level.INFO, "Adding local calendar", info)
+                    LocalCalendar.create(account, provider, info)
+                }
+            }
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/ContactsSyncAdapterService.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid.syncadapter
+
+import android.accounts.Account
+import android.content.ContentProviderClient
+import android.content.ContentResolver
+import android.content.Context
+import android.content.SyncResult
+import android.os.Bundle
+import android.provider.ContactsContract
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.settings.AccountSettings
+import java.util.logging.Level
+
+class ContactsSyncAdapterService: SyncAdapterService() {
+
+    companion object {
+        const val PREVIOUS_GROUP_METHOD = "previous_group_method"
+    }
+
+    override fun syncAdapter() = ContactsSyncAdapter(this)
+
+
+	class ContactsSyncAdapter(
+            context: Context
+    ): SyncAdapter(context) {
+
+        override fun sync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
+            try {
+                val addressBook = LocalAddressBook(context, account, provider)
+                val accountSettings = AccountSettings(context, addressBook.mainAccount)
+
+                // handle group method change
+                val groupMethod = accountSettings.getGroupMethod().name
+                accountSettings.accountManager.getUserData(account, PREVIOUS_GROUP_METHOD)?.let { previousGroupMethod ->
+                    if (previousGroupMethod != groupMethod) {
+                        Logger.log.info("Group method changed, deleting all local contacts/groups")
+
+                        // delete all local contacts and groups so that they will be downloaded again
+                        provider.delete(addressBook.syncAdapterURI(ContactsContract.RawContacts.CONTENT_URI), null, null)
+                        provider.delete(addressBook.syncAdapterURI(ContactsContract.Groups.CONTENT_URI), null, null)
+
+                        // reset sync state
+                        addressBook.syncState = null
+                    }
+                }
+                accountSettings.accountManager.setUserData(account, PREVIOUS_GROUP_METHOD, groupMethod)
+
+                if (!extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL) && !checkSyncConditions(accountSettings))
+                    return
+
+                Logger.log.info("Synchronizing address book: ${addressBook.url}")
+                Logger.log.info("Taking settings from: ${addressBook.mainAccount}")
+
+                ContactsSyncManager(context, account, accountSettings, extras, authority, syncResult, provider, addressBook).use {
+                    it.performSync()
+                }
+            } catch(e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't sync contacts", e)
+            }
+            Logger.log.info("Contacts sync complete")
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/ContactsSyncManager.kt

@@ -0,0 +1,488 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.Account
+import android.content.*
+import android.os.Build
+import android.os.Bundle
+import android.provider.ContactsContract.Groups
+import androidx.core.app.NotificationCompat
+import at.bitfire.dav4jvm.DavAddressBook
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.DavResponseCallback
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.exception.DavException
+import at.bitfire.dav4jvm.property.*
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.HttpClient
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.*
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.NotificationUtils
+import at.bitfire.vcard4android.BatchOperation
+import at.bitfire.vcard4android.Contact
+import at.bitfire.vcard4android.GroupMethod
+import ezvcard.VCardVersion
+import ezvcard.io.CannotParseException
+import okhttp3.HttpUrl
+import okhttp3.Request
+import okhttp3.RequestBody
+import java.io.*
+import java.util.logging.Level
+
+/**
+ * Synchronization manager for CardDAV collections; handles contacts and groups.
+ *
+ * Group handling differs according to the {@link #groupMethod}. There are two basic methods to
+ * handle/manage groups:
+ *
+ * 1. CATEGORIES: groups memberships are attached to each contact and represented as
+ *   "category". When a group is dirty or has been deleted, all its members have to be set to
+ *   dirty, too (because they have to be uploaded without the respective category). This
+ *   is done in [uploadDirty]. Empty groups can be deleted without further processing,
+ *   which is done in [postProcess] because groups may become empty after downloading
+ *   updated remote contacts.
+ *
+ * 2. Groups as separate VCards: individual and group contacts (with a list of member UIDs) are
+ *   distinguished. When a local group is dirty, its members don't need to be set to dirty.
+ *
+ *   However, when a contact is dirty, it has
+ *   to be checked whether its group memberships have changed. In this case, the respective
+ *   groups have to be set to dirty. For instance, if contact A is in group G and H, and then
+ *   group membership of G is removed, the contact will be set to dirty because of the changed
+ *   [android.provider.ContactsContract.CommonDataKinds.GroupMembership]. DAVx5 will
+ *   then have to check whether the group memberships have actually changed, and if so,
+ *   all affected groups have to be set to dirty. To detect changes in group memberships,
+ *   DAVx5 always mirrors all [android.provider.ContactsContract.CommonDataKinds.GroupMembership]
+ *   data rows in respective [at.bitfire.vcard4android.CachedGroupMembership] rows.
+ *   If the cached group memberships are not the same as the current group member ships, the
+ *   difference set (in our example G, because its in the cached memberships, but not in the
+ *   actual ones) is marked as dirty. This is done in [uploadDirty].
+ *
+ *   When downloading remote contacts, groups (+ member information) may be received
+ *   by the actual members. Thus, the member lists have to be cached until all VCards
+ *   are received. This is done by caching the member UIDs of each group in
+ *   [LocalGroup.COLUMN_PENDING_MEMBERS]. In [postProcess],
+ *   these "pending memberships" are assigned to the actual contacts and then cleaned up.
+ */
+class ContactsSyncManager(
+        context: Context,
+        account: Account,
+        accountSettings: AccountSettings,
+        extras: Bundle,
+        authority: String,
+        syncResult: SyncResult,
+        val provider: ContentProviderClient,
+        localAddressBook: LocalAddressBook
+): SyncManager<LocalAddress, LocalAddressBook, DavAddressBook>(context, account, accountSettings, extras, authority, syncResult, localAddressBook) {
+
+    companion object {
+        infix fun <T> Set<T>.disjunct(other: Set<T>) = (this - other) union (other - this)
+    }
+
+    private val readOnly = localAddressBook.readOnly
+    private var numDiscarded = 0
+
+    private var hasVCard4 = false
+    private val groupMethod = accountSettings.getGroupMethod()
+
+    /**
+     * Used to download images which are referenced by URL
+     */
+    private lateinit var resourceDownloader: ResourceDownloader
+
+
+    override fun prepare(): Boolean {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
+            val reallyDirty = localCollection.verifyDirty()
+            val deleted = localCollection.findDeleted().size
+            if (extras.containsKey(ContentResolver.SYNC_EXTRAS_UPLOAD) && reallyDirty == 0 && deleted == 0) {
+                Logger.log.info("This sync was called to up-sync dirty/deleted contacts, but no contacts have been changed")
+                return false
+            }
+        }
+
+        collectionURL = HttpUrl.parse(localCollection.url) ?: return false
+        davCollection = DavAddressBook(httpClient.okHttpClient, collectionURL)
+
+        resourceDownloader = ResourceDownloader(davCollection.location)
+
+        return true
+    }
+
+    override fun queryCapabilities(): SyncState? {
+        Logger.log.info("Contact group method: $groupMethod")
+        // in case of GROUP_VCARDs, treat groups as contacts in the local address book
+        localCollection.includeGroups = groupMethod == GroupMethod.GROUP_VCARDS
+
+        return useRemoteCollection {
+            var syncState: SyncState? = null
+            it.propfind(0, SupportedAddressData.NAME, SupportedReportSet.NAME, GetCTag.NAME, SyncToken.NAME) { response, relation ->
+                if (relation == Response.HrefRelation.SELF) {
+                    response[SupportedAddressData::class.java]?.let { supported ->
+                        hasVCard4 = supported.hasVCard4()
+                    }
+
+                    response[SupportedReportSet::class.java]?.let { supported ->
+                        hasCollectionSync = supported.reports.contains(SupportedReportSet.SYNC_COLLECTION)
+                    }
+
+                    syncState = syncState(response)
+                }
+            }
+
+            Logger.log.info("Server supports vCard/4: $hasVCard4")
+            Logger.log.info("Server supports Collection Sync: $hasCollectionSync")
+
+            syncState
+        }
+    }
+
+    override fun syncAlgorithm() = if (hasCollectionSync)
+                SyncAlgorithm.COLLECTION_SYNC
+            else
+                SyncAlgorithm.PROPFIND_REPORT
+
+    override fun processLocallyDeleted(): Boolean {
+        if (readOnly) {
+            for (group in localCollection.findDeletedGroups()) {
+                Logger.log.warning("Restoring locally deleted group (read-only address book!)")
+                useLocal(group) { it.resetDeleted() }
+                numDiscarded++
+            }
+
+            for (contact in localCollection.findDeletedContacts()) {
+                Logger.log.warning("Restoring locally deleted contact (read-only address book!)")
+                useLocal(contact) { it.resetDeleted() }
+                numDiscarded++
+            }
+
+            if (numDiscarded > 0)
+                notifyDiscardedChange()
+            return false
+        } else
+            // mirror deletions to remote collection (DELETE)
+            return super.processLocallyDeleted()
+    }
+
+    override fun uploadDirty(): Boolean {
+        if (readOnly) {
+            for (group in localCollection.findDirtyGroups()) {
+                Logger.log.warning("Resetting locally modified group to ETag=null (read-only address book!)")
+                useLocal(group) { it.clearDirty(null) }
+                numDiscarded++
+            }
+
+            for (contact in localCollection.findDirtyContacts()) {
+                Logger.log.warning("Resetting locally modified contact to ETag=null (read-only address book!)")
+                useLocal(contact) { it.clearDirty(null) }
+                numDiscarded++
+            }
+
+            if (numDiscarded > 0)
+                notifyDiscardedChange()
+
+        } else {
+            if (groupMethod == GroupMethod.CATEGORIES) {
+                /* groups memberships are represented as contact CATEGORIES */
+
+                // groups with DELETED=1: set all members to dirty, then remove group
+                for (group in localCollection.findDeletedGroups()) {
+                    Logger.log.fine("Finally removing group $group")
+                    // useless because Android deletes group memberships as soon as a group is set to DELETED:
+                    // group.markMembersDirty()
+                    useLocal(group) { it.delete() }
+                }
+
+                // groups with DIRTY=1: mark all memberships as dirty, then clean DIRTY flag of group
+                for (group in localCollection.findDirtyGroups()) {
+                    Logger.log.fine("Marking members of modified group $group as dirty")
+                    useLocal(group) {
+                        it.markMembersDirty()
+                        it.clearDirty(null)
+                    }
+                }
+            } else {
+                /* groups as separate VCards: there are group contacts and individual contacts */
+
+                // mark groups with changed members as dirty
+                val batch = BatchOperation(localCollection.provider!!)
+                for (contact in localCollection.findDirtyContacts())
+                    try {
+                        Logger.log.fine("Looking for changed group memberships of contact ${contact.fileName}")
+                        val cachedGroups = contact.getCachedGroupMemberships()
+                        val currentGroups = contact.getGroupMemberships()
+                        for (groupID in cachedGroups disjunct currentGroups) {
+                            Logger.log.fine("Marking group as dirty: $groupID")
+                            batch.enqueue(BatchOperation.Operation(
+                                    ContentProviderOperation.newUpdate(localCollection.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, groupID)))
+                                    .withValue(Groups.DIRTY, 1)
+                                    .withYieldAllowed(true)
+                            ))
+                        }
+                    } catch(e: FileNotFoundException) {
+                    }
+                batch.commit()
+            }
+        }
+
+        // generate UID/file name for newly created contacts
+        return super.uploadDirty()
+    }
+
+    private fun notifyDiscardedChange() {
+        val notification = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_SYNC_STATUS)
+                .setSmallIcon(R.drawable.ic_delete_notification)
+                .setContentTitle(context.getString(R.string.sync_contacts_read_only_address_book))
+                .setContentText(context.resources.getQuantityString(R.plurals.sync_contacts_local_contact_changes_discarded, numDiscarded, numDiscarded))
+                .setNumber(numDiscarded)
+                .setSubText(account.name)
+                .setCategory(NotificationCompat.CATEGORY_STATUS)
+                .setPriority(NotificationCompat.PRIORITY_MIN)
+                .setLocalOnly(true)
+                .build()
+        notificationManager.notify("discarded_${account.name}", 0, notification)
+    }
+
+    override fun prepareUpload(resource: LocalAddress): RequestBody = useLocal(resource) {
+        val contact: Contact
+        if (resource is LocalContact) {
+            contact = resource.contact!!
+
+            if (groupMethod == GroupMethod.CATEGORIES) {
+                // add groups as CATEGORIES
+                for (groupID in resource.getGroupMemberships()) {
+                    provider.query(
+                            localCollection.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, groupID)),
+                            arrayOf(Groups.TITLE), null, null, null
+                    )?.use { cursor ->
+                        if (cursor.moveToNext()) {
+                            val title = cursor.getString(0)
+                            if (!title.isNullOrEmpty())
+                                contact.categories.add(title)
+                        }
+                    }
+                }
+            }
+        } else if (resource is LocalGroup)
+            contact = resource.contact!!
+        else
+            throw IllegalArgumentException("resource must be LocalContact or LocalGroup")
+
+        Logger.log.log(Level.FINE, "Preparing upload of VCard ${resource.fileName}", contact)
+
+        val os = ByteArrayOutputStream()
+        contact.write(if (hasVCard4) VCardVersion.V4_0 else VCardVersion.V3_0, groupMethod, os)
+
+        RequestBody.create(
+                if (hasVCard4) DavAddressBook.MIME_VCARD4 else DavAddressBook.MIME_VCARD3_UTF8,
+                os.toByteArray()
+        )
+    }
+
+    override fun listAllRemote(callback: DavResponseCallback) =
+            useRemoteCollection {
+                it.propfind(1, ResourceType.NAME, GetETag.NAME, callback = callback)
+            }
+
+    override fun downloadRemote(bunch: List<HttpUrl>) {
+        Logger.log.info("Downloading ${bunch.size} vCards: $bunch")
+        if (bunch.size == 1) {
+            val remote = bunch.first()
+            // only one contact, use GET
+            useRemote(DavResource(httpClient.okHttpClient, remote)) { resource ->
+                resource.get("text/vcard;version=4.0, text/vcard;charset=utf-8;q=0.8, text/vcard;q=0.5") { response ->
+                    // CardDAV servers MUST return ETag on GET [https://tools.ietf.org/html/rfc6352#section-6.3.2.3]
+                    val eTag = response.header("ETag")?.let { GetETag(it).eTag }
+                            ?: throw DavException("Received CardDAV GET response without ETag")
+
+                    response.body()!!.use {
+                        processVCard(resource.fileName(), eTag, it.charStream(), resourceDownloader)
+                    }
+                }
+            }
+        } else
+            // multiple vCards, use addressbook-multi-get
+            useRemoteCollection {
+                it.multiget(bunch, hasVCard4) { response, _ ->
+                    useRemote(response) {
+                        if (!response.isSuccess()) {
+                            Logger.log.warning("Received non-successful multiget response for ${response.href}")
+                            return@useRemote
+                        }
+
+                        val eTag = response[GetETag::class.java]?.eTag
+                                ?: throw DavException("Received multi-get response without ETag")
+
+                        val addressData = response[AddressData::class.java]
+                        val vCard = addressData?.vCard
+                                ?: throw DavException("Received multi-get response without address data")
+
+                        processVCard(DavUtils.lastSegmentOfUrl(response.href), eTag, StringReader(vCard), resourceDownloader)
+                    }
+                }
+            }
+    }
+
+    override fun postProcess() {
+        if (groupMethod == GroupMethod.CATEGORIES) {
+            /* VCard3 group handling: groups memberships are represented as contact CATEGORIES */
+
+            // remove empty groups
+            Logger.log.info("Removing empty groups")
+            localCollection.removeEmptyGroups()
+
+        } else {
+            /* VCard4 group handling: there are group contacts and individual contacts */
+            Logger.log.info("Assigning memberships of downloaded contact groups")
+            LocalGroup.applyPendingMemberships(localCollection)
+        }
+    }
+
+
+    // helpers
+
+    private fun processVCard(fileName: String, eTag: String, reader: Reader, downloader: Contact.Downloader) {
+        Logger.log.info("Processing CardDAV resource $fileName")
+
+        val contacts = try {
+            Contact.fromReader(reader, downloader)
+        } catch (e: CannotParseException) {
+            Logger.log.log(Level.SEVERE, "Received invalid vCard, ignoring", e)
+            notifyInvalidResource(e, fileName)
+            return
+        }
+
+        if (contacts.isEmpty()) {
+            Logger.log.warning("Received vCard without data, ignoring")
+            return
+        } else if (contacts.size > 1)
+            Logger.log.warning("Received multiple vCards, using first one")
+
+        val newData = contacts.first()
+
+        if (groupMethod == GroupMethod.CATEGORIES && newData.group) {
+            Logger.log.warning("Received group vCard although group method is CATEGORIES. Saving as regular contact")
+            newData.group = false
+        }
+
+        // update local contact, if it exists
+        useLocal(localCollection.findByName(fileName)) {
+            var local = it
+            if (local != null) {
+                Logger.log.log(Level.INFO, "Updating $fileName in local address book", newData)
+
+                if (local is LocalGroup && newData.group) {
+                    // update group
+                    local.eTag = eTag
+                    local.flags = LocalResource.FLAG_REMOTELY_PRESENT
+                    local.update(newData)
+                    syncResult.stats.numUpdates++
+
+                } else if (local is LocalContact && !newData.group) {
+                    // update contact
+                    local.eTag = eTag
+                    local.flags = LocalResource.FLAG_REMOTELY_PRESENT
+                    local.update(newData)
+                    syncResult.stats.numUpdates++
+
+                } else {
+                    // group has become an individual contact or vice versa
+                    local.delete()
+                    local = null
+                }
+            }
+
+            if (local == null) {
+                if (newData.group) {
+                    Logger.log.log(Level.INFO, "Creating local group", newData)
+                    useLocal(LocalGroup(localCollection, newData, fileName, eTag, LocalResource.FLAG_REMOTELY_PRESENT)) { group ->
+                        group.add()
+                        local = group
+                    }
+                } else {
+                    Logger.log.log(Level.INFO, "Creating local contact", newData)
+                    useLocal(LocalContact(localCollection, newData, fileName, eTag, LocalResource.FLAG_REMOTELY_PRESENT)) { contact ->
+                        contact.add()
+                        local = contact
+                    }
+                }
+                syncResult.stats.numInserts++
+            }
+
+            if (groupMethod == GroupMethod.CATEGORIES)
+                (local as? LocalContact)?.let { localContact ->
+                    // VCard3: update group memberships from CATEGORIES
+                    val batch = BatchOperation(provider)
+                    Logger.log.log(Level.FINE, "Removing contact group memberships")
+                    localContact.removeGroupMemberships(batch)
+
+                    for (category in localContact.contact!!.categories) {
+                        val groupID = localCollection.findOrCreateGroup(category)
+                        Logger.log.log(Level.FINE, "Adding membership in group $category ($groupID)")
+                        localContact.addToGroup(batch, groupID)
+                    }
+
+                    batch.commit()
+                }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+            // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
+                (local as? LocalContact)?.updateHashCode(null)
+        }
+    }
+
+
+    // downloader helper class
+
+    private inner class ResourceDownloader(
+            val baseUrl: HttpUrl
+    ): Contact.Downloader {
+
+        override fun download(url: String, accepts: String): ByteArray? {
+            val httpUrl = HttpUrl.parse(url)
+            if (httpUrl == null) {
+                Logger.log.log(Level.SEVERE, "Invalid external resource URL", url)
+                return null
+            }
+
+            // authenticate only against a certain host, and only upon request
+            val builder = HttpClient.Builder(context, baseUrl.host(), accountSettings.credentials())
+
+            // allow redirects
+            builder.followRedirects(true)
+
+            val client = builder.build()
+            try {
+                val response = client.okHttpClient.newCall(Request.Builder()
+                        .get()
+                        .url(httpUrl)
+                        .build()).execute()
+
+                if (response.isSuccessful)
+                    return response.body()?.bytes()
+                else
+                    Logger.log.warning("Couldn't download external resource")
+            } catch(e: IOException) {
+                Logger.log.log(Level.SEVERE, "Couldn't download external resource", e)
+            } finally {
+                client.close()
+            }
+            return null
+        }
+    }
+
+    override fun notifyInvalidResourceTitle(): String =
+            context.getString(R.string.sync_invalid_contact)
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/NullAuthenticatorService.kt

@@ -1,7 +1,11 @@
 /*
- * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ * 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.sync.account
+package at.bitfire.davdroid.syncadapter
 
 import android.accounts.AbstractAccountAuthenticator
 import android.accounts.Account
@@ -11,14 +15,9 @@ import android.app.Service
 import android.content.Context
 import android.content.Intent
 import android.os.Bundle
-import androidx.core.os.bundleOf
-import at.bitfire.davdroid.R
+import at.bitfire.davdroid.ui.AccountsActivity
 
-
-/**
- * Account authenticator for the DAVx5 account type.
- */
-class AccountAuthenticatorService: Service() {
+class NullAuthenticatorService: Service() {
 
     private lateinit var accountAuthenticator: AccountAuthenticator
 
@@ -27,19 +26,20 @@ class AccountAuthenticatorService: Service() {
     }
 
     override fun onBind(intent: Intent?) =
-        accountAuthenticator.iBinder.takeIf { intent?.action == AccountManager.ACTION_AUTHENTICATOR_INTENT }
+            accountAuthenticator.iBinder.takeIf { intent?.action == android.accounts.AccountManager.ACTION_AUTHENTICATOR_INTENT }
 
 
     private class AccountAuthenticator(
-        val context: Context
+            val context: Context
     ): AbstractAccountAuthenticator(context) {
 
-        override fun addAccount(response: AccountAuthenticatorResponse?, accountType: String?, authTokenType: String?, requiredFeatures: Array<String>?, options: Bundle?) =
-            bundleOf(
-                AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE to response,
-                AccountManager.KEY_ERROR_CODE to AccountManager.ERROR_CODE_UNSUPPORTED_OPERATION,
-                AccountManager.KEY_ERROR_MESSAGE to context.getString(R.string.account_prefs_use_app)
-            )
+        override fun addAccount(response: AccountAuthenticatorResponse?, accountType: String?, authTokenType: String?, requiredFeatures: Array<String>?, options: Bundle?): Bundle {
+            val intent = Intent(context, AccountsActivity::class.java)
+            intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response)
+            val bundle = Bundle(1)
+            bundle.putParcelable(AccountManager.KEY_INTENT, intent)
+            return bundle
+        }
 
         override fun editProperties(response: AccountAuthenticatorResponse?, accountType: String?) = null
         override fun getAuthTokenLabel(p0: String?) = null

app/src/main/java/at/bitfire/davdroid/syncadapter/SyncAdapterService.kt

@@ -0,0 +1,140 @@
+/*
+ * 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.syncadapter
+
+import android.Manifest
+import android.accounts.Account
+import android.app.PendingIntent
+import android.app.Service
+import android.content.*
+import android.content.pm.PackageManager
+import android.net.ConnectivityManager
+import android.net.wifi.WifiManager
+import android.os.Build
+import android.os.Bundle
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.AccountActivity
+import at.bitfire.davdroid.ui.AccountSettingsActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.logging.Level
+
+abstract class SyncAdapterService: Service() {
+
+    companion object {
+        /** Keep a list of running syncs to block multiple calls at the same time,
+         *  like run by some devices. Weak references are used for the case that a thread
+         *  is terminated and the `finally` block which cleans up [runningSyncs] is not
+         *  executed. */
+        private val runningSyncs = mutableListOf<WeakReference<Pair<String, Account>>>()
+    }
+
+    protected abstract fun syncAdapter(): AbstractThreadedSyncAdapter
+
+    override fun onBind(intent: Intent?) = syncAdapter().syncAdapterBinder!!
+
+
+    abstract class SyncAdapter(
+            context: Context
+    ): AbstractThreadedSyncAdapter(context, false) {
+
+        abstract fun sync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult)
+
+        override fun onPerformSync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
+            Logger.log.log(Level.INFO, "$authority sync of $account has been initiated", extras.keySet().joinToString(", "))
+
+            // prevent multiple syncs of the same authority to be run for the same account
+            val currentSync = Pair(authority, account)
+            synchronized(runningSyncs) {
+                if (runningSyncs.any { it.get() == currentSync }) {
+                    Logger.log.warning("There's already another $authority sync running for $account, aborting")
+                    return
+                }
+                runningSyncs += WeakReference(currentSync)
+            }
+
+            try {
+                // required for dav4jvm (ServiceLoader)
+                Thread.currentThread().contextClassLoader = context.classLoader
+
+                SyncManager.cancelNotifications(NotificationManagerCompat.from(context), authority, account)
+                sync(account, extras, authority, provider, syncResult)
+            } finally {
+                synchronized(runningSyncs) {
+                    runningSyncs.removeAll { it.get() == null || it.get() == currentSync }
+                }
+            }
+
+            Logger.log.info("Sync for $currentSync finished")
+        }
+
+        override fun onSecurityException(account: Account, extras: Bundle, authority: String, syncResult: SyncResult) {
+            Logger.log.log(Level.WARNING, "Security exception when opening content provider for $authority")
+            syncResult.databaseError = true
+
+            val intent = Intent(context, AccountActivity::class.java)
+            intent.putExtra(AccountActivity.EXTRA_ACCOUNT, account)
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+            notifyPermissions(intent)
+        }
+
+        protected fun checkSyncConditions(settings: AccountSettings): Boolean {
+            if (settings.getSyncWifiOnly()) {
+                val connectivityManager = context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
+                val network = connectivityManager.activeNetworkInfo
+                if (network == null || network.type != ConnectivityManager.TYPE_WIFI || !network.isConnected) {
+                    Logger.log.info("Not on connected WiFi, stopping")
+                    return false
+                }
+
+                settings.getSyncWifiOnlySSIDs()?.let { onlySSIDs ->
+                    // getting the WiFi name requires location permission (and active location services) since Android 8.1
+                    // see https://issuetracker.google.com/issues/70633700
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1 &&
+                        ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+                        val intent = Intent(context, AccountSettingsActivity::class.java)
+                        intent.putExtra(AccountActivity.EXTRA_ACCOUNT, settings.account)
+                        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+
+                        notifyPermissions(intent)
+                    }
+
+                    val wifi = context.applicationContext.getSystemService(WIFI_SERVICE) as WifiManager
+                    val info = wifi.connectionInfo
+                    if (info == null || !onlySSIDs.contains(info.ssid.trim('"'))) {
+                        Logger.log.info("Connected to wrong WiFi network (${info.ssid}), ignoring")
+                        return false
+                    }
+                }
+            }
+            return true
+        }
+
+        protected fun notifyPermissions(intent: Intent) {
+            val notify = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_SYNC_ERRORS)
+                    .setSmallIcon(R.drawable.ic_sync_error_notification)
+                    .setContentTitle(context.getString(R.string.sync_error_permissions))
+                    .setContentText(context.getString(R.string.sync_error_permissions_text))
+                    .setContentIntent(PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT))
+                    .setCategory(NotificationCompat.CATEGORY_ERROR)
+                    .setAutoCancel(true)
+                    .build()
+            NotificationManagerCompat.from(context).notify(NotificationUtils.NOTIFY_PERMISSIONS, notify)
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/SyncManager.kt

@@ -0,0 +1,862 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.Account
+import android.app.PendingIntent
+import android.content.*
+import android.net.Uri
+import android.os.Bundle
+import android.os.RemoteException
+import android.provider.CalendarContract
+import android.provider.ContactsContract
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import at.bitfire.dav4jvm.*
+import at.bitfire.dav4jvm.exception.*
+import at.bitfire.dav4jvm.property.GetCTag
+import at.bitfire.dav4jvm.property.GetETag
+import at.bitfire.dav4jvm.property.SyncToken
+import at.bitfire.davdroid.*
+import at.bitfire.davdroid.Constants
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.*
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.AccountSettingsActivity
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import at.bitfire.ical4android.CalendarStorageException
+import at.bitfire.ical4android.TaskProvider
+import at.bitfire.vcard4android.ContactsStorageException
+import okhttp3.HttpUrl
+import okhttp3.RequestBody
+import org.apache.commons.lang3.exception.ContextedException
+import org.dmfs.tasks.contract.TaskContract
+import java.io.IOException
+import java.io.InterruptedIOException
+import java.net.HttpURLConnection
+import java.security.cert.CertificateException
+import java.util.*
+import java.util.concurrent.*
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.logging.Level
+import javax.net.ssl.SSLHandshakeException
+
+@Suppress("MemberVisibilityCanBePrivate")
+abstract class SyncManager<ResourceType: LocalResource<*>, out CollectionType: LocalCollection<ResourceType>, RemoteType: DavCollection>(
+        val context: Context,
+        val account: Account,
+        val accountSettings: AccountSettings,
+        val extras: Bundle,
+        val authority: String,
+        val syncResult: SyncResult,
+        val localCollection: CollectionType
+): AutoCloseable {
+
+    enum class SyncAlgorithm {
+        PROPFIND_REPORT,
+        COLLECTION_SYNC
+    }
+
+    companion object {
+
+        val MAX_PROCESSING_THREADS =    // nCPU/2 (rounded up for case of 1 CPU), but max. 4
+                Math.min((Runtime.getRuntime().availableProcessors()+1)/2, 4)
+        val MAX_DOWNLOAD_THREADS =      // one (if one CPU), 2 otherwise
+                Math.min(Runtime.getRuntime().availableProcessors(), 2)
+        const val MAX_MULTIGET_RESOURCES = 10
+
+        fun cancelNotifications(manager: NotificationManagerCompat, authority: String, account: Account) =
+                manager.cancel(notificationTag(authority, account), NotificationUtils.NOTIFY_SYNC_ERROR)
+
+        private fun notificationTag(authority: String, account: Account) =
+                "$authority-${account.name}".hashCode().toString()
+
+    }
+
+    init {
+        Logger.log.info("SyncManager: using up to $MAX_PROCESSING_THREADS processing threads and $MAX_DOWNLOAD_THREADS download threads")
+    }
+
+    private val mainAccount = if (localCollection is LocalAddressBook)
+        localCollection.mainAccount
+    else
+        account
+
+    protected val notificationManager = NotificationManagerCompat.from(context)
+    protected val notificationTag = notificationTag(authority, mainAccount)
+
+    protected val httpClient = HttpClient.Builder(context, accountSettings).build()
+
+    protected lateinit var collectionURL: HttpUrl
+    protected lateinit var davCollection: RemoteType
+
+    protected var hasCollectionSync = false
+
+    override fun close() {
+        httpClient.close()
+    }
+
+
+    fun performSync() {
+        // dismiss previous error notifications
+        notificationManager.cancel(notificationTag, NotificationUtils.NOTIFY_SYNC_ERROR)
+
+        unwrapExceptions({
+            Logger.log.info("Preparing synchronization")
+            if (!prepare()) {
+                Logger.log.info("No reason to synchronize, aborting")
+                return@unwrapExceptions
+            }
+            abortIfCancelled()
+
+            Logger.log.info("Querying server capabilities")
+            var remoteSyncState = queryCapabilities()
+            abortIfCancelled()
+
+            Logger.log.info("Sending local deletes/updates to server")
+            val modificationsSent = processLocallyDeleted() ||
+                    uploadDirty()
+            abortIfCancelled()
+
+            if (modificationsSent || syncRequired(remoteSyncState))
+                when (syncAlgorithm()) {
+                    SyncAlgorithm.PROPFIND_REPORT -> {
+                        Logger.log.info("Sync algorithm: full listing as one result (PROPFIND/REPORT)")
+                        resetPresentRemotely()
+
+                        // get current sync state
+                        if (modificationsSent)
+                            remoteSyncState = querySyncState()
+
+                        // list and process all entries at current sync state (which may be the same as or newer than remoteSyncState)
+                        Logger.log.info("Processing remote entries")
+                        syncRemote { callback ->
+                            listAllRemote(callback)
+                        }
+
+                        Logger.log.info("Deleting entries which are not present remotely anymore")
+                        syncResult.stats.numDeletes += deleteNotPresentRemotely()
+
+                        Logger.log.info("Post-processing")
+                        postProcess()
+
+                        Logger.log.log(Level.INFO, "Saving sync state", remoteSyncState)
+                        localCollection.lastSyncState = remoteSyncState
+                    }
+                    SyncAlgorithm.COLLECTION_SYNC -> {
+                        var initialSync = false
+
+                        var syncState = localCollection.lastSyncState?.takeIf { it.type == SyncState.Type.SYNC_TOKEN }
+                        if (syncState == null) {
+                            Logger.log.info("Starting initial sync")
+                            initialSync = true
+                            resetPresentRemotely()
+                        } else if (syncState.initialSync == true) {
+                            Logger.log.info("Continuing initial sync")
+                            initialSync = true
+                        }
+
+                        var furtherChanges = false
+                        do {
+                            Logger.log.info("Listing changes since $syncState")
+                            syncRemote { callback ->
+                                try {
+                                    val result = listRemoteChanges(syncState, callback)
+                                    syncState = SyncState.fromSyncToken(result.first, initialSync)
+                                    furtherChanges = result.second
+                                } catch(e: HttpException) {
+                                    if (e.errors.contains(Error.VALID_SYNC_TOKEN)) {
+                                        Logger.log.info("Sync token invalid, performing initial sync")
+                                        initialSync = true
+                                        resetPresentRemotely()
+
+                                        val result = listRemoteChanges(null, callback)
+                                        syncState = SyncState.fromSyncToken(result.first, initialSync)
+                                        furtherChanges = result.second
+                                    } else
+                                        throw e
+                                }
+
+                                Logger.log.log(Level.INFO, "Saving sync state", syncState)
+                                localCollection.lastSyncState = syncState
+                            }
+
+                            Logger.log.info("Server has further changes: $furtherChanges")
+                        } while(furtherChanges)
+
+                        if (initialSync) {
+                            // initial sync is finished, remove all local resources which have not been listed by server
+                            Logger.log.info("Deleting local resources which are not on server (anymore)")
+                            deleteNotPresentRemotely()
+
+                            // remove initial sync flag
+                            syncState!!.initialSync = false
+                            Logger.log.log(Level.INFO, "Initial sync completed, saving sync state", syncState)
+                            localCollection.lastSyncState = syncState
+                        }
+
+                        Logger.log.info("Post-processing")
+                        postProcess()
+                    }
+                }
+            else
+                Logger.log.info("Remote collection didn't change, no reason to sync")
+
+        }, { e, local, remote ->
+            when (e) {
+                // sync was cancelled: re-throw to SyncAdapterService
+                is InterruptedException,
+                is InterruptedIOException ->
+                    throw e
+
+                // specific I/O errors
+                is SSLHandshakeException -> {
+                    Logger.log.log(Level.WARNING, "SSL handshake failed", e)
+
+                    // when a certificate is rejected by cert4android, the cause will be a CertificateException
+                    if (!BuildConfig.customCerts || e.cause !is CertificateException)
+                        notifyException(e, local, remote)
+                }
+
+                // specific HTTP errors
+                is ServiceUnavailableException -> {
+                    Logger.log.log(Level.WARNING, "Got 503 Service unavailable, trying again later", e)
+                    e.retryAfter?.let { retryAfter ->
+                        // how many seconds to wait? getTime() returns ms, so divide by 1000
+                        syncResult.delayUntil = (retryAfter.time - Date().time) / 1000
+                    }
+                }
+
+                // all others
+                else ->
+                    notifyException(e, local, remote)
+            }
+        })
+    }
+
+
+    protected abstract fun prepare(): Boolean
+
+    /**
+     * Queries the server for synchronization capabilities like specific report types,
+     * data formats etc.
+     *
+     * Should also query and save the initial sync state (e.g. CTag/sync-token).
+     *
+     * @return current sync state
+     */
+    protected abstract fun queryCapabilities(): SyncState?
+
+    /**
+     * Processes locally deleted entries and forwards them to the server (HTTP `DELETE`).
+     *
+     * @return whether resources have been deleted from the server
+     */
+    protected open fun processLocallyDeleted(): Boolean {
+        var numDeleted = 0
+
+        // Remove locally deleted entries from server (if they have a name, i.e. if they were uploaded before),
+        // but only if they don't have changed on the server. Then finally remove them from the local address book.
+        val localList = localCollection.findDeleted()
+        for (local in localList) {
+            abortIfCancelled()
+            useLocal(local) {
+                val fileName = local.fileName
+                if (fileName != null) {
+                    Logger.log.info("$fileName has been deleted locally -> deleting from server (ETag ${local.eTag})")
+
+                    useRemote(DavResource(httpClient.okHttpClient, collectionURL.newBuilder().addPathSegment(fileName).build())) { remote ->
+                        try {
+                            remote.delete(local.eTag) {}
+                            numDeleted++
+                        } catch (e: HttpException) {
+                            Logger.log.warning("Couldn't delete $fileName from server; ignoring (may be downloaded again)")
+                        }
+                    }
+                } else
+                    Logger.log.info("Removing local record #${local.id} which has been deleted locally and was never uploaded")
+                local.delete()
+                syncResult.stats.numDeletes++
+            }
+        }
+        Logger.log.info("Removed $numDeleted record(s) from server")
+        return numDeleted > 0
+    }
+
+    /**
+     * Uploads locally modified resources to the server (HTTP `PUT`).
+     *
+     * @return whether resources have been uploaded
+     */
+    protected open fun uploadDirty(): Boolean {
+        var numUploaded = 0
+
+        // upload dirty contacts
+        for (local in localCollection.findDirty())
+            useLocal(local) {
+                abortIfCancelled()
+
+                if (local.fileName == null) {
+                    Logger.log.fine("Generating file name/UID for local record #${local.id}")
+                    local.assignNameAndUID()
+                }
+
+                val fileName = local.fileName!!
+                useRemote(DavResource(httpClient.okHttpClient, collectionURL.newBuilder().addPathSegment(fileName).build())) { remote ->
+                    // generate entity to upload (VCard, iCal, whatever)
+                    val body = prepareUpload(local)
+
+                    var eTag: String? = null
+                    val processETag: (response: okhttp3.Response) -> Unit = { response ->
+                        response.header("ETag")?.let { getETag ->
+                            eTag = GetETag(getETag).eTag
+                        }
+                    }
+                    try {
+                        if (local.eTag == null) {
+                            Logger.log.info("Uploading new record $fileName")
+                            remote.put(body, null, true, processETag)
+                        } else {
+                            Logger.log.info("Uploading locally modified record $fileName")
+                            remote.put(body, local.eTag, false, processETag)
+                        }
+                        numUploaded++
+                    } catch(e: ForbiddenException) {
+                        // HTTP 403 Forbidden
+                        // If and only if the upload failed because of missing permissions, treat it like 412.
+                        if (e.errors.contains(Error.NEED_PRIVILEGES))
+                            Logger.log.log(Level.INFO, "Couldn't upload because of missing permissions, ignoring", e)
+                        else
+                            throw e
+                    } catch(e: ConflictException) {
+                        // HTTP 409 Conflict
+                        // We can't interact with the user to resolve the conflict, so we treat 409 like 412.
+                        Logger.log.log(Level.INFO, "Edit conflict, ignoring", e)
+                    } catch(e: PreconditionFailedException) {
+                        // HTTP 412 Precondition failed: Resource has been modified on the server in the meanwhile.
+                        // Ignore this condition so that the resource can be downloaded and reset again.
+                        Logger.log.log(Level.INFO, "Resource has been modified on the server before upload, ignoring", e)
+                    }
+
+                    if (eTag != null)
+                        Logger.log.fine("Received new ETag=$eTag after uploading")
+                    else
+                        Logger.log.fine("Didn't receive new ETag after uploading, setting to null")
+
+                    local.clearDirty(eTag)
+                }
+            }
+        Logger.log.info("Sent $numUploaded record(s) to server")
+        return numUploaded > 0
+    }
+
+    protected abstract fun prepareUpload(resource: ResourceType): RequestBody
+
+    /**
+     * Determines whether a sync is required because there were changes on the server.
+     * For instance, this method can compare the collection's `CTag`/`sync-token` with
+     * the last known local value.
+     *
+     * When local changes have been uploaded ([processLocallyDeleted] and/or
+     * [uploadDirty] were true), a sync is always required and this method
+     * should *not* be evaluated.
+     *
+     * @param state remote sync state to compare local sync state with
+     *
+     * @return whether data has been changed on the server, i.e. whether running the
+     * sync algorithm is required
+     */
+    protected open fun syncRequired(state: SyncState?): Boolean {
+        if (syncAlgorithm() == SyncAlgorithm.PROPFIND_REPORT && extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL)) {
+            Logger.log.info("Manual sync in PROPFIND/REPORT mode, forcing sync")
+            return true
+        }
+
+        val localState = localCollection.lastSyncState
+        Logger.log.info("Local sync state = $localState, remote sync state = $state")
+        return when {
+            state?.type == SyncState.Type.SYNC_TOKEN -> {
+                val lastKnownToken = localState?.takeIf { it.type == SyncState.Type.SYNC_TOKEN }?.value
+                lastKnownToken != state.value
+            }
+            state?.type == SyncState.Type.CTAG -> {
+                val lastKnownCTag = localState?.takeIf { it.type == SyncState.Type.CTAG }?.value
+                lastKnownCTag != state.value
+            }
+            else ->
+                true
+        }
+    }
+
+    /**
+     * Determines which sync algorithm to use.
+     * @return
+     *   - [SyncAlgorithm.PROPFIND_REPORT]: list all resources (with plain WebDAV
+     *   PROPFIND or specific REPORT requests), then compare and synchronize
+     *   - [SyncAlgorithm.COLLECTION_SYNC]: use incremental collection synchronization (RFC 6578)
+     */
+    protected abstract fun syncAlgorithm(): SyncAlgorithm
+
+    /**
+     * Marks all local resources which shall be taken into consideration for this
+     * sync as "synchronizing". Purpose of marking is that resources which have been marked
+     * and are not present remotely anymore can be deleted.
+     *
+     * Used together with [deleteNotPresentRemotely].
+     */
+    protected open fun resetPresentRemotely() {
+        val number = localCollection.markNotDirty(0)
+        Logger.log.info("Number of local non-dirty entries: $number")
+    }
+
+    protected open fun syncRemote(listRemote: (DavResponseCallback) -> Unit) {
+        // results must be processed in main thread because exceptions must be thrown in main
+        // thread, so that they can be catched by SyncManager
+        val results = ConcurrentLinkedQueue<Future<*>>()
+
+        // thread-safe sync stats
+        val nInserted = AtomicInteger()
+        val nUpdated = AtomicInteger()
+        val nDeleted = AtomicInteger()
+        val nSkipped = AtomicInteger()
+
+        // download queue
+        val toDownload = LinkedBlockingQueue<HttpUrl>()
+
+        // tasks from this executor create the download tasks (if necessary)
+        val processor = ThreadPoolExecutor(1, MAX_PROCESSING_THREADS,
+                10, TimeUnit.SECONDS,
+                LinkedBlockingQueue(MAX_PROCESSING_THREADS),  // accept up to MAX_PROCESSING_THREADS processing tasks
+                ThreadPoolExecutor.CallerRunsPolicy()         // if the queue is full, run task in submitting thread
+        )
+
+        // this executor runs the actual download tasks
+        val downloader = ThreadPoolExecutor(0, MAX_DOWNLOAD_THREADS,
+                10, TimeUnit.SECONDS,
+                LinkedBlockingQueue(MAX_DOWNLOAD_THREADS),  // accept up to MAX_DOWNLOAD_THREADS download tasks
+                ThreadPoolExecutor.CallerRunsPolicy()       // if the queue is full, run task in submitting thread
+        )
+        fun downloadBunch() {
+            val bunch = LinkedList<HttpUrl>()
+            toDownload.drainTo(bunch, MAX_MULTIGET_RESOURCES)
+            results += downloader.submit {
+                downloadRemote(bunch)
+            }
+        }
+
+        listRemote { response, relation ->
+            // ignore non-members
+            if (relation != Response.HrefRelation.MEMBER)
+                return@listRemote
+
+            // ignore collections
+            if (response[at.bitfire.dav4jvm.property.ResourceType::class.java]?.types?.contains(at.bitfire.dav4jvm.property.ResourceType.COLLECTION) == true)
+                return@listRemote
+
+            val name = response.hrefName()
+
+            if (response.isSuccess()) {
+                Logger.log.fine("Found remote resource: $name")
+
+                results += processor.submit {
+                    useLocal(localCollection.findByName(name)) { local ->
+                        if (local == null) {
+                            Logger.log.info("$name has been added remotely")
+                            toDownload += response.href
+                            nInserted.incrementAndGet()
+                        } else {
+                            val localETag = local.eTag
+                            val remoteETag = response[GetETag::class.java]?.eTag ?: throw DavException("Server didn't provide ETag")
+                            if (localETag == remoteETag) {
+                                Logger.log.info("$name has not been changed on server (ETag still $remoteETag)")
+                                nSkipped.incrementAndGet()
+                            } else {
+                                Logger.log.info("$name has been changed on server (current ETag=$remoteETag, last known ETag=$localETag)")
+                                toDownload += response.href
+                                nUpdated.incrementAndGet()
+                            }
+
+                            // mark as remotely present, so that this resource won't be deleted at the end
+                            local.updateFlags(LocalResource.FLAG_REMOTELY_PRESENT)
+                        }
+                    }
+
+                    synchronized(processor) {
+                        if (toDownload.size >= MAX_MULTIGET_RESOURCES)
+                            // download another bunch of MAX_MULTIGET_RESOURCES resources
+                            downloadBunch()
+                    }
+                }
+
+            } else if (response.status?.code == HttpURLConnection.HTTP_NOT_FOUND) {
+                // collection sync: resource has been deleted on remote server
+                results += processor.submit {
+                    useLocal(localCollection.findByName(name)) { local ->
+                        Logger.log.info("$name has been deleted on server, deleting locally")
+                        local?.delete()
+                        nDeleted.incrementAndGet()
+                    }
+                }
+            }
+
+            // check already available results for exceptions so that they don't become too many
+            checkResults(results)
+        }
+
+        // process remaining responses
+        processor.shutdown()
+        processor.awaitTermination(5, TimeUnit.MINUTES)
+
+        // download remaining resources
+        if (toDownload.isNotEmpty())
+            downloadBunch()
+
+        // signal end of queue and wait for download thread
+        downloader.shutdown()
+        downloader.awaitTermination(5, TimeUnit.MINUTES)
+
+        // check remaining results for exceptions
+        checkResults(results)
+
+        // update sync stats
+        with(syncResult.stats) {
+            numInserts += nInserted.get()
+            numUpdates += nUpdated.get()
+            numDeletes += nDeleted.get()
+            numSkippedEntries += nSkipped.get()
+        }
+    }
+
+    protected abstract fun listAllRemote(callback: DavResponseCallback)
+
+    protected open fun listRemoteChanges(syncState: SyncState?, callback: DavResponseCallback): Pair<SyncToken, Boolean> {
+        var furtherResults = false
+
+        val report = davCollection.reportChanges(
+                syncState?.takeIf { syncState.type == SyncState.Type.SYNC_TOKEN }?.value,
+                false, null,
+                GetETag.NAME) { response, relation ->
+            when (relation) {
+                Response.HrefRelation.SELF ->
+                    furtherResults = response.status?.code == 507
+
+                Response.HrefRelation.MEMBER ->
+                    callback(response, relation)
+
+                else ->
+                    Logger.log.fine("Unexpected sync-collection response: $response")
+            }
+        }
+
+        var syncToken: SyncToken? = null
+        report.filterIsInstance(SyncToken::class.java).firstOrNull()?.let {
+            syncToken = it
+        }
+        if (syncToken == null)
+            throw DavException("Received sync-collection response without sync-token")
+
+        return Pair(syncToken!!, furtherResults)
+    }
+
+    protected abstract fun downloadRemote(bunch: List<HttpUrl>)
+
+    /**
+     * Locally deletes entries which are
+     *   1. not dirty and
+     *   2. not marked as [LocalResource.FLAG_REMOTELY_PRESENT].
+     *
+     * Used together with [resetPresentRemotely] when a full listing has been received from
+     * the server to locally delete resources which are not present remotely (anymore).
+     */
+    protected open fun deleteNotPresentRemotely(): Int {
+        val removed = localCollection.removeNotDirtyMarked(0)
+        Logger.log.info("Removed $removed local resources which are not present on the server anymore")
+        return removed
+    }
+
+    /**
+     * Post-processing of synchronized entries, for instance contact group membership operations.
+     */
+    protected abstract fun postProcess()
+
+
+    // sync helpers
+
+    /**
+     * Throws an [InterruptedException] if the current thread has been interrupted,
+     * most probably because synchronization was cancelled by the user.
+     *
+     * @throws InterruptedException (which will be caught by [performSync])
+     * */
+    protected fun abortIfCancelled() {
+        if (Thread.interrupted())
+            throw InterruptedException("Sync was cancelled")
+    }
+
+    protected fun syncState(dav: Response) =
+            dav[SyncToken::class.java]?.token?.let {
+                SyncState(SyncState.Type.SYNC_TOKEN, it)
+            } ?:
+            dav[GetCTag::class.java]?.cTag?.let {
+                SyncState(SyncState.Type.CTAG, it)
+            }
+
+    private fun querySyncState(): SyncState? {
+        var state: SyncState? = null
+        davCollection.propfind(0, GetCTag.NAME, SyncToken.NAME) { response, relation ->
+            if (relation == Response.HrefRelation.SELF)
+                state = syncState(response)
+        }
+        return state
+    }
+
+
+    // exception helpers
+
+    private fun notifyException(e: Throwable, local: ResourceType?, remote: HttpUrl?) {
+        val message: String
+
+        when (e) {
+            is IOException,
+            is InterruptedIOException -> {
+                Logger.log.log(Level.WARNING, "I/O error", e)
+                message = context.getString(R.string.sync_error_io, e.localizedMessage)
+                syncResult.stats.numIoExceptions++
+            }
+            is UnauthorizedException -> {
+                Logger.log.log(Level.SEVERE, "Not authorized anymore", e)
+                message = context.getString(R.string.sync_error_authentication_failed)
+                syncResult.stats.numAuthExceptions++
+            }
+            is HttpException, is DavException -> {
+                Logger.log.log(Level.SEVERE, "HTTP/DAV exception", e)
+                message = context.getString(R.string.sync_error_http_dav, e.localizedMessage)
+                syncResult.stats.numParseExceptions++       // numIoExceptions would indicate a soft error
+            }
+            is CalendarStorageException, is ContactsStorageException, is RemoteException -> {
+                Logger.log.log(Level.SEVERE, "Couldn't access local storage", e)
+                message = context.getString(R.string.sync_error_local_storage, e.localizedMessage)
+                syncResult.databaseError = true
+            }
+            else -> {
+                Logger.log.log(Level.SEVERE, "Unclassified sync error", e)
+                message = e.localizedMessage ?: e::class.java.simpleName
+                syncResult.stats.numParseExceptions++
+            }
+        }
+
+        val contentIntent: Intent
+        var viewItemAction: NotificationCompat.Action? = null
+        if (e is UnauthorizedException) {
+            contentIntent = Intent(context, AccountSettingsActivity::class.java)
+            contentIntent.putExtra(AccountSettingsActivity.EXTRA_ACCOUNT,
+                    if (authority == ContactsContract.AUTHORITY)
+                        mainAccount
+                    else
+                        account)
+        } else {
+            contentIntent = buildDebugInfoIntent(e, local, remote)
+            if (local != null)
+                viewItemAction = buildViewItemAction(local)
+        }
+
+        // to make the PendingIntent unique
+        contentIntent.data = Uri.parse("davdroid:exception/${e.hashCode()}")
+
+        val channel: String
+        val priority: Int
+        if (e is IOException) {
+            channel = NotificationUtils.CHANNEL_SYNC_IO_ERRORS
+            priority = NotificationCompat.PRIORITY_MIN
+        } else {
+            channel = NotificationUtils.CHANNEL_SYNC_ERRORS
+            priority = NotificationCompat.PRIORITY_DEFAULT
+        }
+
+        val builder = NotificationUtils.newBuilder(context, channel)
+        builder .setSmallIcon(R.drawable.ic_sync_error_notification)
+                .setContentTitle(localCollection.title)
+                .setContentText(message)
+                .setStyle(NotificationCompat.BigTextStyle(builder).bigText(message))
+                .setSubText(mainAccount.name)
+                .setOnlyAlertOnce(true)
+                .setContentIntent(PendingIntent.getActivity(context, 0, contentIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+                .setPriority(priority)
+                .setCategory(NotificationCompat.CATEGORY_ERROR)
+        viewItemAction?.let { builder.addAction(it) }
+        builder.addAction(buildRetryAction())
+
+        notificationManager.notify(notificationTag, NotificationUtils.NOTIFY_SYNC_ERROR, builder.build())
+    }
+
+    private fun buildDebugInfoIntent(e: Throwable, local: ResourceType?, remote: HttpUrl?) =
+            Intent(context, DebugInfoActivity::class.java).apply {
+                putExtra(DebugInfoActivity.KEY_ACCOUNT, account)
+                putExtra(DebugInfoActivity.KEY_AUTHORITY, authority)
+                putExtra(DebugInfoActivity.KEY_THROWABLE, e)
+
+                // pass current local/remote resource
+                if (local != null)
+                    putExtra(DebugInfoActivity.KEY_LOCAL_RESOURCE, local.toString())
+                if (remote != null)
+                    putExtra(DebugInfoActivity.KEY_REMOTE_RESOURCE, remote.toString())
+            }
+
+    private fun buildRetryAction(): NotificationCompat.Action {
+        val retryIntent = Intent(context, DavService::class.java)
+        retryIntent.action = DavService.ACTION_FORCE_SYNC
+
+        val syncAuthority: String
+        val syncAccount: Account
+        if (authority == ContactsContract.AUTHORITY) {
+            // if this is a contacts sync, retry syncing all address books of the main account
+            syncAuthority = context.getString(R.string.address_books_authority)
+            syncAccount = mainAccount
+        } else {
+            syncAuthority = authority
+            syncAccount = account
+        }
+
+        retryIntent.data = Uri.parse("sync://").buildUpon()
+                .authority(syncAuthority)
+                .appendPath(syncAccount.type)
+                .appendPath(syncAccount.name)
+                .build()
+
+        return NotificationCompat.Action(
+                android.R.drawable.ic_menu_rotate, context.getString(R.string.sync_error_retry),
+                PendingIntent.getService(context, 0, retryIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+    }
+
+    private fun buildViewItemAction(local: ResourceType): NotificationCompat.Action? {
+        Logger.log.log(Level.FINE, "Adding view action for local resource", local)
+        val intent = local.id?.let { id ->
+            when (local) {
+                is LocalContact ->
+                    Intent(Intent.ACTION_VIEW, ContentUris.withAppendedId(ContactsContract.RawContacts.CONTENT_URI, id))
+                is LocalEvent ->
+                    Intent(Intent.ACTION_VIEW, ContentUris.withAppendedId(CalendarContract.Events.CONTENT_URI, id))
+                is LocalTask ->
+                    Intent(Intent.ACTION_VIEW, ContentUris.withAppendedId(TaskContract.Tasks.getContentUri(TaskProvider.ProviderName.OpenTasks.authority), id))
+                else ->
+                    null
+            }
+        }
+        return if (intent != null && context.packageManager.resolveActivity(intent, 0) != null)
+            NotificationCompat.Action(android.R.drawable.ic_menu_view, context.getString(R.string.sync_error_view_item),
+                    PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT))
+        else
+            null
+    }
+
+
+    fun checkResults(results: MutableCollection<Future<*>>) {
+        val iter = results.iterator()
+        while (iter.hasNext()) {
+            val result = iter.next()
+            if (result.isDone) {
+                try {
+                    result.get()
+                } catch(e: ExecutionException) {
+                    throw e.cause!!
+                }
+                iter.remove()
+            }
+        }
+    }
+
+    protected fun notifyInvalidResource(e: Throwable, fileName: String) {
+        val intent = buildDebugInfoIntent(e, null, collectionURL.resolve(fileName))
+
+        val builder = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_SYNC_WARNINGS)
+        builder .setSmallIcon(R.drawable.ic_warning_notify)
+                .setContentTitle(notifyInvalidResourceTitle())
+                .setContentText(context.getString(R.string.sync_invalid_resources_ignoring))
+                .setSubText(mainAccount.name)
+                .setContentIntent(PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT))
+                .setAutoCancel(true)
+                .setOnlyAlertOnce(true)
+                .priority = NotificationCompat.PRIORITY_LOW
+        notificationManager.notify(notificationTag, NotificationUtils.NOTIFY_INVALID_RESOURCE, builder.build())
+    }
+
+    protected abstract fun notifyInvalidResourceTitle(): String
+
+    protected fun<T: ResourceType?, R> useLocal(local: T, body: (T) -> R): R {
+        try {
+            return body(local)
+        } catch (e: ContextedException) {
+            e.addContextValue(Constants.EXCEPTION_CONTEXT_LOCAL_RESOURCE, local)
+            throw e
+        } catch (e: Throwable) {
+            if (local != null)
+                throw ContextedException(e).setContextValue(Constants.EXCEPTION_CONTEXT_LOCAL_RESOURCE, local)
+            else
+                throw e
+        }
+    }
+
+    protected fun<T: DavResource, R> useRemote(remote: T, body: (T) -> R): R {
+        try {
+            return body(remote)
+        } catch (e: ContextedException) {
+            e.addContextValue(Constants.EXCEPTION_CONTEXT_REMOTE_RESOURCE, remote.location)
+            throw e
+        } catch(e: Throwable) {
+            throw ContextedException(e).setContextValue(Constants.EXCEPTION_CONTEXT_REMOTE_RESOURCE, remote.location)
+        }
+    }
+
+    protected fun<T> useRemote(remote: Response, body: (Response) -> T): T {
+        try {
+            return body(remote)
+        } catch (e: ContextedException) {
+            e.addContextValue(Constants.EXCEPTION_CONTEXT_REMOTE_RESOURCE, remote.href)
+            throw e
+        } catch (e: Throwable) {
+            throw ContextedException(e).setContextValue(Constants.EXCEPTION_CONTEXT_REMOTE_RESOURCE, remote.href)
+        }
+    }
+
+    protected fun<R> useRemoteCollection(body: (RemoteType) -> R) =
+            useRemote(davCollection, body)
+
+    private fun unwrapExceptions(body: () -> Unit, handler: (e: Throwable, local: ResourceType?, remote: HttpUrl?) -> Unit) {
+        var ex: Throwable? = null
+        try {
+            body()
+        } catch(e: Throwable) {
+            ex = e
+        }
+
+        var local: ResourceType? = null
+        var remote: HttpUrl? = null
+
+        if (ex is ContextedException) {
+            @Suppress("UNCHECKED_CAST")
+            // we want the innermost context value, which is the first one
+            (ex.getFirstContextValue(Constants.EXCEPTION_CONTEXT_LOCAL_RESOURCE) as? ResourceType)?.let {
+                if (local == null)
+                    local = it
+            }
+            (ex.getFirstContextValue(Constants.EXCEPTION_CONTEXT_REMOTE_RESOURCE) as? HttpUrl)?.let {
+                if (remote == null)
+                    remote = it
+            }
+            ex = ex.cause
+        }
+
+        if (ex != null)
+            handler(ex, local, remote)
+    }
+
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/TasksSyncAdapterService.kt

@@ -0,0 +1,168 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.app.PendingIntent
+import android.content.*
+import android.content.pm.PackageManager
+import android.database.DatabaseUtils
+import android.graphics.drawable.BitmapDrawable
+import android.net.Uri
+import android.os.Build
+import android.os.Bundle
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.davdroid.model.ServiceDB.Services
+import at.bitfire.davdroid.resource.LocalTaskList
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.NotificationUtils
+import at.bitfire.ical4android.AndroidTaskList
+import at.bitfire.ical4android.TaskProvider
+import okhttp3.HttpUrl
+import org.dmfs.tasks.contract.TaskContract
+import java.util.logging.Level
+
+/**
+ * Synchronization manager for CalDAV collections; handles tasks ({@code VTODO}).
+ */
+class TasksSyncAdapterService: SyncAdapterService() {
+
+    override fun syncAdapter() = TasksSyncAdapter(this)
+
+
+	class TasksSyncAdapter(
+            context: Context
+    ): SyncAdapter(context) {
+
+        override fun sync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
+            try {
+                val taskProvider = TaskProvider.fromProviderClient(context, provider)
+
+                // make sure account can be seen by OpenTasks
+                if (Build.VERSION.SDK_INT >= 26)
+                    AccountManager.get(context).setAccountVisibility(account, taskProvider.name.packageName, AccountManager.VISIBILITY_VISIBLE)
+
+                val accountSettings = AccountSettings(context, account)
+                /* don't run sync if
+                   - sync conditions (e.g. "sync only in WiFi") are not met AND
+                   - this is is an automatic sync (i.e. manual syncs are run regardless of sync conditions)
+                 */
+                if (!extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL) && !checkSyncConditions(accountSettings))
+                    return
+
+                updateLocalTaskLists(taskProvider, account, accountSettings)
+
+                for (taskList in AndroidTaskList.find(account, taskProvider, LocalTaskList.Factory, "${TaskContract.TaskLists.SYNC_ENABLED}!=0", null)) {
+                    Logger.log.info("Synchronizing task list #${taskList.id} [${taskList.syncId}]")
+                    TasksSyncManager(context, account, accountSettings, extras, authority, syncResult, taskList).use {
+                        it.performSync()
+                    }
+                }
+            } catch (e: TaskProvider.ProviderTooOldException) {
+                val nm = NotificationManagerCompat.from(context)
+                val message = context.getString(R.string.sync_error_opentasks_required_version, e.provider.minVersionName, e.installedVersionName)
+                val notify = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_SYNC_ERRORS)
+                        .setSmallIcon(R.drawable.ic_sync_error_notification)
+                        .setContentTitle(context.getString(R.string.sync_error_opentasks_too_old))
+                        .setContentText(message)
+                        .setStyle(NotificationCompat.BigTextStyle().bigText(message))
+                        .setCategory(NotificationCompat.CATEGORY_ERROR)
+
+                try {
+                    val icon = context.packageManager.getApplicationIcon(e.provider.packageName)
+                    if (icon is BitmapDrawable)
+                        notify.setLargeIcon(icon.bitmap)
+                } catch(ignored: PackageManager.NameNotFoundException) {}
+
+                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=${e.provider.packageName}"))
+                if (intent.resolveActivity(context.packageManager) != null)
+                    notify  .setContentIntent(PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT))
+                            .setAutoCancel(true)
+
+                nm.notify(NotificationUtils.NOTIFY_OPENTASKS, notify.build())
+                syncResult.databaseError = true
+            } catch (e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't sync task lists", e)
+                syncResult.databaseError = true
+            }
+
+            Logger.log.info("Task sync complete")
+        }
+
+        private fun updateLocalTaskLists(provider: TaskProvider, account: Account, settings: AccountSettings) {
+            ServiceDB.OpenHelper(context).use { dbHelper ->
+                val db = dbHelper.readableDatabase
+
+                fun getService() =
+                        db.query(Services._TABLE, arrayOf(Services.ID),
+                                "${Services.ACCOUNT_NAME}=? AND ${Services.SERVICE}=?",
+                                arrayOf(account.name, Services.SERVICE_CALDAV), null, null, null)?.use { c ->
+                            if (c.moveToNext())
+                                c.getLong(0)
+                            else
+                                null
+                        }
+
+                fun remoteTaskLists(service: Long?): MutableMap<HttpUrl, CollectionInfo> {
+                    val collections = mutableMapOf<HttpUrl, CollectionInfo>()
+                    service?.let {
+                        db.query(Collections._TABLE, null,
+                                "${Collections.SERVICE_ID}=? AND ${Collections.SUPPORTS_VTODO}!=0 AND ${Collections.SYNC}",
+                                arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                            while (cursor.moveToNext()) {
+                                val values = ContentValues(cursor.columnCount)
+                                DatabaseUtils.cursorRowToContentValues(cursor, values)
+                                val info = CollectionInfo(values)
+                                collections[info.url] = info
+                            }
+                        }
+                    }
+                    return collections
+                }
+
+                // enumerate remote and local task lists
+                val service = getService()
+                val remote = remoteTaskLists(service)
+
+                // delete/update local task lists
+                val updateColors = settings.getManageCalendarColors()
+
+                for (list in AndroidTaskList.find(account, provider, LocalTaskList.Factory, null, null))
+                    list.syncId?.let {
+                        val url = HttpUrl.parse(it)!!
+                        val info = remote[url]
+                        if (info == null) {
+                            Logger.log.fine("Deleting obsolete local task list $url")
+                            list.delete()
+                        } else {
+                            // remote CollectionInfo found for this local collection, update data
+                            Logger.log.log(Level.FINE, "Updating local task list $url", info)
+                            list.update(info, updateColors)
+                            // we already have a local task list for this remote collection, don't take into consideration anymore
+                            remote -= url
+                        }
+                    }
+
+                // create new local task lists
+                for ((_,info) in remote) {
+                    Logger.log.log(Level.INFO, "Adding local task list", info)
+                    LocalTaskList.create(account, provider, info)
+                }
+            }
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/syncadapter/TasksSyncManager.kt

@@ -0,0 +1,172 @@
+/*
+ * 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.syncadapter
+
+import android.accounts.Account
+import android.content.Context
+import android.content.SyncResult
+import android.os.Bundle
+import at.bitfire.dav4jvm.DavCalendar
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.DavResponseCallback
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.exception.DavException
+import at.bitfire.dav4jvm.property.CalendarData
+import at.bitfire.dav4jvm.property.GetCTag
+import at.bitfire.dav4jvm.property.GetETag
+import at.bitfire.dav4jvm.property.SyncToken
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.LocalResource
+import at.bitfire.davdroid.resource.LocalTask
+import at.bitfire.davdroid.resource.LocalTaskList
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.ical4android.InvalidCalendarException
+import at.bitfire.ical4android.Task
+import okhttp3.HttpUrl
+import okhttp3.RequestBody
+import java.io.ByteArrayOutputStream
+import java.io.Reader
+import java.io.StringReader
+import java.util.logging.Level
+
+/**
+ * Synchronization manager for CalDAV collections; handles tasks (VTODO)
+ */
+class TasksSyncManager(
+        context: Context,
+        account: Account,
+        accountSettings: AccountSettings,
+        extras: Bundle,
+        authority: String,
+        syncResult: SyncResult,
+        localCollection: LocalTaskList
+): SyncManager<LocalTask, LocalTaskList, DavCalendar>(context, account, accountSettings, extras, authority, syncResult, localCollection) {
+
+    override fun prepare(): Boolean {
+        collectionURL = HttpUrl.parse(localCollection.syncId ?: return false) ?: return false
+        davCollection = DavCalendar(httpClient.okHttpClient, collectionURL)
+
+        return true
+    }
+
+    override fun queryCapabilities() =
+            useRemoteCollection {
+                var syncState: SyncState? = null
+                it.propfind(0, GetCTag.NAME, SyncToken.NAME) { response, relation ->
+                    if (relation == Response.HrefRelation.SELF)
+                    syncState = syncState(response)
+                }
+                syncState
+            }
+
+    override fun syncAlgorithm() = SyncAlgorithm.PROPFIND_REPORT
+
+    override fun prepareUpload(resource: LocalTask): RequestBody = useLocal(resource) {
+        val task = requireNotNull(resource.task)
+        Logger.log.log(Level.FINE, "Preparing upload of task ${resource.fileName}", task)
+
+        val os = ByteArrayOutputStream()
+        task.write(os)
+
+        RequestBody.create(
+                DavCalendar.MIME_ICALENDAR_UTF8,
+                os.toByteArray()
+        )
+    }
+
+    override fun listAllRemote(callback: DavResponseCallback) {
+        useRemoteCollection { remote ->
+            Logger.log.info("Querying tasks")
+            remote.calendarQuery("VTODO", null, null, callback)
+        }
+    }
+
+    override fun downloadRemote(bunch: List<HttpUrl>) {
+        Logger.log.info("Downloading ${bunch.size} iCalendars: $bunch")
+        if (bunch.size == 1) {
+            val remote = bunch.first()
+            // only one contact, use GET
+            useRemote(DavResource(httpClient.okHttpClient, remote)) { resource ->
+                resource.get(DavCalendar.MIME_ICALENDAR.toString()) { response ->
+                    // CalDAV servers MUST return ETag on GET [https://tools.ietf.org/html/rfc4791#section-5.3.4]
+                    val eTag = response.header("ETag")?.let { GetETag(it).eTag }
+                            ?: throw DavException("Received CalDAV GET response without ETag")
+
+                    response.body()!!.use {
+                        processVTodo(resource.fileName(), eTag, it.charStream())
+                    }
+                }
+            }
+        } else
+            // multiple iCalendars, use calendar-multi-get
+            useRemoteCollection {
+                it.multiget(bunch) { response, _ ->
+                    useRemote(response) {
+                        if (!response.isSuccess()) {
+                            Logger.log.warning("Received non-successful multiget response for ${response.href}")
+                            return@useRemote
+                        }
+
+                        val eTag = response[GetETag::class.java]?.eTag
+                                ?: throw DavException("Received multi-get response without ETag")
+
+                        val calendarData = response[CalendarData::class.java]
+                        val iCal = calendarData?.iCalendar
+                                ?: throw DavException("Received multi-get response without address data")
+
+                        processVTodo(DavUtils.lastSegmentOfUrl(response.href), eTag, StringReader(iCal))
+                    }
+                }
+            }
+    }
+
+    override fun postProcess() {
+    }
+
+    // helpers
+
+    private fun processVTodo(fileName: String, eTag: String, reader: Reader) {
+        val tasks: List<Task>
+        try {
+            tasks = Task.fromReader(reader)
+        } catch (e: InvalidCalendarException) {
+            Logger.log.log(Level.SEVERE, "Received invalid iCalendar, ignoring", e)
+            notifyInvalidResource(e, fileName)
+            return
+        }
+
+        if (tasks.size == 1) {
+            val newData = tasks.first()
+
+            // update local task, if it exists
+            useLocal(localCollection.findByName(fileName)) { local ->
+                if (local != null) {
+                    Logger.log.log(Level.INFO, "Updating $fileName in local task list", newData)
+                    local.eTag = eTag
+                    local.update(newData)
+                    syncResult.stats.numUpdates++
+                } else {
+                    Logger.log.log(Level.INFO, "Adding $fileName to local task list", newData)
+                    useLocal(LocalTask(localCollection, newData, fileName, eTag, LocalResource.FLAG_REMOTELY_PRESENT)) {
+                        it.add()
+                    }
+                    syncResult.stats.numInserts++
+                }
+            }
+        } else
+            Logger.log.info("Received VCALENDAR with not exactly one VTODO; ignoring $fileName")
+    }
+
+    override fun notifyInvalidResourceTitle(): String =
+            context.getString(R.string.sync_invalid_task)
+
+}

app/src/main/java/at/bitfire/davdroid/ui/AboutActivity.kt

@@ -0,0 +1,137 @@
+/*
+ * 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.Application
+import android.os.Build
+import android.os.Bundle
+import android.text.Spanned
+import android.util.DisplayMetrics
+import android.view.*
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.text.HtmlCompat
+import androidx.fragment.app.Fragment
+import androidx.fragment.app.FragmentManager
+import androidx.fragment.app.FragmentPagerAdapter
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.Observer
+import androidx.lifecycle.ViewModelProviders
+import at.bitfire.davdroid.App
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.davdroid.R
+import com.mikepenz.aboutlibraries.LibsBuilder
+import kotlinx.android.synthetic.main.about.*
+import kotlinx.android.synthetic.main.activity_about.*
+import org.apache.commons.io.IOUtils
+import java.text.SimpleDateFormat
+import java.util.*
+import kotlin.concurrent.thread
+
+class AboutActivity: AppCompatActivity() {
+
+    companion object {
+
+        const val pixelsHtml = "<font color=\"#fff433\">■</font>" +
+                "<font color=\"#ffffff\">■</font>" +
+                "<font color=\"#9b59d0\">■</font>" +
+                "<font color=\"#000000\">■</font>"
+
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_about)
+
+        setSupportActionBar(toolbar)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        viewpager.adapter = TabsAdapter(supportFragmentManager)
+        tabs.setupWithViewPager(viewpager, false)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu?): Boolean {
+        menuInflater.inflate(R.menu.about_davdroid, menu)
+        return true
+    }
+
+    fun showWebsite(item: MenuItem) {
+        UiUtils.launchUri(this, App.homepageUrl(this))
+    }
+
+
+    private inner class TabsAdapter(
+            fm: FragmentManager
+    ): FragmentPagerAdapter(fm) {
+
+        override fun getCount() = 2
+
+        override fun getPageTitle(position: Int): String =
+                when (position) {
+                    0 -> getString(R.string.app_name)
+                    else -> getString(R.string.about_libraries)
+                }
+
+        override fun getItem(position: Int) =
+                when (position) {
+                    0 -> AppFragment()
+                    else -> LibsBuilder()
+                            .withAutoDetect(false)
+                            .withFields(R.string::class.java.fields)
+                            .withLicenseShown(true)
+                            .supportFragment()
+                }!!
+    }
+
+
+    class AppFragment: Fragment() {
+
+        override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?) =
+                inflater.inflate(R.layout.about, container, false)!!
+
+        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+            app_name.text = getString(R.string.app_name)
+            app_version.text = getString(R.string.about_version, BuildConfig.VERSION_NAME, BuildConfig.VERSION_CODE)
+            build_time.text = getString(R.string.about_build_date, SimpleDateFormat.getDateInstance().format(BuildConfig.buildTime))
+
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O)
+                icon.setImageDrawable(resources.getDrawableForDensity(R.mipmap.ic_launcher, DisplayMetrics.DENSITY_XXXHIGH))
+
+            pixels.text = HtmlCompat.fromHtml(pixelsHtml, HtmlCompat.FROM_HTML_MODE_LEGACY)
+
+            if (true /* open-source version */) {
+                warranty.setText(R.string.about_license_info_no_warranty)
+
+                val model = ViewModelProviders.of(this).get(LicenseModel::class.java)
+                model.htmlText.observe(this, Observer { spanned ->
+                    license_text.text = spanned
+                })
+            }
+        }
+
+    }
+
+    class LicenseModel(
+            application: Application
+    ): AndroidViewModel(application) {
+
+        val htmlText = MutableLiveData<Spanned>()
+
+        init {
+            thread {
+                getApplication<Application>().resources.assets.open("gplv3.html").use {
+                    val spanned = HtmlCompat.fromHtml(IOUtils.toString(it, Charsets.UTF_8), HtmlCompat.FROM_HTML_MODE_LEGACY)
+                    htmlText.postValue(spanned)
+                }
+            }
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/AccountActivity.kt

@@ -0,0 +1,841 @@
+/*
+ * 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.Manifest
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.annotation.SuppressLint
+import android.app.Dialog
+import android.content.*
+import android.content.pm.PackageManager
+import android.database.DatabaseUtils
+import android.database.sqlite.SQLiteDatabase
+import android.net.Uri
+import android.os.*
+import android.provider.CalendarContract
+import android.provider.ContactsContract
+import android.view.*
+import android.widget.*
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import androidx.appcompat.content.res.AppCompatResources
+import androidx.appcompat.widget.Toolbar
+import androidx.core.app.ActivityCompat
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.DialogFragment
+import androidx.loader.app.LoaderManager
+import androidx.loader.content.AsyncTaskLoader
+import androidx.loader.content.Loader
+import at.bitfire.davdroid.DavService
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.model.ServiceDB.*
+import at.bitfire.davdroid.model.ServiceDB.Collections
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.resource.LocalTaskList
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.ical4android.TaskProvider
+import com.google.android.material.snackbar.Snackbar
+import kotlinx.android.synthetic.main.account_caldav_item.view.*
+import kotlinx.android.synthetic.main.activity_account.*
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.logging.Level
+
+class AccountActivity: AppCompatActivity(), Toolbar.OnMenuItemClickListener, PopupMenu.OnMenuItemClickListener, LoaderManager.LoaderCallbacks<AccountActivity.AccountInfo> {
+
+    companion object {
+        const val EXTRA_ACCOUNT = "account"
+
+        private fun requestSync(context: Context, account: Account) {
+            val authorities = arrayOf(
+                    context.getString(R.string.address_books_authority),
+                    CalendarContract.AUTHORITY,
+                    TaskProvider.ProviderName.OpenTasks.authority
+            )
+
+            for (authority in authorities) {
+                val extras = Bundle(2)
+                extras.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)        // manual sync
+                extras.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, true)     // run immediately (don't queue)
+                ContentResolver.requestSync(account, authority, extras)
+            }
+        }
+
+    }
+
+    lateinit var account: Account
+    private var accountInfo: AccountInfo? = null
+
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        // account may be a DAVx5 address book account -> use main account in this case
+        account = LocalAddressBook.mainAccount(this,
+                requireNotNull(intent.getParcelableExtra(EXTRA_ACCOUNT)))
+        title = account.name
+
+        setContentView(R.layout.activity_account)
+        val icMenu = AppCompatResources.getDrawable(this, R.drawable.ic_menu_light)
+
+        // CardDAV toolbar
+        carddav_menu.overflowIcon = icMenu
+        carddav_menu.inflateMenu(R.menu.carddav_actions)
+        carddav_menu.setOnMenuItemClickListener(this)
+
+        // CalDAV toolbar
+        caldav_menu.overflowIcon = icMenu
+        caldav_menu.inflateMenu(R.menu.caldav_actions)
+        caldav_menu.setOnMenuItemClickListener(this)
+
+        // Webcal toolbar
+        webcal_menu.overflowIcon = icMenu
+        webcal_menu.inflateMenu(R.menu.webcal_actions)
+        webcal_menu.setOnMenuItemClickListener(this)
+
+        // load CardDAV/CalDAV collections
+        LoaderManager.getInstance(this).initLoader(0, null, this)
+    }
+
+    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+        if (grantResults.any { it == PackageManager.PERMISSION_GRANTED })
+            // we've got additional permissions; try to load everything again
+            reload()
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.activity_account, menu)
+        return true
+    }
+
+    override fun onPrepareOptionsMenu(menu: Menu): Boolean {
+        val itemRename = menu.findItem(R.id.rename_account)
+        // renameAccount is available for API level 21+
+        itemRename.isVisible = Build.VERSION.SDK_INT >= 21
+        return super.onPrepareOptionsMenu(menu)
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem): Boolean {
+        when (item.itemId) {
+            R.id.sync_now ->
+                requestSync()
+            R.id.settings -> {
+                val intent = Intent(this, AccountSettingsActivity::class.java)
+                intent.putExtra(AccountSettingsActivity.EXTRA_ACCOUNT, account)
+                startActivity(intent)
+            }
+            R.id.rename_account ->
+                RenameAccountFragment.newInstance(account).show(supportFragmentManager, null)
+            R.id.delete_account -> {
+                AlertDialog.Builder(this)
+                        .setIcon(R.drawable.ic_error_dark)
+                        .setTitle(R.string.account_delete_confirmation_title)
+                        .setMessage(R.string.account_delete_confirmation_text)
+                        .setNegativeButton(android.R.string.no, null)
+                        .setPositiveButton(android.R.string.yes) { _, _ ->
+                            deleteAccount()
+                        }
+                        .show()
+            }
+            else ->
+                return super.onOptionsItemSelected(item)
+        }
+        return true
+    }
+
+    override fun onMenuItemClick(item: MenuItem): Boolean {
+        when (item.itemId) {
+            R.id.refresh_address_books ->
+                accountInfo?.carddav?.let { carddav ->
+                    val intent = Intent(this, DavService::class.java)
+                    intent.action = DavService.ACTION_REFRESH_COLLECTIONS
+                    intent.putExtra(DavService.EXTRA_DAV_SERVICE_ID, carddav.id)
+                    startService(intent)
+                }
+            R.id.create_address_book -> {
+                val intent = Intent(this, CreateAddressBookActivity::class.java)
+                intent.putExtra(CreateAddressBookActivity.EXTRA_ACCOUNT, account)
+                startActivity(intent)
+            }
+            R.id.refresh_calendars ->
+                accountInfo?.caldav?.let { caldav ->
+                    val intent = Intent(this, DavService::class.java)
+                    intent.action = DavService.ACTION_REFRESH_COLLECTIONS
+                    intent.putExtra(DavService.EXTRA_DAV_SERVICE_ID, caldav.id)
+                    startService(intent)
+                }
+            R.id.create_calendar -> {
+                val intent = Intent(this, CreateCalendarActivity::class.java)
+                intent.putExtra(CreateCalendarActivity.EXTRA_ACCOUNT, account)
+                startActivity(intent)
+            }
+        }
+        return false
+    }
+
+
+    private val onItemClickListener = AdapterView.OnItemClickListener { parent, view, position, _ ->
+        if (!view.isEnabled)
+            return@OnItemClickListener
+
+        val list = parent as ListView
+        val adapter = list.adapter as ArrayAdapter<CollectionInfo>
+        val info = adapter.getItem(position)!!
+        val nowChecked = !info.selected
+
+        SelectCollectionTask(applicationContext, info, nowChecked, WeakReference(adapter), WeakReference(view)).execute()
+    }
+
+    private val onActionOverflowListener = { anchor: View, info: CollectionInfo ->
+        val popup = PopupMenu(this, anchor, Gravity.RIGHT)
+        popup.inflate(R.menu.account_collection_operations)
+
+        with(popup.menu.findItem(R.id.force_read_only)) {
+            if (info.privWriteContent)
+                isChecked = info.forceReadOnly
+            else
+                isVisible = false
+        }
+
+        popup.menu.findItem(R.id.delete_collection).isVisible = info.privUnbind
+
+        popup.setOnMenuItemClickListener { item ->
+            when (item.itemId) {
+                R.id.force_read_only -> {
+                    val nowChecked = !item.isChecked
+                    SetReadOnlyTask(WeakReference(this), info.id!!, nowChecked).execute()
+                }
+                R.id.delete_collection ->
+                    DeleteCollectionFragment.newInstance(account, info).show(supportFragmentManager, null)
+                R.id.properties ->
+                    CollectionInfoFragment.newInstance(info).show(supportFragmentManager, null)
+            }
+            true
+        }
+        popup.show()
+
+        // long click was handled
+        true
+    }
+
+    private val webcalOnItemClickListener = AdapterView.OnItemClickListener { parent, _, position, _ ->
+        val info = parent.getItemAtPosition(position) as CollectionInfo
+        var uri = Uri.parse(info.source)
+
+        val nowChecked = !info.selected
+        if (nowChecked) {
+            // subscribe to Webcal feed
+            when {
+                uri.scheme.equals("http", true) -> uri = uri.buildUpon().scheme("webcal").build()
+                uri.scheme.equals("https", true) -> uri = uri.buildUpon().scheme("webcals").build()
+            }
+
+            val intent = Intent(Intent.ACTION_VIEW, uri)
+            info.displayName?.let { intent.putExtra("title", it) }
+            info.color?.let { intent.putExtra("color", it) }
+            if (packageManager.resolveActivity(intent, 0) != null)
+                startActivity(intent)
+            else {
+                val snack = Snackbar.make(parent, R.string.account_no_webcal_handler_found, Snackbar.LENGTH_LONG)
+
+                val installIntent = Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=at.bitfire.icsdroid"))
+                if (packageManager.resolveActivity(installIntent, 0) != null)
+                    snack.setAction(R.string.account_install_icsx5) {
+                        startActivity(installIntent)
+                    }
+
+                snack.show()
+            }
+        } else {
+            // unsubscribe from Webcal feed
+            if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED)
+                contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { provider ->
+                    try {
+                        provider.delete(CalendarContract.Calendars.CONTENT_URI, "${CalendarContract.Calendars.NAME}=?", arrayOf(info.source))
+                        reload()
+                    } finally {
+                        @Suppress("DEPRECATION")
+                        if (Build.VERSION.SDK_INT >= 24)
+                            provider.close()
+                        else
+                            provider.release()
+                    }
+                }
+        }
+    }
+
+
+    /* TASKS */
+
+    @SuppressLint("StaticFieldLeak")
+    class SelectCollectionTask(
+            val applicationContext: Context,
+
+            val info: CollectionInfo,
+            val nowChecked: Boolean,
+            val adapter: WeakReference<ArrayAdapter<*>>,
+            val view: WeakReference<View>
+    ): AsyncTask<Void, Void, Void>() {
+
+        override fun onPreExecute() {
+            view.get()?.isEnabled = false
+        }
+
+        override fun doInBackground(vararg params: Void?): Void? {
+            val values = ContentValues(1)
+            values.put(Collections.SYNC, if (nowChecked) 1 else 0)
+
+            OpenHelper(applicationContext).use { dbHelper ->
+                val db = dbHelper.writableDatabase
+                db.update(Collections._TABLE, values, "${Collections.ID}=?", arrayOf(info.id.toString()))
+            }
+
+            return null
+        }
+
+        override fun onPostExecute(result: Void?) {
+            info.selected = nowChecked
+            adapter.get()?.notifyDataSetChanged()
+            view.get()?.isEnabled = true
+        }
+
+    }
+
+    class SetReadOnlyTask(
+            val activity: WeakReference<AccountActivity>,
+            val id: Long,
+            val nowChecked: Boolean
+    ): AsyncTask<Void, Void, Void>() {
+
+        override fun doInBackground(vararg params: Void?): Void? {
+            activity.get()?.let { context ->
+                OpenHelper(context).use { dbHelper ->
+                    val values = ContentValues(1)
+                    values.put(Collections.FORCE_READ_ONLY, nowChecked)
+
+                    val db = dbHelper.writableDatabase
+                    db.update(Collections._TABLE, values, "${Collections.ID}=?", arrayOf(id.toString()))
+                }
+            }
+            return null
+        }
+
+        override fun onPostExecute(result: Void?) {
+            activity.get()?.reload()
+        }
+
+    }
+
+
+    /* LOADERS AND LOADED DATA */
+
+    class AccountInfo {
+        var carddav: ServiceInfo? = null
+        var caldav: ServiceInfo? = null
+
+        class ServiceInfo {
+            var id: Long? = null
+            var refreshing = false
+
+            var hasHomeSets = false
+            var collections = listOf<CollectionInfo>()
+        }
+    }
+
+    override fun onCreateLoader(id: Int, args: Bundle?) =
+            AccountLoader(this, account)
+
+    fun reload() {
+        LoaderManager.getInstance(this).restartLoader(0, null, this)
+    }
+
+    override fun onLoadFinished(loader: Loader<AccountInfo>, info: AccountInfo?) {
+        accountInfo = info
+
+        if (info?.caldav?.collections?.any { it.selected } != true &&
+            info?.carddav?.collections?.any { it.selected} != true)
+            select_collections_hint.visibility = View.VISIBLE
+
+        carddav.visibility = info?.carddav?.let { carddav ->
+            carddav_refreshing.visibility = if (carddav.refreshing) View.VISIBLE else View.GONE
+
+            address_books.isEnabled = !carddav.refreshing
+            address_books.alpha = if (carddav.refreshing) 0.5f else 1f
+
+            carddav_menu.menu.findItem(R.id.create_address_book).isEnabled = carddav.hasHomeSets
+
+            val adapter = AddressBookAdapter(this)
+            adapter.addAll(carddav.collections)
+            address_books.adapter = adapter
+            address_books.onItemClickListener = onItemClickListener
+
+            View.VISIBLE
+        } ?: View.GONE
+
+        caldav.visibility = info?.caldav?.let { caldav ->
+            caldav_refreshing.visibility = if (caldav.refreshing) View.VISIBLE else View.GONE
+
+            calendars.isEnabled = !caldav.refreshing
+            calendars.alpha = if (caldav.refreshing) 0.5f else 1f
+
+            caldav_menu.menu.findItem(R.id.create_calendar).isEnabled = caldav.hasHomeSets
+
+            val adapter = CalendarAdapter(this)
+            adapter.addAll(caldav.collections.filter { it.type == CollectionInfo.Type.CALENDAR })
+            calendars.adapter = adapter
+            calendars.onItemClickListener = onItemClickListener
+
+            View.VISIBLE
+        } ?: View.GONE
+
+        webcal.visibility = info?.caldav?.let {
+            val collections = it.collections.filter { it.type == CollectionInfo.Type.WEBCAL }
+
+            val adapter = CalendarAdapter(this)
+            adapter.addAll(collections)
+            webcals.adapter = adapter
+            webcals.onItemClickListener = webcalOnItemClickListener
+
+            if (collections.isNotEmpty())
+                View.VISIBLE
+            else
+                View.GONE
+        } ?: View.GONE
+
+        // ask for permissions
+        val requiredPermissions = mutableSetOf<String>()
+        if (info?.carddav != null) {
+            // if there is a CardDAV service, ask for contacts permissions
+            requiredPermissions += Manifest.permission.READ_CONTACTS
+            requiredPermissions += Manifest.permission.WRITE_CONTACTS
+        }
+
+        if (info?.caldav != null) {
+            // if there is a CalDAV service, ask for calendar and tasks permissions
+            requiredPermissions += Manifest.permission.READ_CALENDAR
+            requiredPermissions += Manifest.permission.WRITE_CALENDAR
+
+            if (LocalTaskList.tasksProviderAvailable(this)) {
+                requiredPermissions += TaskProvider.PERMISSION_READ_TASKS
+                requiredPermissions += TaskProvider.PERMISSION_WRITE_TASKS
+            }
+        }
+
+        val askPermissions = requiredPermissions.filter { ActivityCompat.checkSelfPermission(this, it) != PackageManager.PERMISSION_GRANTED }
+        if (askPermissions.isNotEmpty())
+            ActivityCompat.requestPermissions(this, askPermissions.toTypedArray(), 0)
+    }
+
+    override fun onLoaderReset(loader: Loader<AccountInfo>) {
+        address_books?.adapter = null
+        calendars?.adapter = null
+    }
+
+
+    class AccountLoader(
+            context: Context,
+            val account: Account
+    ): AsyncTaskLoader<AccountInfo>(context), DavService.RefreshingStatusListener, SyncStatusObserver {
+
+        private var syncStatusListener: Any? = null
+
+        private var davServiceConn: ServiceConnection? = null
+        private var davService: DavService.InfoBinder? = null
+
+        override fun onStartLoading() {
+            // get notified when sync status changes
+            if (syncStatusListener == null)
+                syncStatusListener = ContentResolver.addStatusChangeListener(ContentResolver.SYNC_OBSERVER_TYPE_ACTIVE, this)
+
+            // bind to DavService to get notified when it's running
+            if (davServiceConn == null) {
+                val serviceConn = object: ServiceConnection {
+                    override fun onServiceConnected(name: ComponentName, service: IBinder) {
+                        // get notified when DavService is running
+                        davService = service as DavService.InfoBinder
+                        service.addRefreshingStatusListener(this@AccountLoader, false)
+
+                        onContentChanged()
+                    }
+
+                    override fun onServiceDisconnected(name: ComponentName) {
+                        davService = null
+                    }
+                }
+                if (context.bindService(Intent(context, DavService::class.java), serviceConn, Context.BIND_AUTO_CREATE))
+                    davServiceConn = serviceConn
+            } else
+                forceLoad()
+        }
+
+        override fun onReset() {
+            syncStatusListener?.let {
+                ContentResolver.removeStatusChangeListener(it)
+                syncStatusListener = null
+            }
+
+            davService?.removeRefreshingStatusListener(this)
+            davServiceConn?.let {
+                context.unbindService(it)
+                davServiceConn = null
+            }
+        }
+
+        override fun onDavRefreshStatusChanged(id: Long, refreshing: Boolean) =
+                onContentChanged()
+
+        override fun onStatusChanged(which: Int) =
+                onContentChanged()
+
+        override fun loadInBackground(): AccountInfo {
+            val info = AccountInfo()
+
+            OpenHelper(context).use { dbHelper ->
+                val db = dbHelper.readableDatabase
+                db.query(
+                        Services._TABLE,
+                        arrayOf(Services.ID, Services.SERVICE),
+                        "${Services.ACCOUNT_NAME}=?", arrayOf(account.name),
+                        null, null, null).use { cursor ->
+                    while (cursor.moveToNext()) {
+                        val id = cursor.getLong(0)
+                        when (cursor.getString(1)) {
+                            Services.SERVICE_CARDDAV -> {
+                                val carddav = AccountInfo.ServiceInfo()
+                                info.carddav = carddav
+                                carddav.id = id
+                                carddav.refreshing =
+                                        davService?.isRefreshing(id) ?: false ||
+                                        ContentResolver.isSyncActive(account, context.getString(R.string.address_books_authority))
+
+                                val accountManager = AccountManager.get(context)
+                                for (addrBookAccount in accountManager.getAccountsByType(context.getString(R.string.account_type_address_book))) {
+                                    val addressBook = LocalAddressBook(context, addrBookAccount, null)
+                                    try {
+                                        if (account == addressBook.mainAccount)
+                                            carddav.refreshing = carddav.refreshing || ContentResolver.isSyncActive(addrBookAccount, ContactsContract.AUTHORITY)
+                                    } catch(e: Exception) {
+                                    }
+                                }
+
+                                carddav.hasHomeSets = hasHomeSets(db, id)
+                                carddav.collections = readCollections(db, id)
+                            }
+                            Services.SERVICE_CALDAV -> {
+                                val caldav = AccountInfo.ServiceInfo()
+                                info.caldav = caldav
+                                caldav.id = id
+                                caldav.refreshing =
+                                        davService?.isRefreshing(id) ?: false ||
+                                        ContentResolver.isSyncActive(account, CalendarContract.AUTHORITY) ||
+                                        ContentResolver.isSyncActive(account, TaskProvider.ProviderName.OpenTasks.authority)
+                                caldav.hasHomeSets = hasHomeSets(db, id)
+                                caldav.collections = readCollections(db, id)
+                            }
+                        }
+                    }
+                }
+            }
+
+            return info
+        }
+
+        private fun hasHomeSets(db: SQLiteDatabase, service: Long): Boolean {
+            db.query(ServiceDB.HomeSets._TABLE, null, "${ServiceDB.HomeSets.SERVICE_ID}=?",
+                    arrayOf(service.toString()), null, null, null)?.use { cursor ->
+                return cursor.count > 0
+            }
+            return false
+        }
+
+        @SuppressLint("Recycle")
+        private fun readCollections(db: SQLiteDatabase, service: Long): List<CollectionInfo>  {
+            val collections = LinkedList<CollectionInfo>()
+            db.query(Collections._TABLE, null, Collections.SERVICE_ID + "=?", arrayOf(service.toString()),
+                    null, null, "${Collections.SUPPORTS_VEVENT} DESC,${Collections.DISPLAY_NAME}").use { cursor ->
+                while (cursor.moveToNext()) {
+                    val values = ContentValues(cursor.columnCount)
+                    DatabaseUtils.cursorRowToContentValues(cursor, values)
+                    collections.add(CollectionInfo(values))
+                }
+            }
+
+            // Webcal: check whether calendar is already subscribed by ICSdroid
+            // (or any other app that stores the URL in Calendars.NAME)
+            val webcalCollections = collections.filter { it.type == CollectionInfo.Type.WEBCAL }
+            if (webcalCollections.isNotEmpty() && ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CALENDAR) == PackageManager.PERMISSION_GRANTED)
+                context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { provider ->
+                    try {
+                        for (info in webcalCollections) {
+                            provider.query(CalendarContract.Calendars.CONTENT_URI, null,
+                                    "${CalendarContract.Calendars.NAME}=?", arrayOf(info.source), null)?.use { cursor ->
+                                if (cursor.moveToNext())
+                                    info.selected = true
+                            }
+                        }
+                    } finally {
+                        @Suppress("DEPRECATION")
+                        if (Build.VERSION.SDK_INT >= 24)
+                            provider.close()
+                        else
+                            provider.release()
+                    }
+                }
+
+            return collections
+        }
+
+    }
+
+
+    /* LIST ADAPTERS */
+
+    class AddressBookAdapter(
+            context: Context
+    ): ArrayAdapter<CollectionInfo>(context, R.layout.account_carddav_item) {
+        override fun getView(position: Int, _v: View?, parent: ViewGroup?): View {
+            val v = _v ?: LayoutInflater.from(context).inflate(R.layout.account_carddav_item, parent, false)
+            val info = getItem(position)!!
+
+            val checked: CheckBox = v.findViewById(R.id.checked)
+            checked.isChecked = info.selected
+
+            var tv: TextView = v.findViewById(R.id.title)
+            tv.text = if (!info.displayName.isNullOrBlank()) info.displayName else info.url.toString()
+
+            tv = v.findViewById(R.id.description)
+            if (info.description.isNullOrBlank())
+                tv.visibility = View.GONE
+            else {
+                tv.visibility = View.VISIBLE
+                tv.text = info.description
+            }
+
+            v.findViewById<ImageView>(R.id.read_only).visibility =
+                    if (!info.privWriteContent || info.forceReadOnly) View.VISIBLE else View.GONE
+
+            v.findViewById<ImageView>(R.id.action_overflow).setOnClickListener { view ->
+                @Suppress("ReplaceSingleLineLet")
+                (context as? AccountActivity)?.let {
+                    it.onActionOverflowListener(view, info)
+                }
+            }
+
+            return v
+        }
+    }
+
+    class CalendarAdapter(
+            context: Context
+    ): ArrayAdapter<CollectionInfo>(context, R.layout.account_caldav_item) {
+        override fun getView(position: Int, _v: View?, parent: ViewGroup?): View {
+            val v = _v ?: LayoutInflater.from(context).inflate(R.layout.account_caldav_item, parent, false)
+            val info = getItem(position)!!
+
+            val enabled = info.selected || info.supportsVEVENT || info.supportsVTODO
+            v.isEnabled = enabled
+            v.checked.isEnabled = enabled
+
+            val checked: CheckBox = v.findViewById(R.id.checked)
+            checked.isChecked = info.selected
+
+            val vColor: View = v.findViewById(R.id.color)
+            vColor.visibility = info.color?.let {
+                vColor.setBackgroundColor(it)
+                View.VISIBLE
+            } ?: View.INVISIBLE
+
+            var tv: TextView = v.findViewById(R.id.title)
+            tv.text = if (!info.displayName.isNullOrBlank()) info.displayName else info.url.toString()
+
+            tv = v.findViewById(R.id.description)
+            if (info.description.isNullOrBlank())
+                tv.visibility = View.GONE
+            else {
+                tv.visibility = View.VISIBLE
+                tv.text = info.description
+            }
+
+            v.findViewById<ImageView>(R.id.read_only).visibility =
+                    if (!info.privWriteContent || info.forceReadOnly) View.VISIBLE else View.GONE
+
+            v.findViewById<ImageView>(R.id.events).visibility =
+                    if (info.supportsVEVENT) View.VISIBLE else View.GONE
+
+            v.findViewById<ImageView>(R.id.tasks).visibility =
+                    if (info.supportsVTODO) View.VISIBLE else View.GONE
+
+            val overflow = v.findViewById<ImageView>(R.id.action_overflow)
+            if (info.type == CollectionInfo.Type.WEBCAL)
+                overflow.visibility = View.GONE
+            else
+                overflow.setOnClickListener { view ->
+                    (context as? AccountActivity)?.let {
+                        it.onActionOverflowListener(view, info)
+                    }
+                }
+
+            return v
+        }
+    }
+
+
+    /* DIALOG FRAGMENTS */
+
+    class RenameAccountFragment: DialogFragment() {
+
+        companion object {
+
+            const val ARG_ACCOUNT = "account"
+
+            fun newInstance(account: Account): RenameAccountFragment {
+                val fragment = RenameAccountFragment()
+                val args = Bundle(1)
+                args.putParcelable(ARG_ACCOUNT, account)
+                fragment.arguments = args
+                return fragment
+            }
+
+        }
+
+        @SuppressLint("Recycle")
+        override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+            val oldAccount: Account = arguments!!.getParcelable(ARG_ACCOUNT)!!
+
+            val editText = EditText(activity)
+            editText.setText(oldAccount.name)
+
+            return AlertDialog.Builder(activity!!)
+                    .setTitle(R.string.account_rename)
+                    .setMessage(R.string.account_rename_new_name)
+                    .setView(editText)
+                    .setPositiveButton(R.string.account_rename_rename, DialogInterface.OnClickListener { _, _ ->
+                        val newName = editText.text.toString()
+
+                        if (newName == oldAccount.name)
+                            return@OnClickListener
+
+                        // remember sync intervals
+                        val oldSettings = AccountSettings(requireActivity(), oldAccount)
+                        val authorities = arrayOf(
+                                getString(R.string.address_books_authority),
+                                CalendarContract.AUTHORITY,
+                                TaskProvider.ProviderName.OpenTasks.authority
+                        )
+                        val syncIntervals = authorities.map { Pair(it, oldSettings.getSyncInterval(it)) }
+
+                        val accountManager = AccountManager.get(activity)
+                        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP)
+                            accountManager.renameAccount(oldAccount, newName, {
+                                // account has now been renamed
+                                Logger.log.info("Updating account name references")
+
+                                // cancel maybe running synchronization
+                                ContentResolver.cancelSync(oldAccount, null)
+                                for (addrBookAccount in accountManager.getAccountsByType(getString(R.string.account_type_address_book)))
+                                    ContentResolver.cancelSync(addrBookAccount, null)
+
+                                // update account name references in database
+                                OpenHelper(requireActivity()).use { dbHelper ->
+                                    ServiceDB.onRenameAccount(dbHelper.writableDatabase, oldAccount.name, newName)
+                                }
+
+                                // update main account of address book accounts
+                                if (ContextCompat.checkSelfPermission(requireActivity(), Manifest.permission.WRITE_CONTACTS) == PackageManager.PERMISSION_GRANTED)
+                                    try {
+                                        requireActivity().contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.let { provider ->
+                                            for (addrBookAccount in accountManager.getAccountsByType(getString(R.string.account_type_address_book)))
+                                                try {
+                                                    val addressBook = LocalAddressBook(requireActivity(), addrBookAccount, provider)
+                                                    if (oldAccount == addressBook.mainAccount)
+                                                        addressBook.mainAccount = Account(newName, oldAccount.type)
+                                                } finally {
+                                                    @Suppress("DEPRECATION")
+                                                    if (Build.VERSION.SDK_INT >= 24)
+                                                        provider.close()
+                                                    else
+                                                        provider.release()
+                                                }
+                                        }
+                                    } catch(e: Exception) {
+                                        Logger.log.log(Level.SEVERE, "Couldn't update address book accounts", e)
+                                    }
+
+                                // calendar provider doesn't allow changing account_name of Events
+                                // (all events will have to be downloaded again)
+
+                                // update account_name of local tasks
+                                try {
+                                    LocalTaskList.onRenameAccount(activity!!.contentResolver, oldAccount.name, newName)
+                                } catch(e: Exception) {
+                                    Logger.log.log(Level.SEVERE, "Couldn't propagate new account name to tasks provider", e)
+                                }
+
+                                // retain sync intervals
+                                val newAccount = Account(newName, oldAccount.type)
+                                val newSettings = AccountSettings(requireActivity(), newAccount)
+                                for ((authority, interval) in syncIntervals) {
+                                    if (interval == null)
+                                        ContentResolver.setIsSyncable(newAccount, authority, 0)
+                                    else {
+                                        ContentResolver.setIsSyncable(newAccount, authority, 1)
+                                        newSettings.setSyncInterval(authority, interval)
+                                    }
+                                }
+
+                                // synchronize again
+                                requestSync(activity!!, newAccount)
+                            }, null)
+                        activity!!.finish()
+                    })
+                    .setNegativeButton(android.R.string.cancel) { _, _ -> }
+                    .create()
+        }
+    }
+
+
+    /* USER ACTIONS */
+
+    private fun deleteAccount() {
+        val accountManager = AccountManager.get(this)
+
+        if (Build.VERSION.SDK_INT >= 22)
+            accountManager.removeAccount(account, this, { future ->
+                try {
+                    if (future.result.getBoolean(AccountManager.KEY_BOOLEAN_RESULT))
+                        Handler(Looper.getMainLooper()).post {
+                            finish()
+                        }
+                } catch(e: Exception) {
+                    Logger.log.log(Level.SEVERE, "Couldn't remove account", e)
+                }
+            }, null)
+        else
+            accountManager.removeAccount(account, { future ->
+                try {
+                    if (future.result)
+                        Handler(Looper.getMainLooper()).post {
+                            finish()
+                        }
+                } catch (e: Exception) {
+                    Logger.log.log(Level.SEVERE, "Couldn't remove account", e)
+                }
+            }, null)
+    }
+
+    private fun requestSync() {
+        requestSync(this, account)
+        Snackbar.make(findViewById(R.id.parent), R.string.account_synchronizing_now, Snackbar.LENGTH_LONG).show()
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/AccountListFragment.kt

@@ -0,0 +1,114 @@
+/*
+ * 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.accounts.Account
+import android.accounts.AccountManager
+import android.accounts.OnAccountsUpdateListener
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.widget.AbsListView
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import androidx.fragment.app.ListFragment
+import androidx.loader.app.LoaderManager
+import androidx.loader.content.AsyncTaskLoader
+import androidx.loader.content.Loader
+import at.bitfire.davdroid.R
+import kotlinx.android.synthetic.main.account_list_item.view.*
+
+class AccountListFragment: ListFragment(), LoaderManager.LoaderCallbacks<Array<Account>> {
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        listAdapter = AccountListAdapter(requireActivity())
+
+        return inflater.inflate(R.layout.account_list, container, false)
+    }
+
+    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
+        super.onViewCreated(view, savedInstanceState)
+        LoaderManager.getInstance(this).initLoader(0, arguments, this)
+
+        listView.choiceMode = AbsListView.CHOICE_MODE_SINGLE
+        listView.onItemClickListener = AdapterView.OnItemClickListener { _, _, position, _ ->
+            val account = listAdapter.getItem(position) as Account
+            val intent = Intent(activity, AccountActivity::class.java)
+            intent.putExtra(AccountActivity.EXTRA_ACCOUNT, account)
+            startActivity(intent)
+        }
+    }
+
+
+    // loader
+
+    override fun onCreateLoader(id: Int, args: Bundle?) =
+            AccountLoader(requireActivity())
+
+    override fun onLoadFinished(loader: Loader<Array<Account>>, accounts: Array<Account>) {
+        val adapter = listAdapter as AccountListAdapter
+        adapter.clear()
+        adapter.addAll(*accounts)
+    }
+
+    override fun onLoaderReset(loader: Loader<Array<Account>>) {
+        (listAdapter as AccountListAdapter).clear()
+    }
+
+    class AccountLoader(
+            context: Context
+    ): AsyncTaskLoader<Array<Account>>(context) {
+
+        private val accountManager = AccountManager.get(context)!!
+        private var listener: OnAccountsUpdateListener? = null
+
+        override fun onStartLoading() {
+            if (listener == null) {
+                listener = OnAccountsUpdateListener { onContentChanged() }
+                accountManager.addOnAccountsUpdatedListener(listener, null, false)
+            }
+
+            forceLoad()
+        }
+
+        override fun onReset() {
+            listener?.let {
+                try {
+                    accountManager.removeOnAccountsUpdatedListener(it)
+                } catch(ignored: IllegalArgumentException) {}
+                listener = null
+            }
+        }
+
+        override fun loadInBackground(): Array<Account> =
+            AccountManager.get(context).getAccountsByType(context.getString(R.string.account_type))
+
+    }
+
+
+    // list adapter
+
+    class AccountListAdapter(
+            context: Context
+    ): ArrayAdapter<Account>(context, R.layout.account_list_item) {
+
+        override fun getView(position: Int, _v: View?, parent: ViewGroup?): View {
+            val account = getItem(position)!!
+
+            val v = _v ?: LayoutInflater.from(context).inflate(R.layout.account_list_item, parent, false)
+            v.account_name.text = account.name
+
+            return v
+        }
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/AccountSettingsActivity.kt

@@ -0,0 +1,407 @@
+/*
+ * 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.Manifest
+import android.accounts.Account
+import android.content.ContentResolver
+import android.content.Intent
+import android.content.SyncStatusObserver
+import android.content.pm.PackageManager
+import android.os.Build
+import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
+import android.provider.CalendarContract
+import android.security.KeyChain
+import android.view.MenuItem
+import androidx.appcompat.app.AlertDialog
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.NavUtils
+import androidx.core.content.ContextCompat
+import androidx.fragment.app.DialogFragment
+import androidx.preference.*
+import at.bitfire.davdroid.App
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.model.Credentials
+import at.bitfire.davdroid.resource.LocalCalendar
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.ical4android.AndroidCalendar
+import at.bitfire.ical4android.TaskProvider
+import at.bitfire.vcard4android.GroupMethod
+import org.apache.commons.lang3.StringUtils
+
+class AccountSettingsActivity: AppCompatActivity() {
+
+    companion object {
+        const val EXTRA_ACCOUNT = "account"
+    }
+
+    private lateinit var account: Account
+
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        account = intent.getParcelableExtra(EXTRA_ACCOUNT)
+        title = getString(R.string.settings_title, account.name)
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        if (savedInstanceState == null)
+            supportFragmentManager.beginTransaction()
+                    .replace(android.R.id.content, DialogFragment.instantiate(this, AccountSettingsFragment::class.java.name, intent.extras))
+                    .commit()
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) =
+            if (item.itemId == android.R.id.home) {
+                val intent = Intent(this, AccountActivity::class.java)
+                intent.putExtra(AccountActivity.EXTRA_ACCOUNT, account)
+                NavUtils.navigateUpTo(this, intent)
+                true
+            } else
+                false
+
+
+    class AccountSettingsFragment: PreferenceFragmentCompat(), SyncStatusObserver, Settings.OnChangeListener {
+        private lateinit var settings: Settings
+
+        lateinit var account: Account
+        private var statusChangeListener: Any? = null
+
+        override fun onCreate(savedInstanceState: Bundle?) {
+            super.onCreate(savedInstanceState)
+            settings = Settings.getInstance(requireActivity())
+            account = arguments!!.getParcelable(EXTRA_ACCOUNT)!!
+        }
+
+        override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
+            addPreferencesFromResource(R.xml.settings_account)
+        }
+
+        override fun onResume() {
+            super.onResume()
+
+            statusChangeListener = ContentResolver.addStatusChangeListener(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, this)
+            settings.addOnChangeListener(this)
+
+            reload()
+        }
+
+        override fun onPause() {
+            super.onPause()
+            statusChangeListener?.let {
+                ContentResolver.removeStatusChangeListener(it)
+                statusChangeListener = null
+            }
+            settings.removeOnChangeListener(this)
+        }
+
+        override fun onStatusChanged(which: Int) {
+            Handler(Looper.getMainLooper()).post {
+                reload()
+            }
+        }
+
+        override fun onSettingsChanged()  = reload()
+
+        fun reload() {
+            val accountSettings = AccountSettings(requireActivity(), account)
+
+            // preference group: authentication
+            val prefUserName = findPreference("username") as EditTextPreference
+            val prefPassword = findPreference("password") as EditTextPreference
+            val prefCertAlias = findPreference("certificate_alias") as Preference
+
+            val credentials = accountSettings.credentials()
+            when (credentials.type) {
+                Credentials.Type.UsernamePassword -> {
+                    prefUserName.isVisible = true
+                    prefUserName.summary = credentials.userName
+                    prefUserName.text = credentials.userName
+                    prefUserName.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                        accountSettings.credentials(Credentials(newValue as String, credentials.password))
+                        reload()
+                        false
+                    }
+
+                    prefPassword.isVisible = true
+                    prefPassword.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                        accountSettings.credentials(Credentials(credentials.userName, newValue as String))
+                        reload()
+                        false
+                    }
+
+                    prefCertAlias.isVisible = false
+                }
+                Credentials.Type.ClientCertificate -> {
+                    prefUserName.isVisible = false
+                    prefPassword.isVisible = false
+
+                    prefCertAlias.isVisible = true
+                    prefCertAlias.summary = credentials.certificateAlias
+                    prefCertAlias.setOnPreferenceClickListener {
+                        KeyChain.choosePrivateKeyAlias(requireActivity(), { alias ->
+                            accountSettings.credentials(Credentials(certificateAlias = alias))
+                            Handler(Looper.getMainLooper()).post {
+                                reload()
+                            }
+                        }, null, null, null, -1, credentials.certificateAlias)
+                        true
+                    }
+                }
+            }
+
+            // preference group: sync
+            // those are null if the respective sync type is not available for this account:
+            val syncIntervalContacts = accountSettings.getSyncInterval(getString(R.string.address_books_authority))
+            val syncIntervalCalendars = accountSettings.getSyncInterval(CalendarContract.AUTHORITY)
+            val syncIntervalTasks = accountSettings.getSyncInterval(TaskProvider.ProviderName.OpenTasks.authority)
+
+            (findPreference("sync_interval_contacts") as ListPreference).let {
+                if (syncIntervalContacts != null) {
+                    it.isEnabled = true
+                    it.isVisible = true
+                    it.value = syncIntervalContacts.toString()
+                    if (syncIntervalContacts == AccountSettings.SYNC_INTERVAL_MANUALLY)
+                        it.setSummary(R.string.settings_sync_summary_manually)
+                    else
+                        it.summary = getString(R.string.settings_sync_summary_periodically, syncIntervalContacts / 60)
+                    it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { pref, newValue ->
+                        Handler(Looper.myLooper()).post {
+                            pref.isEnabled = false
+                            accountSettings.setSyncInterval(getString(R.string.address_books_authority), (newValue as String).toLong())
+                            reload()
+                        }
+                        false
+                    }
+                } else
+                    it.isVisible = false
+            }
+
+            (findPreference("sync_interval_calendars") as ListPreference).let {
+                if (syncIntervalCalendars != null) {
+                    it.isEnabled = true
+                    it.isVisible = true
+                    it.value = syncIntervalCalendars.toString()
+                    if (syncIntervalCalendars == AccountSettings.SYNC_INTERVAL_MANUALLY)
+                        it.setSummary(R.string.settings_sync_summary_manually)
+                    else
+                        it.summary = getString(R.string.settings_sync_summary_periodically, syncIntervalCalendars / 60)
+                    it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { pref, newValue ->
+                        Handler(Looper.myLooper()).post {
+                            pref.isEnabled = false
+                            accountSettings.setSyncInterval(CalendarContract.AUTHORITY, (newValue as String).toLong())
+                            reload()
+                        }
+                        false
+                    }
+                } else
+                    it.isVisible = false
+            }
+
+            (findPreference("sync_interval_tasks") as ListPreference).let {
+                if (syncIntervalTasks != null) {
+                    it.isEnabled = true
+                    it.isVisible = true
+                    it.value = syncIntervalTasks.toString()
+                    if (syncIntervalTasks == AccountSettings.SYNC_INTERVAL_MANUALLY)
+                        it.setSummary(R.string.settings_sync_summary_manually)
+                    else
+                        it.summary = getString(R.string.settings_sync_summary_periodically, syncIntervalTasks / 60)
+                    it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { pref, newValue ->
+                        Handler(Looper.myLooper()).post {
+                            pref.isEnabled = false
+                            accountSettings.setSyncInterval(TaskProvider.ProviderName.OpenTasks.authority, (newValue as String).toLong())
+                            reload()
+                        }
+                        false
+                    }
+                } else
+                    it.isVisible = false
+            }
+
+            val prefWifiOnly = findPreference("sync_wifi_only") as SwitchPreferenceCompat
+            prefWifiOnly.isEnabled = !settings.has(AccountSettings.KEY_WIFI_ONLY)
+            prefWifiOnly.isChecked = accountSettings.getSyncWifiOnly()
+            prefWifiOnly.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, wifiOnly ->
+                accountSettings.setSyncWiFiOnly(wifiOnly as Boolean)
+                reload()
+                false
+            }
+
+            val prefWifiOnlySSIDs = findPreference("sync_wifi_only_ssids") as EditTextPreference
+            val onlySSIDs = accountSettings.getSyncWifiOnlySSIDs()?.joinToString(", ")
+            prefWifiOnlySSIDs.text = onlySSIDs
+            if (onlySSIDs != null)
+                prefWifiOnlySSIDs.summary = getString(if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1)
+                    R.string.settings_sync_wifi_only_ssids_on_location_services else R.string.settings_sync_wifi_only_ssids_on, onlySSIDs)
+            else
+                prefWifiOnlySSIDs.setSummary(R.string.settings_sync_wifi_only_ssids_off)
+            prefWifiOnlySSIDs.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                accountSettings.setSyncWifiOnlySSIDs((newValue as String).split(',').mapNotNull { StringUtils.trimToNull(it) }.distinct())
+                reload()
+                false
+            }
+
+            // getting the WiFi name requires location permission (and active location services) since Android 8.1
+            // see https://issuetracker.google.com/issues/70633700
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1 &&
+                accountSettings.getSyncWifiOnly() && onlySSIDs != null &&
+                ContextCompat.checkSelfPermission(requireActivity(), Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED)
+                    requestPermissions(arrayOf(Manifest.permission.ACCESS_COARSE_LOCATION), 0)
+
+            // preference group: CardDAV
+            (findPreference("contact_group_method") as ListPreference).let {
+                if (syncIntervalContacts != null) {
+                    it.isVisible = true
+                    it.value = accountSettings.getGroupMethod().name
+                    it.summary = it.entry
+                    if (settings.has(AccountSettings.KEY_CONTACT_GROUP_METHOD))
+                        it.isEnabled = false
+                    else {
+                        it.isEnabled = true
+                        it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, groupMethod ->
+                            AlertDialog.Builder(requireActivity())
+                                    .setIcon(R.drawable.ic_error_dark)
+                                    .setTitle(R.string.settings_contact_group_method_change)
+                                    .setMessage(R.string.settings_contact_group_method_change_reload_contacts)
+                                    .setPositiveButton(android.R.string.ok) { _, _ ->
+                                        // change group method
+                                        accountSettings.setGroupMethod(GroupMethod.valueOf(groupMethod as String))
+                                        reload()
+
+                                        // reload all contacts
+                                        val args = Bundle(1)
+                                        args.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, true)
+                                        ContentResolver.requestSync(account, getString(R.string.address_books_authority), args)
+                                    }
+                                    .setNegativeButton(android.R.string.cancel, null)
+                                    .show()
+                            false
+                        }
+                    }
+                } else
+                    it.isVisible = false
+            }
+
+            // preference group: CalDAV
+            (findPreference("time_range_past_days") as EditTextPreference).let {
+                if (syncIntervalCalendars != null) {
+                    it.isVisible = true
+                    val pastDays = accountSettings.getTimeRangePastDays()
+                    if (pastDays != null) {
+                        it.text = pastDays.toString()
+                        it.summary = resources.getQuantityString(R.plurals.settings_sync_time_range_past_days, pastDays, pastDays)
+                    } else {
+                        it.text = null
+                        it.setSummary(R.string.settings_sync_time_range_past_none)
+                    }
+                    it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                        val days = try {
+                            (newValue as String).toInt()
+                        } catch(e: NumberFormatException) {
+                            -1
+                        }
+                        accountSettings.setTimeRangePastDays(if (days < 0) null else days)
+
+                        // reset sync state of all calendars in this account to trigger a full sync
+                        if (ContextCompat.checkSelfPermission(requireContext(), Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED) {
+                            requireContext().contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { provider ->
+                                try {
+                                    AndroidCalendar.find(account, provider, LocalCalendar.Factory, null, null).forEach { calendar ->
+                                        calendar.lastSyncState = null
+                                    }
+                                } finally {
+                                    @Suppress("DEPRECATION")
+                                    if (Build.VERSION.SDK_INT >= 24)
+                                        provider.close()
+                                    else
+                                        provider.release()
+                                }
+                            }
+                        }
+
+                        reload()
+                        false
+                    }
+                } else
+                    it.isVisible = false
+            }
+
+            (findPreference("manage_calendar_colors") as SwitchPreferenceCompat).let {
+                if (syncIntervalCalendars != null || syncIntervalTasks != null) {
+                    it.isVisible = true
+                    it.isEnabled = !settings.has(AccountSettings.KEY_MANAGE_CALENDAR_COLORS)
+                    it.isChecked = accountSettings.getManageCalendarColors()
+                    it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                        accountSettings.setManageCalendarColors(newValue as Boolean)
+                        reload()
+                        false
+                    }
+                } else
+                    it.isVisible = false
+            }
+
+            (findPreference("event_colors") as SwitchPreferenceCompat).let {
+                if (syncIntervalCalendars != null) {
+                    it.isVisible = true
+                    it.isEnabled = !settings.has(AccountSettings.KEY_EVENT_COLORS)
+                    it.isChecked = accountSettings.getEventColors()
+                    it.onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                        if (newValue as Boolean) {
+                            accountSettings.setEventColors(true)
+                            reload()
+                        } else
+                            AlertDialog.Builder(requireActivity())
+                                    .setIcon(R.drawable.ic_error_dark)
+                                    .setTitle(R.string.settings_event_colors)
+                                    .setMessage(R.string.settings_event_colors_off_confirm)
+                                    .setNegativeButton(android.R.string.cancel, null)
+                                    .setPositiveButton(android.R.string.ok) { _, _ ->
+                                        accountSettings.setEventColors(false)
+                                        reload()
+                                    }
+                                    .show()
+                        false
+                    }
+                } else
+                    it.isVisible = false
+            }
+        }
+
+        override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
+            super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+
+            if (permissions.first() == Manifest.permission.ACCESS_COARSE_LOCATION && grantResults.first() == PackageManager.PERMISSION_DENIED) {
+                // location permission denied, reset SSID restriction
+                AccountSettings(requireActivity(), account).setSyncWifiOnlySSIDs(null)
+                reload()
+
+                AlertDialog.Builder(requireActivity())
+                        .setIcon(R.drawable.ic_network_wifi_dark)
+                        .setTitle(R.string.settings_sync_wifi_only_ssids)
+                        .setMessage(R.string.settings_sync_wifi_only_ssids_location_permission)
+                        .setPositiveButton(android.R.string.ok) { _, _ -> }
+                        .setNeutralButton(R.string.settings_more_info_faq) { _, _ ->
+                            val faqUrl = App.homepageUrl(requireActivity()).buildUpon()
+                                    .appendPath("faq").appendPath("wifi-ssid-restriction-location-permission")
+                                    .build()
+                            val intent = Intent(Intent.ACTION_VIEW, faqUrl)
+                            startActivity(Intent.createChooser(intent, null))
+                        }
+                        .show()
+            }
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/AccountsActivity.kt

@@ -0,0 +1,118 @@
+/*
+ * 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.accounts.AccountManager
+import android.content.ContentResolver
+import android.content.Intent
+import android.content.SyncStatusObserver
+import android.os.Bundle
+import android.view.MenuItem
+import androidx.appcompat.app.ActionBarDrawerToggle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.view.GravityCompat
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.ui.setup.LoginActivity
+import com.google.android.material.navigation.NavigationView
+import com.google.android.material.snackbar.Snackbar
+import kotlinx.android.synthetic.main.accounts_content.*
+import kotlinx.android.synthetic.main.activity_accounts.*
+import kotlinx.android.synthetic.main.activity_accounts.view.*
+
+class AccountsActivity: AppCompatActivity(), NavigationView.OnNavigationItemSelectedListener, SyncStatusObserver {
+
+    companion object {
+        val accountsDrawerHandler = DefaultAccountsDrawerHandler()
+
+        const val fragTagStartup = "startup"
+    }
+
+    private lateinit var settings: Settings
+
+    private var syncStatusSnackbar: Snackbar? = null
+    private var syncStatusObserver: Any? = null
+
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        settings = Settings.getInstance(this)
+
+        setContentView(R.layout.activity_accounts)
+        setSupportActionBar(toolbar)
+
+        if (supportFragmentManager.findFragmentByTag(fragTagStartup) == null) {
+            val ft = supportFragmentManager.beginTransaction()
+            StartupDialogFragment.getStartupDialogs(this).forEach { ft.add(it, fragTagStartup) }
+            ft.commit()
+        }
+
+        fab.setOnClickListener {
+            startActivity(Intent(this, LoginActivity::class.java))
+        }
+        fab.show()
+
+        accountsDrawerHandler.initMenu(this, drawer_layout.nav_view.menu)
+        val toggle = ActionBarDrawerToggle(
+                this, drawer_layout, toolbar, R.string.navigation_drawer_open, R.string.navigation_drawer_close)
+        drawer_layout.addDrawerListener(toggle)
+        toggle.syncState()
+
+        nav_view.setNavigationItemSelectedListener(this)
+        nav_view.itemIconTintList = null
+    }
+
+    override fun onResume() {
+        super.onResume()
+
+        onStatusChanged(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS)
+        syncStatusObserver = ContentResolver.addStatusChangeListener(ContentResolver.SYNC_OBSERVER_TYPE_SETTINGS, this)
+    }
+
+    override fun onPause() {
+        super.onPause()
+
+        syncStatusObserver?.let {
+            ContentResolver.removeStatusChangeListener(it)
+            syncStatusObserver = null
+        }
+    }
+
+    override fun onStatusChanged(which: Int) {
+        syncStatusSnackbar?.let {
+            it.dismiss()
+            syncStatusSnackbar = null
+        }
+
+        if (!ContentResolver.getMasterSyncAutomatically()) {
+            val snackbar = Snackbar
+                    .make(findViewById(R.id.coordinator), R.string.accounts_global_sync_disabled, Snackbar.LENGTH_INDEFINITE)
+                    .setAction(R.string.accounts_global_sync_enable) {
+                        ContentResolver.setMasterSyncAutomatically(true)
+                    }
+            syncStatusSnackbar = snackbar
+            snackbar.show()
+        }
+    }
+
+
+    override fun onBackPressed() {
+        if (drawer_layout.isDrawerOpen(GravityCompat.START))
+            drawer_layout.closeDrawer(GravityCompat.START)
+        else
+            super.onBackPressed()
+    }
+
+    override fun onNavigationItemSelected(item: MenuItem): Boolean {
+        val processed = accountsDrawerHandler.onNavigationItemSelected(this, item)
+        drawer_layout.closeDrawer(GravityCompat.START)
+        return processed
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/AppSettingsActivity.kt

@@ -0,0 +1,162 @@
+/*
+ * 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.content.Intent
+import android.os.Build
+import android.os.Bundle
+import androidx.appcompat.app.AppCompatActivity
+import androidx.preference.EditTextPreference
+import androidx.preference.Preference
+import androidx.preference.PreferenceFragmentCompat
+import androidx.preference.SwitchPreferenceCompat
+import at.bitfire.cert4android.CustomCertManager
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.settings.Settings
+import com.google.android.material.snackbar.Snackbar
+import java.net.URI
+import java.net.URISyntaxException
+
+class AppSettingsActivity: AppCompatActivity() {
+
+    companion object {
+        const val EXTRA_SCROLL_TO = "scrollTo"
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        if (savedInstanceState == null) {
+            val fragment = SettingsFragment()
+            fragment.arguments = intent.extras
+            supportFragmentManager.beginTransaction()
+                    .replace(android.R.id.content, fragment)
+                    .commit()
+        }
+    }
+
+
+    class SettingsFragment: PreferenceFragmentCompat(), Settings.OnChangeListener {
+
+        override fun onCreatePreferences(bundle: Bundle?, s: String?) {
+            addPreferencesFromResource(R.xml.settings_app)
+            loadSettings()
+
+            // UI settings
+            findPreference("notification_settings").apply {
+                if (Build.VERSION.SDK_INT >= 26)
+                    onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                        startActivity(Intent(android.provider.Settings.ACTION_APP_NOTIFICATION_SETTINGS).apply {
+                            putExtra(android.provider.Settings.EXTRA_APP_PACKAGE, BuildConfig.APPLICATION_ID)
+                        })
+                        false
+                    }
+                else
+                    isVisible = false
+            }
+            findPreference("reset_hints").onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                resetHints()
+                false
+            }
+
+            // security settings
+            findPreference(Settings.DISTRUST_SYSTEM_CERTIFICATES).apply {
+                isVisible = BuildConfig.customCerts
+                isEnabled = true
+            }
+            findPreference("reset_certificates").apply {
+                isVisible = BuildConfig.customCerts
+                isEnabled = true
+                onPreferenceClickListener = Preference.OnPreferenceClickListener {
+                    resetCertificates()
+                    false
+                }
+            }
+
+            arguments?.getString(EXTRA_SCROLL_TO)?.let { key ->
+                scrollToPreference(key)
+            }
+        }
+
+        private fun loadSettings() {
+            val settings = Settings.getInstance(requireActivity())
+            
+            // connection settings
+            (findPreference(Settings.OVERRIDE_PROXY) as SwitchPreferenceCompat).apply {
+                isChecked = settings.getBoolean(Settings.OVERRIDE_PROXY) ?: Settings.OVERRIDE_PROXY_DEFAULT
+                isEnabled = settings.isWritable(Settings.OVERRIDE_PROXY)
+            }
+
+            (findPreference(Settings.OVERRIDE_PROXY_HOST) as EditTextPreference).apply {
+                isEnabled = settings.isWritable(Settings.OVERRIDE_PROXY_HOST)
+                val proxyHost = settings.getString(Settings.OVERRIDE_PROXY_HOST) ?: Settings.OVERRIDE_PROXY_HOST_DEFAULT
+                text = proxyHost
+                summary = proxyHost
+                onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                    val host = newValue as String
+                    try {
+                        URI(null, host, null, null)
+                        settings.putString(Settings.OVERRIDE_PROXY_HOST, host)
+                        summary = host
+                        true
+                    } catch(e: URISyntaxException) {
+                        Snackbar.make(view!!, e.localizedMessage, Snackbar.LENGTH_LONG).show()
+                        false
+                    }
+                }
+            }
+
+            (findPreference(Settings.OVERRIDE_PROXY_PORT) as EditTextPreference).apply {
+                isEnabled = settings.isWritable(Settings.OVERRIDE_PROXY_PORT)
+                val proxyPort = settings.getInt(Settings.OVERRIDE_PROXY_PORT) ?: Settings.OVERRIDE_PROXY_PORT_DEFAULT
+                text = proxyPort.toString()
+                summary = proxyPort.toString()
+                onPreferenceChangeListener = Preference.OnPreferenceChangeListener { _, newValue ->
+                    try {
+                        val port = Integer.parseInt(newValue as String)
+                        if (port in 1..65535) {
+                            settings.putInt(Settings.OVERRIDE_PROXY_PORT, port)
+                            text = port.toString()
+                            summary = port.toString()
+                            true
+                        } else
+                            false
+                    } catch(e: NumberFormatException) {
+                        false
+                    }
+                }
+            }
+
+            // security settings
+            (findPreference(Settings.DISTRUST_SYSTEM_CERTIFICATES) as SwitchPreferenceCompat)
+                    .isChecked = settings.getBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES) ?: Settings.DISTRUST_SYSTEM_CERTIFICATES_DEFAULT
+        }
+
+        override fun onSettingsChanged() {
+            loadSettings()
+        }
+
+
+        private fun resetHints() {
+            val settings = Settings.getInstance(requireActivity())
+            settings.remove(StartupDialogFragment.HINT_AUTOSTART_PERMISSIONS)
+            settings.remove(StartupDialogFragment.HINT_BATTERY_OPTIMIZATIONS)
+            settings.remove(StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED)
+            Snackbar.make(view!!, R.string.app_settings_reset_hints_success, Snackbar.LENGTH_LONG).show()
+        }
+
+        private fun resetCertificates() {
+            if (CustomCertManager.resetCertificates(activity!!))
+                Snackbar.make(view!!, getString(R.string.app_settings_reset_certificates_success), Snackbar.LENGTH_LONG).show()
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/CollectionInfoFragment.kt

@@ -0,0 +1,49 @@
+/*
+ * 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.annotation.SuppressLint
+import android.app.Dialog
+import android.os.Bundle
+import androidx.appcompat.app.AlertDialog
+import androidx.fragment.app.DialogFragment
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.model.CollectionInfo
+import kotlinx.android.synthetic.main.collection_properties.view.*
+
+class CollectionInfoFragment : DialogFragment() {
+
+    companion object {
+
+        private const val ARGS_INFO = "model"
+
+        fun newInstance(info: CollectionInfo): CollectionInfoFragment {
+            val frag = CollectionInfoFragment()
+            val args = Bundle(1)
+            args.putParcelable(ARGS_INFO, info)
+            frag.arguments = args
+            return frag
+        }
+
+    }
+
+    @SuppressLint("InflateParams")
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val info = arguments!![ARGS_INFO] as CollectionInfo
+
+        val view = requireActivity().layoutInflater.inflate(R.layout.collection_properties, null)
+        view.url.text = info.url.toString()
+
+        return AlertDialog.Builder(requireActivity())
+                .setTitle(info.displayName)
+                .setView(view)
+                .create()
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/CreateAddressBookActivity.kt

@@ -0,0 +1,132 @@
+/*
+ * 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.accounts.Account
+import android.content.Context
+import android.content.Intent
+import android.os.Bundle
+import android.view.Menu
+import android.view.MenuItem
+import android.widget.ArrayAdapter
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.NavUtils
+import androidx.loader.app.LoaderManager
+import androidx.loader.content.AsyncTaskLoader
+import androidx.loader.content.Loader
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import kotlinx.android.synthetic.main.activity_create_address_book.*
+import okhttp3.HttpUrl
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+
+class CreateAddressBookActivity: AppCompatActivity(), LoaderManager.LoaderCallbacks<CreateAddressBookActivity.AccountInfo> {
+
+    companion object {
+        const val EXTRA_ACCOUNT = "account"
+    }
+
+    private lateinit var account: Account
+
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        account = intent.getParcelableExtra(EXTRA_ACCOUNT)
+
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+        setContentView(R.layout.activity_create_address_book)
+
+        LoaderManager.getInstance(this).initLoader(0, intent.extras, this)
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.activity_create_collection, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) =
+            if (item.itemId == android.R.id.home) {
+                val intent = Intent(this, AccountActivity::class.java)
+                intent.putExtra(AccountActivity.EXTRA_ACCOUNT, account)
+                NavUtils.navigateUpTo(this, intent)
+                true
+            } else
+                false
+
+    fun onCreateCollection(item: MenuItem) {
+        val homeSet = home_sets.selectedItem as String
+
+        var ok = true
+        HttpUrl.parse(homeSet)?.let {
+            val info = CollectionInfo(it.resolve(UUID.randomUUID().toString() + "/")!!)
+            info.displayName = display_name.text.toString()
+            if (info.displayName.isNullOrBlank()) {
+                display_name.error = getString(R.string.create_collection_display_name_required)
+                ok = false
+            }
+
+            info.description = StringUtils.trimToNull(description.text.toString())
+
+            if (ok) {
+                info.type = CollectionInfo.Type.ADDRESS_BOOK
+                CreateCollectionFragment.newInstance(account, info).show(supportFragmentManager, null)
+            }
+        }
+    }
+
+
+    override fun onCreateLoader(id: Int, args: Bundle?) = AccountInfoLoader(this, account)
+
+    override fun onLoadFinished(loader: Loader<AccountInfo>, info: AccountInfo?) {
+        info?.let {
+            home_sets.adapter = ArrayAdapter<String>(this, android.R.layout.simple_spinner_dropdown_item, it.homeSets)
+        }
+    }
+
+    override fun onLoaderReset(loader: Loader<AccountInfo>) {
+    }
+
+    class AccountInfo {
+        val homeSets = LinkedList<String>()
+    }
+
+    class AccountInfoLoader(
+            context: Context,
+            val account: Account
+    ): AsyncTaskLoader<AccountInfo>(context) {
+
+        override fun onStartLoading() = forceLoad()
+
+        override fun loadInBackground(): AccountInfo? {
+            val info = AccountInfo()
+            ServiceDB.OpenHelper(context).use { dbHelper ->
+                // find DAV service and home sets
+                val db = dbHelper.readableDatabase
+                db.query(ServiceDB.Services._TABLE, arrayOf(ServiceDB.Services.ID),
+                        "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
+                        arrayOf(account.name, ServiceDB.Services.SERVICE_CARDDAV), null, null, null).use { cursor ->
+                    if (!cursor.moveToNext())
+                        return null
+                    val strServiceID = cursor.getString(0)
+
+                    db.query(ServiceDB.HomeSets._TABLE, arrayOf(ServiceDB.HomeSets.URL),
+                            "${ServiceDB.HomeSets.SERVICE_ID}=?", arrayOf(strServiceID), null, null, null).use { c ->
+                        while (c.moveToNext())
+                            info.homeSets += c.getString(0)
+                    }
+                }
+            }
+            return info
+        }
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/CreateCalendarActivity.kt

@@ -0,0 +1,288 @@
+/*
+ * 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.accounts.Account
+import android.app.Application
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.ColorDrawable
+import android.os.Bundle
+import android.text.TextUtils
+import android.view.Menu
+import android.view.MenuItem
+import android.view.View
+import android.view.ViewGroup
+import android.widget.ArrayAdapter
+import android.widget.Filter
+import android.widget.SpinnerAdapter
+import android.widget.TextView
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.NavUtils
+import androidx.databinding.DataBindingUtil
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.Observer
+import androidx.lifecycle.ViewModelProviders
+import at.bitfire.davdroid.Constants
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.databinding.ActivityCreateCalendarBinding
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.ical4android.DateUtils
+import com.jaredrummler.android.colorpicker.ColorPickerDialog
+import com.jaredrummler.android.colorpicker.ColorPickerDialogListener
+import kotlinx.android.synthetic.main.activity_create_calendar.*
+import net.fortuna.ical4j.model.Calendar
+import okhttp3.HttpUrl
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+import kotlin.concurrent.thread
+
+class CreateCalendarActivity: AppCompatActivity(), ColorPickerDialogListener {
+
+    companion object {
+        const val EXTRA_ACCOUNT = "account"
+    }
+
+    private lateinit var model: Model
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        supportActionBar?.setDisplayHomeAsUpEnabled(true)
+
+        model = ViewModelProviders.of(this).get(Model::class.java)
+        (intent?.extras?.getParcelable(EXTRA_ACCOUNT) as? Account)?.let {
+            model.initialize(it)
+        }
+        model.homeSets.observe(this, Observer {
+            if (it.isEmpty)
+                // no known homesets, we don't know where to create the calendar
+                finish()
+        })
+
+        val binding = DataBindingUtil.setContentView<ActivityCreateCalendarBinding>(this, R.layout.activity_create_calendar)
+        binding.lifecycleOwner = this
+        binding.model = model
+
+        binding.color.setOnClickListener { _ ->
+            ColorPickerDialog.newBuilder()
+                    .setShowAlphaSlider(false)
+                    .setColor((color.background as ColorDrawable).color)
+                    .show(this)
+        }
+
+        binding.timezone.setAdapter(model.timezones)
+    }
+
+    override fun onColorSelected(dialogId: Int, rgb: Int) {
+        model.color.value = rgb
+    }
+
+    override fun onDialogDismissed(dialogId: Int) {
+        // color selection dismissed
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.activity_create_collection, menu)
+        return true
+    }
+
+    override fun onOptionsItemSelected(item: MenuItem) =
+            if (item.itemId == android.R.id.home) {
+                val intent = Intent(this, AccountActivity::class.java)
+                intent.putExtra(AccountActivity.EXTRA_ACCOUNT, model.account)
+                NavUtils.navigateUpTo(this, intent)
+                true
+            } else
+                false
+
+    fun onCreateCollection(item: MenuItem) {
+        var ok = true
+
+        val parent = model.homeSets.value?.getItem(model.idxHomeSet.value!!) as String
+        HttpUrl.parse(parent)?.let { parentUrl ->
+            val info = CollectionInfo(parentUrl.resolve(UUID.randomUUID().toString() + "/")!!)
+
+            val displayName = model.displayName.value
+            if (displayName.isNullOrBlank()) {
+                model.displayNameError.value = getString(R.string.create_collection_display_name_required)
+                ok = false
+            } else {
+                info.displayName = displayName
+                model.displayNameError.value = null
+            }
+
+            info.description = StringUtils.trimToNull(model.description.value)
+            info.color = model.color.value
+
+            val tzId = model.timezone.value
+            if (tzId.isNullOrBlank()) {
+                model.timezoneError.value = getString(R.string.create_calendar_time_zone_required)
+                ok = false
+            } else {
+                DateUtils.tzRegistry.getTimeZone(tzId)?.let { tz ->
+                    val cal = Calendar()
+                    cal.components += tz.vTimeZone
+                    info.timeZone = cal.toString()
+                }
+                model.timezoneError.value = null
+            }
+
+            val supportsVEVENT = model.supportVEVENT.value ?: false
+            val supportsVTODO = model.supportVTODO.value ?: false
+            val supportsVJOURNAL = model.supportVJOURNAL.value ?: false
+            if (!supportsVEVENT && !supportsVTODO && !supportsVJOURNAL) {
+                ok = false
+                model.typeError.value = ""
+            } else
+                model.typeError.value = null
+
+            info.type = CollectionInfo.Type.CALENDAR
+            info.supportsVEVENT = supportsVEVENT
+            info.supportsVTODO = supportsVTODO
+            info.supportsVJOURNAL = supportsVJOURNAL
+
+            if (ok)
+                CreateCollectionFragment.newInstance(model.account!!, info).show(supportFragmentManager, null)
+        }
+    }
+
+    class HomesetAdapter(
+            context: Context
+    ): ArrayAdapter<String>(context, android.R.layout.simple_list_item_1, android.R.id.text1) {
+
+        init {
+            setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item)
+        }
+
+        override fun getView(position: Int, convertView: View?, parent: ViewGroup): View {
+            val data = getItem(position)!!
+            val v = super.getView(position, convertView, parent)
+            v.findViewById<TextView>(android.R.id.text1).apply {
+                setSingleLine()
+                ellipsize = TextUtils.TruncateAt.START
+            }
+            return v
+        }
+
+        override fun getDropDownView(position: Int, convertView: View?, parent: ViewGroup): View {
+            val data = getItem(position)!!
+            val v = super.getDropDownView(position, convertView, parent)
+            v.findViewById<TextView>(android.R.id.text1).apply {
+                ellipsize = TextUtils.TruncateAt.START
+            }
+            return v
+        }
+
+    }
+
+    class TimeZoneAdapter(
+            context: Context
+    ): ArrayAdapter<String>(context, android.R.layout.simple_list_item_1, android.R.id.text1) {
+
+        val tz = TimeZone.getAvailableIDs()
+
+        override fun getFilter(): Filter {
+            return object: Filter() {
+                override fun performFiltering(constraint: CharSequence?): FilterResults {
+                    val filtered = constraint?.let {
+                        tz.filter { it.contains(constraint, true) }
+                    } ?: listOf()
+                    val results = FilterResults()
+                    results.values = filtered
+                    results.count = filtered.size
+                    return results
+                }
+                override fun publishResults(constraint: CharSequence?, results: FilterResults) {
+                    clear()
+                    @Suppress("UNCHECKED_CAST") addAll(results.values as List<String>)
+                    if (results.count >= 0)
+                        notifyDataSetChanged()
+                    else
+                        notifyDataSetInvalidated()
+                }
+            }
+        }
+
+    }
+
+
+    class Model(
+            application: Application
+    ): AndroidViewModel(application) {
+
+        class TimeZoneInfo(
+                val id: String,
+                val displayName: String
+        ) {
+            override fun toString() = id
+        }
+
+        var account: Account? = null
+
+        val displayName = MutableLiveData<String>()
+        val displayNameError = MutableLiveData<String>()
+
+        val description = MutableLiveData<String>()
+        val color = MutableLiveData<Int>()
+
+        val homeSets = MutableLiveData<SpinnerAdapter>()
+        val idxHomeSet = MutableLiveData<Int>()
+
+        val timezones = TimeZoneAdapter(application)
+        val timezone = MutableLiveData<String>()
+        val timezoneError = MutableLiveData<String>()
+
+        val typeError = MutableLiveData<String>()
+        val supportVEVENT = MutableLiveData<Boolean>()
+        val supportVTODO = MutableLiveData<Boolean>()
+        val supportVJOURNAL = MutableLiveData<Boolean>()
+
+        fun initialize(account: Account) {
+            synchronized(this) {
+                if (this.account != null)
+                    return
+                this.account = account
+            }
+
+            color.value = Constants.DAVDROID_GREEN_RGBA
+
+            timezone.value = TimeZone.getDefault().id
+
+            supportVEVENT.value = true
+            supportVTODO.value = true
+            supportVJOURNAL.value = true
+
+            thread {
+                // load account info
+                ServiceDB.OpenHelper(getApplication()).use { dbHelper ->
+                    val adapter = HomesetAdapter(getApplication())
+                    val db = dbHelper.readableDatabase
+                    db.query(ServiceDB.Services._TABLE, arrayOf(ServiceDB.Services.ID),
+                            "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
+                            arrayOf(account.name, ServiceDB.Services.SERVICE_CALDAV), null, null, null).use { cursor ->
+                        if (cursor.moveToNext()) {
+                            val strServiceID = cursor.getString(0)
+                            db.query(ServiceDB.HomeSets._TABLE, arrayOf(ServiceDB.HomeSets.URL),
+                                    "${ServiceDB.HomeSets.SERVICE_ID}=?", arrayOf(strServiceID), null, null, null).use { c ->
+                                while (c.moveToNext())
+                                    adapter.add(c.getString(0))
+                            }
+                        }
+                    }
+                    homeSets.postValue(adapter)
+                    idxHomeSet.postValue(0)
+                }
+            }
+        }
+
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/CreateCollectionFragment.kt

@@ -0,0 +1,231 @@
+/*
+ * 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.accounts.Account
+import android.app.Dialog
+import android.app.ProgressDialog
+import android.content.Context
+import android.os.Bundle
+import androidx.fragment.app.DialogFragment
+import androidx.loader.app.LoaderManager
+import androidx.loader.content.AsyncTaskLoader
+import androidx.loader.content.Loader
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.XmlUtils
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.HttpClient
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.settings.AccountSettings
+import java.io.IOException
+import java.io.StringWriter
+import java.util.logging.Level
+
+class CreateCollectionFragment: DialogFragment(), LoaderManager.LoaderCallbacks<Exception> {
+
+    companion object {
+
+        const val ARG_ACCOUNT = "account"
+        const val ARG_COLLECTION_INFO = "collectionInfo"
+
+        fun newInstance(account: Account, info: CollectionInfo): CreateCollectionFragment {
+            val frag = CreateCollectionFragment()
+            val args = Bundle(2)
+            args.putParcelable(ARG_ACCOUNT, account)
+            args.putParcelable(ARG_COLLECTION_INFO, info)
+            frag.arguments = args
+            return frag
+        }
+
+    }
+
+    private lateinit var account: Account
+    private lateinit var info: CollectionInfo
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        val args = requireNotNull(arguments)
+        account = args.getParcelable(ARG_ACCOUNT)!!
+        info = args.getParcelable(ARG_COLLECTION_INFO)!!
+
+        LoaderManager.getInstance(this).initLoader(0, null, this)
+    }
+
+    @Suppress("DEPRECATION")
+    override fun onCreateDialog(savedInstanceState: Bundle?): Dialog {
+        val progress = ProgressDialog(context)
+        progress.setTitle(R.string.create_collection_creating)
+        progress.setMessage(getString(R.string.please_wait))
+        progress.isIndeterminate = true
+        progress.setCanceledOnTouchOutside(false)
+        isCancelable = false
+        return progress
+    }
+
+
+    override fun onCreateLoader(id: Int, args: Bundle?) = CreateCollectionLoader(requireActivity(), account, info)
+
+    override fun onLoadFinished(loader: Loader<Exception>, exception: Exception?) {
+        dismiss()
+
+        activity?.let { parent ->
+            if (exception != null)
+                requireFragmentManager().beginTransaction()
+                        .add(ExceptionInfoFragment.newInstance(exception, account), null)
+                        .commit()
+            else
+                parent.finish()
+        }
+
+    }
+
+    override fun onLoaderReset(loader: Loader<Exception>) {}
+
+
+    class CreateCollectionLoader(
+            context: Context,
+            val account: Account,
+            val info: CollectionInfo
+    ): AsyncTaskLoader<Exception>(context) {
+
+        override fun onStartLoading() = forceLoad()
+
+        override fun loadInBackground(): Exception? {
+            val writer = StringWriter()
+            try {
+                val serializer = XmlUtils.newSerializer()
+                with(serializer) {
+                    setOutput(writer)
+                    startDocument("UTF-8", null)
+                    setPrefix("", XmlUtils.NS_WEBDAV)
+                    setPrefix("CAL", XmlUtils.NS_CALDAV)
+                    setPrefix("CARD", XmlUtils.NS_CARDDAV)
+    
+                    startTag(XmlUtils.NS_WEBDAV, "mkcol")
+                        startTag(XmlUtils.NS_WEBDAV, "set")
+                            startTag(XmlUtils.NS_WEBDAV, "prop")
+                                startTag(XmlUtils.NS_WEBDAV, "resourcetype")
+                                    startTag(XmlUtils.NS_WEBDAV, "collection")
+                                    endTag(XmlUtils.NS_WEBDAV, "collection")
+                                    if (info.type == CollectionInfo.Type.ADDRESS_BOOK) {
+                                        startTag(XmlUtils.NS_CARDDAV, "addressbook")
+                                        endTag(XmlUtils.NS_CARDDAV, "addressbook")
+                                    } else if (info.type == CollectionInfo.Type.CALENDAR) {
+                                        startTag(XmlUtils.NS_CALDAV, "calendar")
+                                        endTag(XmlUtils.NS_CALDAV, "calendar")
+                                    }
+                                endTag(XmlUtils.NS_WEBDAV, "resourcetype")
+                                info.displayName?.let {
+                                    startTag(XmlUtils.NS_WEBDAV, "displayname")
+                                        text(it)
+                                    endTag(XmlUtils.NS_WEBDAV, "displayname")
+                                }
+    
+                                // addressbook-specific properties
+                                if (info.type == CollectionInfo.Type.ADDRESS_BOOK) {
+                                    info.description?.let {
+                                        startTag(XmlUtils.NS_CARDDAV, "addressbook-description")
+                                        text(it)
+                                        endTag(XmlUtils.NS_CARDDAV, "addressbook-description")
+                                    }
+                                }
+    
+                                // calendar-specific properties
+                                if (info.type == CollectionInfo.Type.CALENDAR) {
+                                    info.description?.let {
+                                        startTag(XmlUtils.NS_CALDAV, "calendar-description")
+                                        text(it)
+                                        endTag(XmlUtils.NS_CALDAV, "calendar-description")
+                                    }
+
+                                    info.color?.let {
+                                        startTag(XmlUtils.NS_APPLE_ICAL, "calendar-color")
+                                        text(DavUtils.ARGBtoCalDAVColor(it))
+                                        endTag(XmlUtils.NS_APPLE_ICAL, "calendar-color")
+                                    }
+
+                                    info.timeZone?.let {
+                                        startTag(XmlUtils.NS_CALDAV, "calendar-timezone")
+                                        cdsect(it)
+                                        endTag(XmlUtils.NS_CALDAV, "calendar-timezone")
+                                    }
+    
+                                    startTag(XmlUtils.NS_CALDAV, "supported-calendar-component-set")
+                                    if (info.supportsVEVENT) {
+                                        startTag(XmlUtils.NS_CALDAV, "comp")
+                                        attribute(null, "name", "VEVENT")
+                                        endTag(XmlUtils.NS_CALDAV, "comp")
+                                    }
+                                    if (info.supportsVTODO) {
+                                        startTag(XmlUtils.NS_CALDAV, "comp")
+                                        attribute(null, "name", "VTODO")
+                                        endTag(XmlUtils.NS_CALDAV, "comp")
+                                    }
+                                    if (info.supportsVJOURNAL) {
+                                        startTag(XmlUtils.NS_CALDAV, "comp")
+                                        attribute(null, "name", "VJOURNAL")
+                                        endTag(XmlUtils.NS_CALDAV, "comp")
+                                    }
+                                    endTag(XmlUtils.NS_CALDAV, "supported-calendar-component-set")
+                                }
+    
+                            endTag(XmlUtils.NS_WEBDAV, "prop")
+                        endTag(XmlUtils.NS_WEBDAV, "set")
+                    endTag(XmlUtils.NS_WEBDAV, "mkcol")
+                    endDocument()
+                }
+            } catch(e: IOException) {
+                Logger.log.log(Level.SEVERE, "Couldn't assemble Extended MKCOL request", e)
+            }
+
+            HttpClient.Builder(context, AccountSettings(context, account))
+                    .setForeground(true)
+                    .build().use { httpClient ->
+                try {
+                    val collection = DavResource(httpClient.okHttpClient, info.url)
+
+                    // create collection on remote server
+                    collection.mkCol(writer.toString()) {}
+
+                    // now insert collection into database:
+                    ServiceDB.OpenHelper(context).use { dbHelper ->
+                        val db = dbHelper.writableDatabase
+
+                        // 1. find service ID
+                        val serviceType = when (info.type) {
+                            CollectionInfo.Type.ADDRESS_BOOK -> ServiceDB.Services.SERVICE_CARDDAV
+                            CollectionInfo.Type.CALENDAR     -> ServiceDB.Services.SERVICE_CALDAV
+                            else -> throw IllegalArgumentException("Collection must be an address book or calendar")
+                        }
+                        db.query(ServiceDB.Services._TABLE, arrayOf(ServiceDB.Services.ID),
+                                "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
+                                arrayOf(account.name, serviceType), null, null, null).use { c ->
+
+                            assert(c.moveToNext())
+                            val serviceID = c.getLong(0)
+
+                            // 2. add collection to service
+                            val values = info.toDB()
+                            values.put(ServiceDB.Collections.SERVICE_ID, serviceID)
+                            db.insert(ServiceDB.Collections._TABLE, null, values)
+                        }
+                    }
+                } catch(e: Exception) {
+                    return e
+                }
+            }
+            return null
+        }
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/DebugInfoActivity.kt

@@ -0,0 +1,321 @@
+/*
+ * 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.Manifest
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.app.Application
+import android.content.ContentResolver
+import android.content.ContentUris
+import android.content.Context
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.net.ConnectivityManager
+import android.os.Build
+import android.os.Bundle
+import android.os.PowerManager
+import android.provider.CalendarContract
+import android.provider.ContactsContract
+import android.util.Log
+import android.view.Menu
+import android.view.MenuItem
+import androidx.appcompat.app.AppCompatActivity
+import androidx.core.app.ShareCompat
+import androidx.core.content.ContextCompat
+import androidx.core.content.FileProvider
+import androidx.core.content.pm.PackageInfoCompat
+import androidx.databinding.DataBindingUtil
+import androidx.lifecycle.AndroidViewModel
+import androidx.lifecycle.MutableLiveData
+import androidx.lifecycle.ViewModelProviders
+import at.bitfire.dav4jvm.exception.HttpException
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.davdroid.InvalidAccountException
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.databinding.ActivityDebugInfoBinding
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.ical4android.TaskProvider
+import org.dmfs.tasks.contract.TaskContract
+import java.io.File
+import java.io.FileWriter
+import java.io.IOException
+import java.util.logging.Level
+import kotlin.concurrent.thread
+
+class DebugInfoActivity: AppCompatActivity() {
+
+    companion object {
+        const val KEY_THROWABLE = "throwable"
+        const val KEY_LOGS = "logs"
+        const val KEY_ACCOUNT = "account"
+        const val KEY_AUTHORITY = "authority"
+        const val KEY_PHASE = "phase"
+        const val KEY_LOCAL_RESOURCE = "localResource"
+        const val KEY_REMOTE_RESOURCE = "remoteResource"
+    }
+
+    private lateinit var model: ReportModel
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+
+        model = ViewModelProviders.of(this).get(ReportModel::class.java)
+        model.initialize(intent.extras)
+
+        val binding = DataBindingUtil.setContentView<ActivityDebugInfoBinding>(this, R.layout.activity_debug_info)
+        binding.model = model
+        binding.lifecycleOwner = this
+    }
+
+    override fun onCreateOptionsMenu(menu: Menu): Boolean {
+        menuInflater.inflate(R.menu.activity_debug_info, menu)
+        return true
+    }
+
+
+    fun onShare(item: MenuItem) {
+        model.report.value?.let { report ->
+            val builder = ShareCompat.IntentBuilder.from(this)
+                    .setSubject("${getString(R.string.app_name)} ${BuildConfig.VERSION_NAME} debug model")
+                    .setType("text/plain")
+
+            try {
+                val debugInfoDir = File(filesDir, "debug")
+                if (!(debugInfoDir.exists() && debugInfoDir.isDirectory) && !debugInfoDir.mkdir())
+                    throw IOException("Couldn't create debug directory")
+
+                val reportFile = File(debugInfoDir, "davx5-model.txt")
+                Logger.log.fine("Writing debug model to ${reportFile.absolutePath}")
+                val writer = FileWriter(reportFile)
+                writer.write(report)
+                writer.close()
+
+                builder.setStream(FileProvider.getUriForFile(this, getString(R.string.authority_debug_provider), reportFile))
+                builder.intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_ACTIVITY_NEW_TASK)
+            } catch(e: IOException) {
+                // creating an attachment failed, so send it inline
+                val text = "Couldn't create debug model file: " + Log.getStackTraceString(e) + "\n\n$report"
+                builder.setText(text)
+            }
+
+            builder.startChooser()
+        }
+    }
+
+
+    class ReportModel(application: Application): AndroidViewModel(application) {
+
+        private var initialized = false
+        val report = MutableLiveData<String>()
+
+        fun initialize(extras: Bundle?) {
+            if (initialized)
+                return
+
+            Logger.log.info("Generating debug model report")
+            initialized = true
+
+            thread {
+                val context = getApplication<Application>()
+                val text = StringBuilder("--- BEGIN DEBUG INFO ---\n")
+
+                // begin with most specific information
+                extras?.getInt(KEY_PHASE, -1).takeIf { it != -1 }?.let {
+                    text.append("SYNCHRONIZATION INFO\nSynchronization phase: $it\n")
+                }
+                extras?.getParcelable<Account>(KEY_ACCOUNT)?.let {
+                    text.append("Account name: ${it.name}\n")
+                }
+                extras?.getString(KEY_AUTHORITY)?.let {
+                    text.append("Authority: $it\n")
+                }
+
+                // exception details
+                val throwable = extras?.getSerializable(KEY_THROWABLE) as Throwable?
+                if (throwable is HttpException) {
+                    throwable.request?.let {
+                        text.append("\nHTTP REQUEST:\n$it\n")
+                        throwable.requestBody?.let { text.append(it) }
+                        text.append("\n\n")
+                    }
+                    throwable.response?.let {
+                        text.append("HTTP RESPONSE:\n$it\n")
+                        throwable.responseBody?.let { text.append(it) }
+                        text.append("\n\n")
+                    }
+                }
+
+                extras?.getString(KEY_LOCAL_RESOURCE)?.let {
+                    text.append("\nLOCAL RESOURCE:\n$it\n")
+                }
+                extras?.getString(KEY_REMOTE_RESOURCE)?.let {
+                    text.append("\nREMOTE RESOURCE:\n$it\n")
+                }
+
+                throwable?.let {
+                    text.append("\nEXCEPTION:\n${Log.getStackTraceString(throwable)}")
+                }
+
+                // logs (for instance, from failed resource detection)
+                extras?.getString(KEY_LOGS)?.let {
+                    text.append("\nLOGS:\n$it\n")
+                }
+
+                // software information
+                try {
+                    text.append("\nSOFTWARE INFORMATION\n")
+                    val pm = context.packageManager
+                    val appIDs = mutableSetOf(      // we always want model about these packages
+                            BuildConfig.APPLICATION_ID,                     // DAVx5
+                            "${BuildConfig.APPLICATION_ID}.jbworkaround",   // DAVdroid JB Workaround
+                            "org.dmfs.tasks"                               // OpenTasks
+                    )
+                    // add model about contact, calendar, task provider
+                    for (authority in arrayOf(ContactsContract.AUTHORITY, CalendarContract.AUTHORITY, TaskProvider.ProviderName.OpenTasks.authority))
+                        pm.resolveContentProvider(authority, 0)?.let { appIDs += it.packageName }
+                    // add model about available contact, calendar, task apps
+                    for (uri in arrayOf(ContactsContract.Contacts.CONTENT_URI, CalendarContract.Events.CONTENT_URI, TaskContract.Tasks.getContentUri(TaskProvider.ProviderName.OpenTasks.authority))) {
+                        val viewIntent = Intent(Intent.ACTION_VIEW, ContentUris.withAppendedId(uri, 1))
+                        for (info in pm.queryIntentActivities(viewIntent, 0))
+                            appIDs += info.activityInfo.packageName
+                    }
+
+                    for (appID in appIDs)
+                        try {
+                            val info = pm.getPackageInfo(appID, 0)
+                            text  .append("* ").append(appID)
+                                    .append(" ").append(info.versionName)
+                                    .append(" (").append(PackageInfoCompat.getLongVersionCode(info)).append(")")
+                            pm.getInstallerPackageName(appID)?.let { installer ->
+                                text.append(" from ").append(installer)
+                            }
+                            info.applicationInfo?.let { applicationInfo ->
+                                if (!applicationInfo.enabled)
+                                    text.append(" disabled!")
+                                if (applicationInfo.flags.and(ApplicationInfo.FLAG_EXTERNAL_STORAGE) != 0)
+                                    text.append(" on external storage!")
+                            }
+                            text.append("\n")
+                        } catch(e: PackageManager.NameNotFoundException) {
+                        }
+                } catch(e: Exception) {
+                    Logger.log.log(Level.SEVERE, "Couldn't get software information", e)
+                }
+
+                // connectivity
+                text.append("\nCONNECTIVITY (at the moment)\n")
+                val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
+                connectivityManager.activeNetworkInfo?.let { networkInfo ->
+                    val type = when (networkInfo.type) {
+                        ConnectivityManager.TYPE_WIFI   -> "WiFi"
+                        ConnectivityManager.TYPE_MOBILE -> "mobile"
+                        else -> "type: ${networkInfo.type}"
+                    }
+                    text.append("Active connection: $type, ${networkInfo.detailedState}\n")
+                }
+                if (Build.VERSION.SDK_INT >= 23)
+                    connectivityManager.defaultProxy?.let { proxy ->
+                        text.append("System default proxy: ${proxy.host}:${proxy.port}")
+                    }
+                text.append("\n")
+
+                text.append("CONFIGURATION\n")
+                // power saving
+                val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
+                if (Build.VERSION.SDK_INT >= 23)
+                    text.append("Power saving disabled: ")
+                            .append(if (powerManager.isIgnoringBatteryOptimizations(BuildConfig.APPLICATION_ID)) "yes" else "no")
+                            .append("\n")
+                // permissions
+                for (permission in arrayOf(Manifest.permission.READ_CONTACTS, Manifest.permission.WRITE_CONTACTS,
+                        Manifest.permission.READ_CALENDAR, Manifest.permission.WRITE_CALENDAR,
+                        TaskProvider.PERMISSION_READ_TASKS, TaskProvider.PERMISSION_WRITE_TASKS,
+                        Manifest.permission.ACCESS_COARSE_LOCATION)) {
+                    text  .append(permission).append(": ")
+                            .append(if (ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED)
+                                "granted"
+                            else
+                                "denied")
+                            .append("\n")
+                }
+                // system-wide sync settings
+                text.append("System-wide synchronization: ")
+                        .append(if (ContentResolver.getMasterSyncAutomatically()) "automatically" else "manually")
+                        .append("\n")
+                // main accounts
+                val accountManager = AccountManager.get(context)
+                for (acct in accountManager.getAccountsByType(context.getString(R.string.account_type)))
+                    try {
+                        val accountSettings = AccountSettings(context, acct)
+                        text.append("Account: ${acct.name}\n" +
+                                "  Address book sync. interval: ${syncStatus(accountSettings, context.getString(R.string.address_books_authority))}\n" +
+                                "  Calendar     sync. interval: ${syncStatus(accountSettings, CalendarContract.AUTHORITY)}\n" +
+                                "  OpenTasks    sync. interval: ${syncStatus(accountSettings, TaskProvider.ProviderName.OpenTasks.authority)}\n" +
+                                "  WiFi only: ").append(accountSettings.getSyncWifiOnly())
+                        accountSettings.getSyncWifiOnlySSIDs()?.let {
+                            text.append(", SSIDs: ${accountSettings.getSyncWifiOnlySSIDs()}")
+                        }
+                        text.append("\n  [CardDAV] Contact group method: ${accountSettings.getGroupMethod()}")
+                                .append("\n  [CalDAV] Time range (past days): ${accountSettings.getTimeRangePastDays()}")
+                                .append("\n           Manage calendar colors: ${accountSettings.getManageCalendarColors()}")
+                                .append("\n           Use event colors: ${accountSettings.getEventColors()}")
+                                .append("\n")
+                    } catch (e: InvalidAccountException) {
+                        text.append("$acct is invalid (unsupported settings version) or does not exist\n")
+                    }
+                // address book accounts
+                for (acct in accountManager.getAccountsByType(context.getString(R.string.account_type_address_book)))
+                    try {
+                        val addressBook = LocalAddressBook(context, acct, null)
+                        text.append("Address book account: ${acct.name}\n" +
+                                "  Main account: ${addressBook.mainAccount}\n" +
+                                "  URL: ${addressBook.url}\n" +
+                                "  Sync automatically: ").append(ContentResolver.getSyncAutomatically(acct, ContactsContract.AUTHORITY)).append("\n")
+                    } catch(e: Exception) {
+                        text.append("$acct is invalid: ${e.message}\n")
+                    }
+                text.append("\n")
+
+                ServiceDB.OpenHelper(context).use { dbHelper ->
+                    text.append("SQLITE DUMP\n")
+                    dbHelper.dump(text)
+                    text.append("\n")
+                }
+
+                try {
+                    text.append(
+                            "SYSTEM INFORMATION\n" +
+                                    "Android version: ${Build.VERSION.RELEASE} (${Build.DISPLAY})\n" +
+                                    "Device: ${Build.MANUFACTURER} ${Build.MODEL} (${Build.DEVICE})\n\n"
+                    )
+                } catch(e: Exception) {
+                    Logger.log.log(Level.SEVERE, "Couldn't get system details", e)
+                }
+
+                text.append("--- END DEBUG INFO ---\n")
+                report.postValue(text.toString())
+            }
+        }
+
+        private fun syncStatus(settings: AccountSettings, authority: String): String {
+            val interval = settings.getSyncInterval(authority)
+            return if (interval != null) {
+                if (interval == AccountSettings.SYNC_INTERVAL_MANUALLY) "manually" else "${interval/60} min"
+            } else
+                "—"
+        }
+
+    }
+
+}

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

@@ -0,0 +1,65 @@
+/*
+ * 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.Context
+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
+
+class DefaultAccountsDrawerHandler: IAccountsDrawerHandler {
+
+    companion object {
+        private const val BETA_FEEDBACK_URI = "mailto:play@bitfire.at?subject=${BuildConfig.APPLICATION_ID}/${BuildConfig.VERSION_NAME} feedback (${BuildConfig.VERSION_CODE})"
+    }
+
+
+    override fun initMenu(context: Context, 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 ->
+                UiUtils.launchUri(activity, Uri.parse(BETA_FEEDBACK_URI), Intent.ACTION_SENDTO)
+            R.id.nav_twitter ->
+                UiUtils.launchUri(activity, Uri.parse("https://twitter.com/" + activity.getString(R.string.twitter_handle)))
+            R.id.nav_website ->
+                UiUtils.launchUri(activity, App.homepageUrl(activity))
+            R.id.nav_manual ->
+                UiUtils.launchUri(activity, App.homepageUrl(activity)
+                        .buildUpon().appendPath("manual").build())
+            R.id.nav_faq ->
+                UiUtils.launchUri(activity, App.homepageUrl(activity)
+                        .buildUpon().appendPath("faq").build())
+            R.id.nav_forums ->
+                UiUtils.launchUri(activity, App.homepageUrl(activity)
+                        .buildUpon().appendPath("forums").build())
+            R.id.nav_donate ->
+                //if (BuildConfig.FLAVOR != App.FLAVOR_GOOGLE_PLAY)
+                    UiUtils.launchUri(activity, App.homepageUrl(activity)
+                            .buildUpon().appendPath("donate").build())
+            else ->
+                return false
+        }
+
+        return true
+    }
+
+}

app/src/main/java/at/bitfire/davdroid/ui/DeleteCollectionFragment.kt

@@ -0,0 +1,128 @@
+/*
+ * 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.accounts.Account
+import android.app.Application
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import androidx.fragment.app.DialogFragment
+import androidx.lifecycle.*
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.davdroid.HttpClient
+import at.bitfire.davdroid.databinding.DeleteCollectionBinding
+import at.bitfire.davdroid.model.CollectionInfo
+import at.bitfire.davdroid.model.ServiceDB
+import at.bitfire.davdroid.settings.AccountSettings
+import kotlin.concurrent.thread
+
+class DeleteCollectionFragment: DialogFragment() {
+
+    companion object {
+        const val ARG_ACCOUNT = "account"
+        const val ARG_COLLECTION_INFO = "collectionInfo"
+
+        fun newInstance(account: Account, collectionInfo: CollectionInfo): DialogFragment {
+            val frag = DeleteCollectionFragment()
+            val args = Bundle(2)
+            args.putParcelable(ARG_ACCOUNT, account)
+            args.putParcelable(ARG_COLLECTION_INFO, collectionInfo)
+            frag.arguments = args
+            return frag
+        }
+    }
+
+    private lateinit var model: DeleteCollectionModel
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        model = ViewModelProviders.of(this).get(DeleteCollectionModel::class.java)
+
+        model.account = arguments?.getParcelable(ARG_ACCOUNT) as? Account
+        model.collectionInfo = arguments?.getParcelable(ARG_COLLECTION_INFO) as? CollectionInfo
+    }
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
+        val binding = DeleteCollectionBinding.inflate(layoutInflater, null, false)
+        binding.lifecycleOwner = this
+        binding.model = model
+
+        binding.ok.setOnClickListener {
+            isCancelable = false
+            binding.progress.visibility = View.VISIBLE
+            binding.controls.visibility = View.GONE
+
+            model.deleteCollection().observe(this, Observer { exception ->
+                if (exception == null)
+                    // reload collection list
+                    (activity as? AccountActivity)?.reload()
+                else
+                    requireFragmentManager().beginTransaction()
+                            .add(ExceptionInfoFragment.newInstance(exception, model.account), null)
+                            .commit()
+                dismiss()
+            })
+        }
+
+        binding.cancel.setOnClickListener {
+            dismiss()
+        }
+
+        return binding.root
+    }
+
+
+    class DeleteCollectionModel(
+            application: Application
+    ): AndroidViewModel(application) {
+
+        var account: Account? = null
+        var collectionInfo: CollectionInfo? = null
+
+        val confirmation = MutableLiveData<Boolean>()
+        val result = MutableLiveData<Exception>()
+
+        fun deleteCollection(): LiveData<Exception> {
+            thread {
+                val account = requireNotNull(account)
+                val collectionInfo = requireNotNull(collectionInfo)
+
+                val context = getApplication<Application>()
+                HttpClient.Builder(context, AccountSettings(context, account))
+                        .setForeground(true)
+                        .build().use { httpClient ->
+                            try {
+                                val collection = DavResource(httpClient.okHttpClient, collectionInfo.url)
+
+                                // delete collection from server
+                                collection.delete(null) {}
+
+                                // delete collection locally
+                                ServiceDB.OpenHelper(context).use { dbHelper ->
+                                    val db = dbHelper.writableDatabase
+                                    db.delete(ServiceDB.Collections._TABLE, "${ServiceDB.Collections.ID}=?", arrayOf(collectionInfo.id.toString()))
+                                }
+
+                                // return success
+                                result.postValue(null)
+
+                            } catch(e: Exception) {
+                                // return error
+                                result.postValue(e)
+                            }
+                        }
+            }
+            return result
+        }
+
+    }
+
+}