Lint cleanup

Version bump to 3.3.12-beta3
Update test dependencies
2026-08-07 05:44:54 -04:00 · 2021-07-12 13:40:13 +02:00 · 2021-07-12 12:49:16 +02:00 · 2021-07-12 12:42:56 +02:00 · 2021-07-12 12:36:08 +02:00 · 2021-07-08 14:38:49 +02:00
550 changed files with 61414 additions and 7965 deletions
@@ -1,60 +1,92 @@
-### ANDROID
+# Created by https://www.gitignore.io

-# built application files
+### Android ###
+# Built application files
 *.apk
 *.ap_

-# files for the dex VM
+# Files for the Dalvik VM
 *.dex

 # Java class files
 *.class

-# generated files
+# Generated files
 bin/
 gen/

+# Gradle files
+.gradle/
+build/
+
 # Local configuration file (sdk path, etc)
 local.properties

-# Eclipse project files
-.classpath
-.project
-
 # Proguard folder generated by Eclipse
 proguard/

-# Intellij project files
+# Log Files
+*.log
+
+
+### Intellij ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm
+
 *.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
 *.ipr
 *.iws
-.idea/
+
+## Plugin-specific files:
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties


-### ECLIPSE
+### Gradle ###
+.gradle
+build/

-*.pydevproject
-.metadata
-bin/**
-tmp/**
-tmp/**/*
-*.tmp
-*.bak
-*.swp
-*~.nib
-local.properties
-.classpath
-.settings/
-.loadpath
+# Ignore Gradle GUI config
+gradle-app.setting

-# External tool builders
-.externalToolBuilders/
+### external libs ###
+.svn

-# Locally stored "Eclipse launch configurations"
-*.launch
-
-# CDT-specific
-.cproject
-
-# PDT-specific
-.buildpath
+# Javadoc
+javadoc/
@@ -0,0 +1,32 @@
+image: registry.gitlab.com/bitfireat/docker-android-emulator:latest
+
+before_script:
+  - git submodule update --init --recursive
+  - export GRADLE_USER_HOME=`pwd`/.gradle; chmod +x gradlew
+
+cache:
+  paths:
+     - .gradle/
+
+test:
+  tags:
+    - privileged
+  script:
+   - curl -d "email=gitlab%40bitfire.at&password=$DAVTEST_TOKEN&action=Request+access" -X POST "https://davtest.dev001.net/access/"
+   - start-emulator.sh
+   - ./gradlew app:check app:connectedCheck
+  artifacts:
+    paths:
+      - app/build/outputs/lint-results-debug.html
+      - app/build/reports
+      - build/reports
+
+pages:
+  script:
+    - ./gradlew app:dokka
+    - mkdir public && mv app/build/dokka public
+  artifacts:
+    paths:
+      - public
+  only:
+    - master-ose
@@ -0,0 +1,9 @@
+[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
@@ -1,77 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="at.bitfire.davdroid"
-    android:versionCode="29"
-    android:versionName="0.5.8.1" android:installLocation="internalOnly">
-
-    <uses-sdk
-        android:minSdkVersion="14"
-        android:targetSdkVersion="19" />
-
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
-    <uses-permission android:name="android.permission.READ_CONTACTS" />
-    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
-    <uses-permission android:name="android.permission.READ_CALENDAR" />
-    <uses-permission android:name="android.permission.WRITE_CALENDAR" />
-    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
-
-    <application
-        android:allowBackup="false"
-        android:icon="@drawable/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/AppTheme" >
-        <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.ContactsSyncAdapterService"
-            android:exported="true"
-            android:process=":sync" >
-            <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>
-        <service
-            android:name=".syncadapter.CalendarsSyncAdapterService"
-            android:exported="true"
-            android:process=":sync" >
-            <intent-filter>
-                <action android:name="android.content.SyncAdapter" />
-            </intent-filter>
-
-            <meta-data
-                android:name="android.content.SyncAdapter"
-                android:resource="@xml/sync_calendars" />
-        </service>
-
-        <activity
-            android:name=".MainActivity"
-            android:label="@string/app_name" >
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-        <activity
-            android:name=".syncadapter.AddAccountActivity"
-            android:excludeFromRecents="true" >
-        </activity>
-    </application>
-
-</manifest>
@@ -0,0 +1,47 @@
+
+Contributing to DAVx⁵
+=====================
+
+**Thank you for your interest in contributing to DAVx⁵!**
+
+Because you're reading this, you're probably interested in
+contributing to the DAVx⁵ code. [Other ways to contribute:
+see here.](https://www.davx5.com/donate#c306)
+
+To contribute:
+
+1. It's good idea to have a look at the [DAVx⁵ Roadmap](https://gitlab.com/bitfireAT/davx5-ose/wikis/Roadmap)
+   to see whether the change is already planned. Maybe there's even a link to a
+   corresponding forum thread there.
+1. Determine which project the changes shall go to. There's
+   the DAVx⁵ main project (this repo), and the [related
+   libraries](README.md).
+1. Please post to the [DAVx⁵ development forum](https://www.davx5.com/forums)
+   before doing actual work (unless you do it only for yourself, of course).
+   This will help to coordinate activities and you'll also get hints
+   about where to start and possible pitfalls.
+1. Fork the repository.
+1. Do the changes in your repository.
+1. Submit a pull request to the original project.
+1. Post in the forum again (to make sure the pull request is being notified).
+
+
+Questions, discussion
+=====================
+
+We're happy to see questions, discussions etc. in the
+[DAVx⁵ development forum](https://www.davx5.com/forums)!
+
+
+Licensing
+=========
+
+All code has to be licensed under the GPL.
+
+We (bitfire.at, initial developers) are also asking you to double-license the
+code so that we can also use it for related non-open source projects like
+[Managed DAVx⁵](https://www.davx5.com/organizations/managed-davx5).
+
+Please find more about this in the Contributor's License Agreement (CLA)
+we'll send to you if you want to contribute.
+
@@ -1,12 +1,37 @@
+![DAVx⁵ logo](app/src/main/res/mipmap-xxxhdpi/ic_launcher.png)

-Please see the [DAVdroid Web site](http://davdroid.bitfire.at).
+DAVx⁵
+========
+
+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: [@davx5app](https://twitter.com/davx5app) on Twitter
+
+Help, discussion, feature requests, bug reports and "issues": [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
 ==========================

-* [iCal4j](http://ical4j.sourceforge.net/) ([New BSD License](http://sourceforge.net/p/ical4j/ical4j/ci/default/tree/LICENSE))
-* [ez-vcard](https://code.google.com/p/ez-vcard/) ([New BSD License](http://opensource.org/licenses/BSD-3-Clause))
-* [Simple XML Serialization](http://simple.sourceforge.net/) ([Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0))
-* [Project Lombok](http://projectlombok.org/) ([MIT License](http://opensource.org/licenses/mit-license.php))
+Those libraries are used by DAVx⁵ (alphabetically):

+* [Color Picker](https://github.com/jaredrummler/ColorPicker) – [Apache License, Version 2.0](https://github.com/jaredrummler/ColorPicker/LICENSE)
+* [dnsjava](http://www.xbill.org/dnsjava/) – [BSD License](http://www.xbill.org/dnsjava/dnsjava-current/LICENSE)
+* [ez-vcard](https://github.com/mangstadt/ez-vcard) – [New BSD License](http://opensource.org/licenses/BSD-3-Clause)
+* [iCal4j](https://github.com/ical4j/ical4j) – [New BSD License](http://sourceforge.net/p/ical4j/ical4j/ci/default/tree/LICENSE)
+* [okhttp](https://square.github.io/okhttp) – [Apache License, Version 2.0](https://square.github.io/okhttp/#license)
@@ -0,0 +1,2 @@
+build
+target
@@ -0,0 +1,175 @@
+/*
+ * 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: 'com.mikepenz.aboutlibraries.plugin'
+apply plugin: 'kotlin-android'
+apply plugin: 'kotlin-kapt'
+apply plugin: 'org.jetbrains.dokka'
+
+android {
+    compileSdkVersion 30
+    buildToolsVersion '30.0.3'
+
+    defaultConfig {
+        applicationId "at.bitfire.davdroid"
+
+        versionCode 303120002
+        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
+
+        minSdkVersion 21        // Android 5
+        targetSdkVersion 30     // Android 11
+
+        buildConfigField "String", "userAgent", "\"DAVx5\""
+
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+
+        kapt {
+            arguments {
+                arg("room.schemaLocation", "$projectDir/schemas")
+            }
+        }
+    }
+
+    compileOptions {
+        // enable because ical4android requires desugaring
+        coreLibraryDesugaringEnabled true
+
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+
+    buildFeatures {
+        viewBinding = true
+        dataBinding = true
+    }
+
+    flavorDimensions "distribution"
+    productFlavors {
+        standard {
+            versionName "3.3.12-beta3-ose"
+        }
+    }
+
+    sourceSets {
+        androidTest.assets.srcDirs += files("$projectDir/schemas".toString())
+    }
+
+    buildTypes {
+        debug {
+        }
+        release {
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules-release.pro'
+
+            shrinkResources true
+        }
+    }
+
+    lintOptions {
+        disable 'GoogleAppIndexingWarning'                  // we don't need Google indexing, thanks
+        disable 'ImpliedQuantity', 'MissingQuantity'        // quantities from Transifex may vary
+        disable 'MissingTranslation', 'ExtraTranslation'    // translations from Transifex are not always up to date
+        disable 'RtlEnabled', 'RtlHardcoded'                // RTL not supported yet
+        disable 'Typos'
+        disable 'NullSafeMutableLiveData'                   // crashes lint since Mar 2021
+    }
+
+    dokka.configuration {
+        sourceLink {
+            url = "https://gitlab.com/bitfireAT/davx5-ose/tree/master-ose/"
+            lineSuffix = "#L"
+        }
+        jdkVersion = 8
+
+        externalDocumentationLink {
+            url = new URL("https://bitfireat.gitlab.io/cert4android/dokka/cert4android/")
+            packageListUrl = new URL("https://bitfireat.gitlab.io/cert4android/dokka/cert4android/package-list")
+        }
+        externalDocumentationLink {
+            url = new URL("https://bitfireat.gitlab.io/dav4jvm/dokka/dav4jvm/")
+            packageListUrl = new URL("https://bitfireat.gitlab.io/dav4jvm/dokka/dav4jvm/package-list")
+        }
+        externalDocumentationLink {
+            url = new URL("https://bitfireat.gitlab.io/ical4android/dokka/ical4android/")
+            packageListUrl = new URL("https://bitfireat.gitlab.io/ical4android/dokka/ical4android/package-list")
+        }
+        externalDocumentationLink {
+            url = new URL("https://bitfireat.gitlab.io/vcard4android/dokka/vcard4android/")
+            packageListUrl = new URL("https://bitfireat.gitlab.io/vcard4android/dokka/vcard4android/package-list")
+        }
+    }
+}
+
+aboutLibraries {
+    additionalLicenses {
+        mpl_2_0
+    }
+}
+
+dependencies {
+    implementation project(':cert4android')
+    implementation project(':ical4android')
+    implementation project(':vcard4android')
+
+    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk7"
+    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.5.0"
+    coreLibraryDesugaring 'com.android.tools:desugar_jdk_libs:1.1.5'
+
+    implementation 'androidx.appcompat:appcompat:1.3.0'
+    implementation 'androidx.browser:browser:1.3.0'
+    implementation 'androidx.cardview:cardview:1.0.0'
+    implementation 'androidx.constraintlayout:constraintlayout:2.0.4'
+    implementation 'androidx.core:core-ktx:1.6.0'
+    implementation 'androidx.fragment:fragment-ktx:1.3.5'
+    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
+    implementation 'androidx.lifecycle:lifecycle-viewmodel-ktx:2.3.1'
+    implementation 'androidx.paging:paging-runtime-ktx:3.0.0'
+    implementation 'androidx.preference:preference-ktx:1.1.1'
+    implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
+    implementation 'com.google.android:flexbox:2.0.1'
+    implementation 'com.google.android.material:material:1.4.0'
+
+    def room_version = '2.3.0'
+    implementation "androidx.room:room-runtime:$room_version"
+    implementation "androidx.room:room-ktx:$room_version"
+    kapt "androidx.room:room-compiler:$room_version"
+    androidTestImplementation "androidx.room:room-testing:$room_version"
+
+    implementation 'com.jaredrummler:colorpicker:1.1.0'
+    implementation "com.github.AppIntro:AppIntro:${versions.appIntro}"
+    implementation "com.gitlab.bitfireAT:dav4jvm:${versions.dav4jvm}"
+    implementation "com.mikepenz:aboutlibraries:${versions.aboutLibraries}"
+    implementation "com.squareup.okhttp3:okhttp:${versions.okhttp}"
+    implementation "com.squareup.okhttp3:okhttp-brotli:${versions.okhttp}"
+    implementation "com.squareup.okhttp3:logging-interceptor:${versions.okhttp}"
+    implementation 'commons-io:commons-io:2.6'
+    //noinspection GradleDependency - dnsjava 3+ needs Java 8/Android 7
+    implementation 'dnsjava:dnsjava:2.1.9'
+    //noinspection GradleDependency
+    implementation "org.apache.commons:commons-collections4:${versions.commonsCollections}"
+    //noinspection GradleDependency
+    implementation "org.apache.commons:commons-lang3:${versions.commonsLang}"
+    //noinspection GradleDependency
+    implementation "org.apache.commons:commons-text:${versions.commonsText}"
+
+    // for tests
+    androidTestImplementation 'androidx.test:runner:1.4.0'
+    androidTestImplementation 'androidx.test:rules:1.4.0'
+    androidTestImplementation 'androidx.test.ext:junit-ktx:1.1.3'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
+    androidTestImplementation 'androidx.test.espresso:espresso-contrib:3.4.0'
+    androidTestImplementation 'junit:junit:4.13.2'
+    androidTestImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
+
+    testImplementation 'junit:junit:4.13.2'
+    testImplementation "com.squareup.okhttp3:mockwebserver:${versions.okhttp}"
+}
@@ -0,0 +1,13 @@
+<?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
+  -->
+
+<lint>
+    <issue id="InvalidPackage" severity="ignore" />
+    <issue id="MissingTranslation" severity="warning" />
+</lint>
@@ -0,0 +1,25 @@
+
+# R8 usage for DAVx⁵:
+#    shrinking        yes (only in release builds)
+#    optimization     yes (on by R8 defaults)
+#    obfuscation      no (open-source)
+
+-dontobfuscate
+-printusage build/reports/r8-usage.txt
+
+# ez-vcard: keep all vCard properties/parameters (used via reflection)
+-keep class ezvcard.io.scribe.** { *; }
+-keep class ezvcard.property.** { *; }
+-keep class ezvcard.parameter.** { *; }
+
+# ical4j: keep all iCalendar properties/parameters (used via reflection)
+-keep class net.fortuna.ical4j.** { *; }
+
+# DAVx⁵ + libs
+-keep class at.bitfire.** { *; }       # all DAVx⁵ code is required
+
+# we use enum classes (https://www.guardsquare.com/en/products/proguard/manual/examples#enumerations)
+-keepclassmembers,allowoptimization enum * {
+    public static **[] values();
+    public static ** valueOf(java.lang.String);
+}
@@ -0,0 +1,298 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 8,
+    "identityHash": "b8699ef3cc4c62e8851df4360fb69e00",
+    "entities": [
+      {
+        "tableName": "service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `accountName` TEXT NOT NULL, `type` TEXT NOT NULL, `principal` TEXT)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accountName",
+            "columnName": "accountName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "principal",
+            "columnName": "principal",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_service_accountName_type` ON `${TABLE_NAME}` (`accountName`, `type`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "homeset",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `personal` INTEGER NOT NULL, `url` TEXT NOT NULL, `privBind` INTEGER NOT NULL, `displayName` TEXT, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "personal",
+            "columnName": "personal",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privBind",
+            "columnName": "privBind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_homeset_serviceId_url` ON `${TABLE_NAME}` (`serviceId`, `url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "collection",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `homeSetId` INTEGER, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `owner` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`homeSetId`) REFERENCES `homeset`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "homeSetId",
+            "columnName": "homeSetId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privWriteContent",
+            "columnName": "privWriteContent",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privUnbind",
+            "columnName": "privUnbind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "forceReadOnly",
+            "columnName": "forceReadOnly",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "owner",
+            "columnName": "owner",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "timezone",
+            "columnName": "timezone",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVEVENT",
+            "columnName": "supportsVEVENT",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVTODO",
+            "columnName": "supportsVTODO",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVJOURNAL",
+            "columnName": "supportsVJOURNAL",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "source",
+            "columnName": "source",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "sync",
+            "columnName": "sync",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_serviceId_type` ON `${TABLE_NAME}` (`serviceId`, `type`)"
+          },
+          {
+            "name": "index_collection_homeSetId_type",
+            "unique": false,
+            "columnNames": [
+              "homeSetId",
+              "type"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "homeset",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "homeSetId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, 'b8699ef3cc4c62e8851df4360fb69e00')"
+    ]
+  }
+}
@@ -0,0 +1,366 @@
+{
+  "formatVersion": 1,
+  "database": {
+    "version": 9,
+    "identityHash": "7e4bfdf7f9fa3529c333cf9485f8cf50",
+    "entities": [
+      {
+        "tableName": "service",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `accountName` TEXT NOT NULL, `type` TEXT NOT NULL, `principal` TEXT)",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "accountName",
+            "columnName": "accountName",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "principal",
+            "columnName": "principal",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_service_accountName_type",
+            "unique": true,
+            "columnNames": [
+              "accountName",
+              "type"
+            ],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_service_accountName_type` ON `${TABLE_NAME}` (`accountName`, `type`)"
+          }
+        ],
+        "foreignKeys": []
+      },
+      {
+        "tableName": "homeset",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `personal` INTEGER NOT NULL, `url` TEXT NOT NULL, `privBind` INTEGER NOT NULL, `displayName` TEXT, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "personal",
+            "columnName": "personal",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privBind",
+            "columnName": "privBind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_homeset_serviceId_url",
+            "unique": true,
+            "columnNames": [
+              "serviceId",
+              "url"
+            ],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_homeset_serviceId_url` ON `${TABLE_NAME}` (`serviceId`, `url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "collection",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `serviceId` INTEGER NOT NULL, `homeSetId` INTEGER, `type` TEXT NOT NULL, `url` TEXT NOT NULL, `privWriteContent` INTEGER NOT NULL, `privUnbind` INTEGER NOT NULL, `forceReadOnly` INTEGER NOT NULL, `displayName` TEXT, `description` TEXT, `owner` TEXT, `color` INTEGER, `timezone` TEXT, `supportsVEVENT` INTEGER, `supportsVTODO` INTEGER, `supportsVJOURNAL` INTEGER, `source` TEXT, `sync` INTEGER NOT NULL, FOREIGN KEY(`serviceId`) REFERENCES `service`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE , FOREIGN KEY(`homeSetId`) REFERENCES `homeset`(`id`) ON UPDATE NO ACTION ON DELETE SET NULL )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "serviceId",
+            "columnName": "serviceId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "homeSetId",
+            "columnName": "homeSetId",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "type",
+            "columnName": "type",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "url",
+            "columnName": "url",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privWriteContent",
+            "columnName": "privWriteContent",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "privUnbind",
+            "columnName": "privUnbind",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "forceReadOnly",
+            "columnName": "forceReadOnly",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "displayName",
+            "columnName": "displayName",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "description",
+            "columnName": "description",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "owner",
+            "columnName": "owner",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "color",
+            "columnName": "color",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "timezone",
+            "columnName": "timezone",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVEVENT",
+            "columnName": "supportsVEVENT",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVTODO",
+            "columnName": "supportsVTODO",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "supportsVJOURNAL",
+            "columnName": "supportsVJOURNAL",
+            "affinity": "INTEGER",
+            "notNull": false
+          },
+          {
+            "fieldPath": "source",
+            "columnName": "source",
+            "affinity": "TEXT",
+            "notNull": false
+          },
+          {
+            "fieldPath": "sync",
+            "columnName": "sync",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_collection_serviceId_type",
+            "unique": false,
+            "columnNames": [
+              "serviceId",
+              "type"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_serviceId_type` ON `${TABLE_NAME}` (`serviceId`, `type`)"
+          },
+          {
+            "name": "index_collection_homeSetId_type",
+            "unique": false,
+            "columnNames": [
+              "homeSetId",
+              "type"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_homeSetId_type` ON `${TABLE_NAME}` (`homeSetId`, `type`)"
+          },
+          {
+            "name": "index_collection_url",
+            "unique": false,
+            "columnNames": [
+              "url"
+            ],
+            "createSql": "CREATE INDEX IF NOT EXISTS `index_collection_url` ON `${TABLE_NAME}` (`url`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "service",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "serviceId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          },
+          {
+            "table": "homeset",
+            "onDelete": "SET NULL",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "homeSetId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      },
+      {
+        "tableName": "syncstats",
+        "createSql": "CREATE TABLE IF NOT EXISTS `${TABLE_NAME}` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `collectionId` INTEGER NOT NULL, `authority` TEXT NOT NULL, `lastSync` INTEGER NOT NULL, FOREIGN KEY(`collectionId`) REFERENCES `collection`(`id`) ON UPDATE NO ACTION ON DELETE CASCADE )",
+        "fields": [
+          {
+            "fieldPath": "id",
+            "columnName": "id",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "collectionId",
+            "columnName": "collectionId",
+            "affinity": "INTEGER",
+            "notNull": true
+          },
+          {
+            "fieldPath": "authority",
+            "columnName": "authority",
+            "affinity": "TEXT",
+            "notNull": true
+          },
+          {
+            "fieldPath": "lastSync",
+            "columnName": "lastSync",
+            "affinity": "INTEGER",
+            "notNull": true
+          }
+        ],
+        "primaryKey": {
+          "columnNames": [
+            "id"
+          ],
+          "autoGenerate": true
+        },
+        "indices": [
+          {
+            "name": "index_syncstats_collectionId_authority",
+            "unique": true,
+            "columnNames": [
+              "collectionId",
+              "authority"
+            ],
+            "createSql": "CREATE UNIQUE INDEX IF NOT EXISTS `index_syncstats_collectionId_authority` ON `${TABLE_NAME}` (`collectionId`, `authority`)"
+          }
+        ],
+        "foreignKeys": [
+          {
+            "table": "collection",
+            "onDelete": "CASCADE",
+            "onUpdate": "NO ACTION",
+            "columns": [
+              "collectionId"
+            ],
+            "referencedColumns": [
+              "id"
+            ]
+          }
+        ]
+      }
+    ],
+    "views": [],
+    "setupQueries": [
+      "CREATE TABLE IF NOT EXISTS room_master_table (id INTEGER PRIMARY KEY,identity_hash TEXT)",
+      "INSERT OR REPLACE INTO room_master_table (id,identity_hash) VALUES(42, '7e4bfdf7f9fa3529c333cf9485f8cf50')"
+    ]
+  }
+}
@@ -0,0 +1 @@
+espressoTest
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="at.bitfire.davdroid"
+          xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools"
+          android:installLocation="internalOnly">
+
+    <!-- account management permissions not required for own accounts since API level 22 -->
+    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" android:maxSdkVersion="22"/>
+    <uses-permission android:name="android.permission.GET_ACCOUNTS" android:maxSdkVersion="22"/>
+    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS" android:maxSdkVersion="22"/>
+
+    <application>
+
+        <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/test_account_authenticator"/>
+        </service>
+
+    </application>
+
+</manifest>
@@ -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"))
+    }
+
+}
@@ -0,0 +1,38 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Room
+import androidx.room.testing.MigrationTestHelper
+import androidx.sqlite.db.framework.FrameworkSQLiteOpenHelperFactory
+import androidx.test.platform.app.InstrumentationRegistry
+import org.junit.Rule
+import org.junit.Test
+
+class AppDatabaseTest {
+
+    val TEST_DB = "test"
+
+    @Rule
+    @JvmField
+    val helper = MigrationTestHelper(
+            InstrumentationRegistry.getInstrumentation(),
+            AppDatabase::class.java.canonicalName,
+            FrameworkSQLiteOpenHelperFactory()
+    )
+
+
+    @Test
+    fun testAllMigrations() {
+        // DB schema is available since version 8
+        helper.createDatabase(TEST_DB, 8).close()
+
+        Room.databaseBuilder(
+            InstrumentationRegistry.getInstrumentation().targetContext,
+            AppDatabase::class.java,
+            TEST_DB
+        ).addMigrations(*AppDatabase.migrations).build().apply {
+            openHelper.writableDatabase
+            close()
+        }
+    }
+
+}
@@ -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 androidx.test.filters.SmallTest
+import at.bitfire.dav4jvm.DavResource
+import at.bitfire.dav4jvm.property.ResourceType
+import at.bitfire.davdroid.HttpClient
+import okhttp3.HttpUrl.Companion.toHttpUrl
+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 CollectionTest {
+
+    private lateinit var httpClient: HttpClient
+    private val server = MockWebServer()
+
+    @Before
+    fun setUp() {
+        httpClient = HttpClient.Builder().build()
+    }
+
+    @After
+    fun shutDown() {
+        httpClient.close()
+    }
+
+
+    @Test
+    @SmallTest
+    fun testFromDavResponseAddressBook() {
+        // r/w address book
+        server.enqueue(MockResponse()
+                .setResponseCode(207)
+                .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav'>" +
+                        "<response>" +
+                        "   <href>/</href>" +
+                        "   <propstat><prop>" +
+                        "       <resourcetype><collection/><CARD:addressbook/></resourcetype>" +
+                        "       <displayname>My Contacts</displayname>" +
+                        "       <CARD:addressbook-description>My Contacts Description</CARD:addressbook-description>" +
+                        "   </prop></propstat>" +
+                        "</response>" +
+                        "</multistatus>"))
+
+        lateinit var info: Collection
+        DavResource(httpClient.okHttpClient, server.url("/"))
+                .propfind(0, ResourceType.NAME) { response, _ ->
+            info = Collection.fromDavResponse(response) ?: throw IllegalArgumentException()
+        }
+        assertEquals(Collection.TYPE_ADDRESSBOOK, info.type)
+        assertTrue(info.privWriteContent)
+        assertTrue(info.privUnbind)
+        assertNull(info.supportsVEVENT)
+        assertNull(info.supportsVTODO)
+        assertNull(info.supportsVJOURNAL)
+        assertEquals("My Contacts", info.displayName)
+        assertEquals("My Contacts Description", info.description)
+    }
+
+    @Test
+    @SmallTest
+    fun testFromDavResponseCalendar() {
+        // read-only calendar, no display name
+        server.enqueue(MockResponse()
+                .setResponseCode(207)
+                .setBody("<multistatus xmlns='DAV:' xmlns:CAL='urn:ietf:params:xml:ns:caldav' xmlns:ICAL='http://apple.com/ns/ical/'>" +
+                        "<response>" +
+                        "   <href>/</href>" +
+                        "   <propstat><prop>" +
+                        "       <resourcetype><collection/><CAL:calendar/></resourcetype>" +
+                        "       <current-user-privilege-set><privilege><read/></privilege></current-user-privilege-set>" +
+                        "       <CAL:calendar-description>My Calendar</CAL:calendar-description>" +
+                        "       <CAL:calendar-timezone>tzdata</CAL:calendar-timezone>" +
+                        "       <ICAL:calendar-color>#ff0000</ICAL:calendar-color>" +
+                        "   </prop></propstat>" +
+                        "</response>" +
+                        "</multistatus>"))
+
+        lateinit var info: Collection
+        DavResource(httpClient.okHttpClient, server.url("/"))
+                .propfind(0, ResourceType.NAME) { response, _ ->
+                    info = Collection.fromDavResponse(response) ?: throw IllegalArgumentException()
+                }
+        assertEquals(Collection.TYPE_CALENDAR, info.type)
+        assertFalse(info.privWriteContent)
+        assertFalse(info.privUnbind)
+        assertNull(info.displayName)
+        assertEquals("My Calendar", info.description)
+        assertEquals(0xFFFF0000.toInt(), info.color)
+        assertEquals("tzdata", info.timezone)
+        assertTrue(info.supportsVEVENT!!)
+        assertTrue(info.supportsVTODO!!)
+        assertTrue(info.supportsVJOURNAL!!)
+    }
+
+    @Test
+    @SmallTest
+    fun testFromDavResponseWebcal() {
+        // Webcal subscription
+        server.enqueue(MockResponse()
+                .setResponseCode(207)
+                .setBody("<multistatus xmlns='DAV:' xmlns:CS='http://calendarserver.org/ns/'>" +
+                        "<response>" +
+                        "   <href>/webcal1</href>" +
+                        "   <propstat><prop>" +
+                        "       <displayname>Sample Subscription</displayname>" +
+                        "       <resourcetype><collection/><CS:subscribed/></resourcetype>" +
+                        "       <CS:source><href>webcals://example.com/1.ics</href></CS:source>" +
+                        "   </prop></propstat>" +
+                        "</response>" +
+                        "</multistatus>"))
+
+        lateinit var info: Collection
+        DavResource(httpClient.okHttpClient, server.url("/"))
+                .propfind(0, ResourceType.NAME) { response, _ ->
+                    info = Collection.fromDavResponse(response) ?: throw IllegalArgumentException()
+                }
+        assertEquals(Collection.TYPE_WEBCAL, info.type)
+        assertEquals("Sample Subscription", info.displayName)
+        assertEquals("https://example.com/1.ics".toHttpUrl(), info.source)
+    }
+
+}
@@ -0,0 +1,64 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Room
+import androidx.test.platform.app.InstrumentationRegistry
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+
+class DaoToolsTest {
+
+    private lateinit var db: AppDatabase
+
+    @Before
+    fun createDb() {
+        val context = InstrumentationRegistry.getInstrumentation().context
+        db = Room.inMemoryDatabaseBuilder(context, AppDatabase::class.java).build()
+    }
+
+    @After
+    fun closeDb() {
+        db.close()
+    }
+
+    @Test
+    fun testSyncAll() {
+        val serviceDao = db.serviceDao()
+        val service = Service(id=0, accountName="test", type=Service.TYPE_CALDAV, principal = null)
+        service.id = serviceDao.insertOrReplace(service)
+
+        val homeSetDao = db.homeSetDao()
+        val entry1 = HomeSet(id=1, serviceId=service.id, personal=true, url= "https://example.com/1".toHttpUrl())
+        val entry3 = HomeSet(id=3, serviceId=service.id, personal=true, url= "https://example.com/3".toHttpUrl())
+        val oldItems = listOf(
+                entry1,
+                HomeSet(id=2, serviceId=service.id, personal=true, url= "https://example.com/2".toHttpUrl()),
+                entry3
+        )
+        homeSetDao.insert(oldItems)
+
+        val newItems = mutableMapOf<HttpUrl, HomeSet>()
+        newItems[entry1.url] = entry1
+
+        // no id, because identity is given by the url
+        val updated = HomeSet(id=0, serviceId=service.id, personal=true,
+                url= "https://example.com/2".toHttpUrl(), displayName="Updated Entry")
+        newItems[updated.url] = updated
+
+        val created = HomeSet(id=4, serviceId=service.id, personal=true, url= "https://example.com/4".toHttpUrl())
+        newItems[created.url] = created
+
+        DaoTools(homeSetDao).syncAll(oldItems, newItems, { it.url })
+
+        val afterSync = homeSetDao.getByService(service.id)
+        assertEquals(afterSync.size, 3)
+        assertFalse(afterSync.contains(entry3))
+        assertTrue(afterSync.contains(entry1))
+        assertTrue(afterSync.contains(updated))
+        assertTrue(afterSync.contains(created))
+    }
+
+}
@@ -0,0 +1,72 @@
+package at.bitfire.davdroid.settings
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.ContentResolver
+import android.os.Build
+import android.provider.CalendarContract
+import android.provider.ContactsContract
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.model.Credentials
+import at.bitfire.davdroid.syncadapter.AccountUtils
+import org.junit.After
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import java.util.concurrent.TimeUnit
+
+class AccountSettingsTest {
+
+    val context = InstrumentationRegistry.getInstrumentation().targetContext
+
+    val account = Account("Test Account", context.getString(R.string.account_type))
+    val fakeCredentials = Credentials("test", "test")
+
+
+    @Before
+    fun prepareAccount() {
+        assertTrue(AccountUtils.createAccount(context, account, AccountSettings.initialUserData(fakeCredentials)))
+        ContentResolver.setIsSyncable(account, CalendarContract.AUTHORITY, 1)
+        ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 0)
+    }
+
+    @After
+    fun removeAccount() {
+        val futureResult = AccountManager.get(context).removeAccount(account, {}, null)
+        assertTrue(futureResult.getResult(10, TimeUnit.SECONDS))
+    }
+
+
+    @Test
+    fun testSyncIntervals() {
+        val settings = AccountSettings(context, account)
+        val presetIntervals = context.resources.getStringArray(R.array.settings_sync_interval_seconds)
+                .map { it.toLong() }
+                .filter { it != AccountSettings.SYNC_INTERVAL_MANUALLY }
+        for (interval in presetIntervals) {
+            assertTrue(settings.setSyncInterval(CalendarContract.AUTHORITY, interval))
+            assertEquals(interval, settings.getSyncInterval(CalendarContract.AUTHORITY))
+        }
+    }
+
+    @Test
+    fun testSyncIntervals_IsNotSyncable() {
+        val settings = AccountSettings(context, account)
+        val interval = 15*60L    // 15 min
+        val result = settings.setSyncInterval(ContactsContract.AUTHORITY, interval)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)     // below Android 7, Android returns true for whatever reason
+            assertFalse(result)
+    }
+
+    @Test
+    fun testSyncIntervals_TooShort() {
+        val settings = AccountSettings(context, account)
+        val interval = 60L      // 1 min is not supported by Android
+        val result = settings.setSyncInterval(CalendarContract.AUTHORITY, interval)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)     // below Android 7, Android returns true for whatever reason
+            assertFalse(result)
+    }
+
+
+}
@@ -0,0 +1,28 @@
+/*
+ * 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.Test
+
+class SettingsManagerTest {
+
+    val settingsManager by lazy { SettingsManager.getInstance(InstrumentationRegistry.getInstrumentation().targetContext) }
+
+    @Test
+    fun testContainsKey() {
+        assertFalse(settingsManager.containsKey("notExisting"))
+
+        // provided by DefaultsProvider
+        assertTrue(settingsManager.containsKey(Settings.OVERRIDE_PROXY))
+    }
+
+}
@@ -0,0 +1,36 @@
+package at.bitfire.davdroid.syncadapter
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.os.Bundle
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.davdroid.R
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import java.util.concurrent.TimeUnit
+
+class AccountUtilsTest {
+
+    val context = InstrumentationRegistry.getInstrumentation().targetContext
+    val account = Account("Test Account", context.getString(R.string.account_type))
+
+    @Test
+    fun testCreateAccount() {
+        val userData = Bundle(2)
+        userData.putString("int", "1")
+        userData.putString("string", "abc/\"-")
+        try {
+            assertTrue(AccountUtils.createAccount(context, account, userData))
+
+            // validate user data
+            val manager = AccountManager.get(context)
+            assertEquals("1", manager.getUserData(account, "int"))
+            assertEquals("abc/\"-", manager.getUserData(account, "string"))
+        } finally {
+            val futureResult = AccountManager.get(context).removeAccount(account, {}, null)
+            assertTrue(futureResult.getResult(10, TimeUnit.SECONDS))
+        }
+    }
+
+}
@@ -0,0 +1,38 @@
+package at.bitfire.davdroid.syncadapter
+
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.LocalCollection
+
+class LocalTestCollection: LocalCollection<LocalTestResource> {
+
+    override val tag = "LocalTestCollection"
+    override val title = "Local Test Collection"
+
+    override var lastSyncState: SyncState? = null
+
+    val entries = mutableListOf<LocalTestResource>()
+
+    override fun findDeleted() = entries.filter { it.deleted }
+    override fun findDirty() = entries.filter { it.dirty }
+
+    override fun findByName(name: String) = entries.filter { it.fileName == name }.firstOrNull()
+
+    override fun markNotDirty(flags: Int): Int {
+        var updated = 0
+        for (dirty in findDirty()) {
+            dirty.flags = flags
+            updated++
+        }
+        return updated
+    }
+
+    override fun removeNotDirtyMarked(flags: Int): Int {
+        val numBefore = entries.size
+        entries.removeIf { !it.dirty && it.flags == flags }
+        return numBefore - entries.size
+    }
+
+    override fun forgetETags() {
+    }
+
+}
@@ -0,0 +1,43 @@
+package at.bitfire.davdroid.syncadapter
+
+import android.net.Uri
+import at.bitfire.davdroid.resource.LocalResource
+
+class LocalTestResource: LocalResource<Any> {
+
+    override val id: Long? = null
+    override var fileName: String? = null
+    override var eTag: String? = null
+    override var scheduleTag: String? = null
+    override var flags: Int = 0
+
+    var deleted = false
+    var dirty = false
+
+    override fun prepareForUpload() = "generated-file.txt"
+
+    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
+        dirty = false
+        if (fileName != null)
+            this.fileName = fileName
+        this.eTag = eTag
+        this.scheduleTag = scheduleTag
+    }
+
+    override fun updateFlags(flags: Int) {
+        this.flags = flags
+    }
+
+    override fun add(): Uri {
+        TODO("Not yet implemented")
+    }
+
+    override fun update(data: Any): Uri {
+        TODO("Not yet implemented")
+    }
+
+    override fun delete(): Int {
+        TODO("Not yet implemented")
+    }
+
+}
@@ -0,0 +1,31 @@
+package at.bitfire.davdroid.syncadapter
+
+import android.os.Bundle
+import androidx.test.filters.SmallTest
+import at.bitfire.davdroid.syncadapter.SyncAdapterService.SyncAdapter
+import org.junit.Assert.assertArrayEquals
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class SyncAdapterServiceTest {
+
+    @Test
+    @SmallTest
+    fun testPriorityCollections() {
+        val extras = Bundle()
+        assertTrue(SyncAdapter.priorityCollections(extras).isEmpty())
+
+        extras.putString(SyncAdapterService.SYNC_EXTRAS_PRIORITY_COLLECTIONS, "")
+        assertTrue(SyncAdapter.priorityCollections(extras).isEmpty())
+
+        extras.putString(SyncAdapterService.SYNC_EXTRAS_PRIORITY_COLLECTIONS, "123")
+        assertArrayEquals(longArrayOf(123), SyncAdapter.priorityCollections(extras).toLongArray())
+
+        extras.putString(SyncAdapterService.SYNC_EXTRAS_PRIORITY_COLLECTIONS, ",x,")
+        assertTrue(SyncAdapter.priorityCollections(extras).isEmpty())
+
+        extras.putString(SyncAdapterService.SYNC_EXTRAS_PRIORITY_COLLECTIONS, "1,2,3")
+        assertArrayEquals(longArrayOf(1,2,3), SyncAdapter.priorityCollections(extras).toLongArray())
+    }
+
+}
@@ -0,0 +1,437 @@
+package at.bitfire.davdroid.syncadapter
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.SyncResult
+import android.os.Bundle
+import androidx.core.app.NotificationManagerCompat
+import androidx.test.platform.app.InstrumentationRegistry
+import at.bitfire.dav4jvm.PropStat
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.Response.HrefRelation
+import at.bitfire.dav4jvm.property.GetETag
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.model.Credentials
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.settings.AccountSettings
+import okhttp3.Protocol
+import okhttp3.internal.http.StatusLine
+import okhttp3.mockwebserver.MockResponse
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.*
+import org.junit.Assert.*
+import java.util.concurrent.TimeUnit
+
+class SyncManagerTest {
+
+    companion object {
+
+        val context = InstrumentationRegistry.getInstrumentation().targetContext
+        val account = Account("SyncManagerTest", context.getString(R.string.account_type))
+
+        @BeforeClass
+        @JvmStatic
+        fun createAccount() {
+            assertTrue(AccountManager.get(context).addAccountExplicitly(account, "test", AccountSettings.initialUserData(Credentials("test", "test"))))
+        }
+
+        @AfterClass
+        @JvmStatic
+        fun removeAccount() {
+            assertTrue(AccountManager.get(context).removeAccount(account, null, null).getResult(10, TimeUnit.SECONDS))
+
+            // clear annoying syncError notifications
+            NotificationManagerCompat.from(context).cancelAll()
+        }
+
+    }
+
+    val server = MockWebServer()
+
+    private fun syncManager(collection: LocalTestCollection) =
+            TestSyncManager(
+                    context,
+                    account,
+                    Bundle(),
+                    "TestAuthority",
+                    SyncResult(),
+                    collection,
+                    server
+            )
+
+    @Before
+    fun startServer() {
+        server.start()
+    }
+
+    @After
+    fun stopServer() {
+        server.close()
+    }
+
+
+    private fun queryCapabilitiesResponse(cTag: String? = null): MockResponse {
+        val body = StringBuilder()
+        body.append("<?xml version=\"1.0\" encoding=\"utf-8\" ?>\n" +
+                "<multistatus xmlns=\"DAV:\" xmlns:CALDAV=\"http://calendarserver.org/ns/\">\n" +
+                "  <response>\n" +
+                "    <href>/</href>\n" +
+                "    <propstat>\n" +
+                "      <prop>\n")
+        if (cTag != null)
+                body.append("<CALDAV:getctag>$cTag</CALDAV:getctag>\n")
+        body.append(
+                "      </prop>\n" +
+                "    </propstat>\n" +
+                "  </response>\n" +
+                "</multistatus>")
+        val response = MockResponse()
+                .setResponseCode(207)
+                .setHeader("Content-Type", "text/xml")
+                .setBody(body.toString())
+        return response
+    }
+
+    @Test
+    fun testPerformSync_FirstSync_Empty() {
+        val collection = LocalTestCollection() /* no last known ctag */
+        server.enqueue(queryCapabilitiesResponse())
+
+        val syncManager = syncManager(collection)
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertTrue(collection.entries.isEmpty())
+    }
+
+    @Test
+    fun testPerformSync_UploadNewMember_ETagOnPut() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 204 No Content
+        server.enqueue(MockResponse()
+                .setResponseCode(204)
+                .setHeader("ETag", "etag-from-put"))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/generated-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"etag-from-put\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("etag-from-put", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_UploadModifiedMember_ETagOnPut() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "existing-file.txt"
+                eTag = "old-etag-like-on-server"
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 204 No Content
+        server.enqueue(MockResponse()
+                .setResponseCode(204)
+                .addHeader("ETag", "etag-from-put"))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/existing-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("etag-from-put")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/existing-file.txt"), "etag-from-put"))
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("etag-from-put", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_UploadModifiedMember_NoETagOnPut() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "existing-file.txt"
+                eTag = "old-etag-like-on-server"
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 204 No Content
+        server.enqueue(MockResponse().setResponseCode(204))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/existing-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("etag-from-propfind")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/existing-file.txt"), "etag-from-propfind"))
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("etag-from-propfind", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_UploadModifiedMember_412PreconditionFailed() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "existing-file.txt"
+                eTag = "etag-that-has-been-changed-on-server-in-the-meanwhile"
+                dirty = true
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        // PUT -> 412 Precondition Failed
+        server.enqueue(MockResponse()
+                .setResponseCode(412))
+
+        // modifications sent, so DAVx5 will query CTag again
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/existing-file.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("changed-etag-from-server")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/existing-file.txt"), "changed-etag-from-server"))
+        }
+        syncManager.performSync()
+
+        assertTrue(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("changed-etag-from-server", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_NoopOnMemberWithSameETag() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "ctag1")
+            entries += LocalTestResource().apply {
+                fileName = "downloaded-member.txt"
+                eTag = "MemberETag1"
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag2"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/downloaded-member.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"MemberETag1\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+        }
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("MemberETag1", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_DownloadNewMember() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+        }
+        server.enqueue(queryCapabilitiesResponse(cTag = "new-ctag"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/new-member.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"NewMemberETag1\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                    )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/new-member.txt"), "NewMemberETag1"))
+        }
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("NewMemberETag1", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_DownloadUpdatedMember() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "downloaded-member.txt"
+                eTag = "MemberETag1"
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse(cTag = "new-ctag"))
+
+        val syncManager = syncManager(collection).apply {
+            listAllRemoteResult = listOf(
+                    Pair(Response(
+                            server.url("/"),
+                            server.url("/downloaded-member.txt"),
+                            null,
+                            listOf(PropStat(
+                                    listOf(
+                                            GetETag("\"MemberETag2\"")
+                                    ),
+                                    StatusLine(Protocol.HTTP_1_1, 200, "OK")
+                            )
+                            )), HrefRelation.MEMBER)
+            )
+
+            assertDownloadRemote = mapOf(Pair(server.url("/downloaded-member.txt"), "MemberETag2"))
+        }
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertTrue(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertEquals(1, collection.entries.size)
+        assertEquals("MemberETag2", collection.entries.first().eTag)
+    }
+
+    @Test
+    fun testPerformSync_RemoveVanishedMember() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "old-ctag")
+            entries += LocalTestResource().apply {
+                fileName = "downloaded-member.txt"
+            }
+        }
+        server.enqueue(queryCapabilitiesResponse(cTag = "new-ctag"))
+
+        val syncManager = syncManager(collection)
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertTrue(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertTrue(collection.entries.isEmpty())
+    }
+
+    @Test
+    fun testPerformSync_CTagDidntChange() {
+        val collection = LocalTestCollection().apply {
+            lastSyncState = SyncState(SyncState.Type.CTAG, "ctag1")
+        }
+        server.enqueue(queryCapabilitiesResponse("ctag1"))
+
+        val syncManager = syncManager(collection)
+        syncManager.performSync()
+
+        assertFalse(syncManager.didGenerateUpload)
+        assertFalse(syncManager.didListAllRemote)
+        assertFalse(syncManager.didDownloadRemote)
+        assertFalse(syncManager.syncResult.hasError())
+        assertTrue(collection.entries.isEmpty())
+    }
+
+}
@@ -0,0 +1,100 @@
+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.DavCollection
+import at.bitfire.dav4jvm.DavResponseCallback
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.property.GetCTag
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.resource.LocalResource
+import at.bitfire.davdroid.settings.AccountSettings
+import okhttp3.HttpUrl
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import okhttp3.mockwebserver.MockWebServer
+import org.junit.Assert.assertEquals
+
+class TestSyncManager(
+        context: Context,
+        account: Account,
+        extras: Bundle,
+        authority: String,
+        syncResult: SyncResult,
+        localCollection: LocalTestCollection,
+        val mockWebServer: MockWebServer
+): SyncManager<LocalTestResource, LocalTestCollection, DavCollection>(context, account, AccountSettings(context, account), extras, authority, syncResult, localCollection) {
+
+    override fun prepare(): Boolean {
+        collectionURL = mockWebServer.url("/")
+        davCollection = DavCollection(httpClient.okHttpClient, collectionURL)
+        return true
+    }
+
+    var didQueryCapabilities = false
+    override fun queryCapabilities(): SyncState? {
+        if (didQueryCapabilities)
+            throw IllegalStateException("queryCapabilities() must not be called twice")
+        didQueryCapabilities = true
+
+        var cTag: SyncState? = null
+        davCollection.propfind(0, GetCTag.NAME) { response, rel ->
+            if (rel == Response.HrefRelation.SELF)
+                response[GetCTag::class.java]?.cTag?.let {
+                    cTag = SyncState(SyncState.Type.CTAG, it)
+                }
+        }
+
+        return cTag
+    }
+
+    var didGenerateUpload = false
+    override fun generateUpload(resource: LocalTestResource): RequestBody {
+        didGenerateUpload = true
+        return resource.toString().toRequestBody()
+    }
+
+    override fun syncAlgorithm() = SyncAlgorithm.PROPFIND_REPORT
+
+    var listAllRemoteResult = emptyList<Pair<Response, Response.HrefRelation>>()
+    var didListAllRemote = false
+    override fun listAllRemote(callback: DavResponseCallback) {
+        if (didListAllRemote)
+            throw IllegalStateException("listAllRemote() must not be called twice")
+        didListAllRemote = true
+        for (result in listAllRemoteResult)
+            callback(result.first, result.second)
+    }
+
+    var assertDownloadRemote = emptyMap<HttpUrl, String>()
+    var didDownloadRemote = false
+    override fun downloadRemote(bunch: List<HttpUrl>) {
+        didDownloadRemote = true
+        assertEquals(assertDownloadRemote.keys.toList(), bunch)
+
+        for ((url, eTag) in assertDownloadRemote) {
+            val fileName = DavUtils.lastSegmentOfUrl(url)
+            var localEntry = localCollection.entries.filter { it.fileName == fileName }.firstOrNull()
+            if (localEntry == null) {
+                val newEntry = LocalTestResource().also {
+                    it.fileName = fileName
+                }
+                localCollection.entries += newEntry
+                localEntry = newEntry
+            }
+            localEntry.eTag = eTag
+            localEntry.flags = LocalResource.FLAG_REMOTELY_PRESENT
+        }
+    }
+
+    override fun postProcess() {
+    }
+
+    override fun notifyInvalidResourceTitle(): String {
+        TODO("Not yet implemented")
+    }
+
+}
@@ -0,0 +1,205 @@
+package at.bitfire.davdroid.ui
+
+import android.view.Gravity
+import android.view.View
+import android.view.ViewGroup
+import androidx.test.espresso.*
+import androidx.test.espresso.Espresso.onView
+import androidx.test.espresso.action.ViewActions
+import androidx.test.espresso.action.ViewActions.click
+import androidx.test.espresso.action.ViewActions.typeText
+import androidx.test.espresso.assertion.ViewAssertions.matches
+import androidx.test.espresso.contrib.DrawerActions
+import androidx.test.espresso.contrib.DrawerMatchers.isClosed
+import androidx.test.espresso.matcher.ViewMatchers.*
+import androidx.test.espresso.util.HumanReadables
+import androidx.test.espresso.util.TreeIterables
+import androidx.test.ext.junit.rules.activityScenarioRule
+import androidx.test.filters.LargeTest
+import at.bitfire.davdroid.R
+import org.hamcrest.Description
+import org.hamcrest.Matcher
+import org.hamcrest.Matchers
+import org.hamcrest.TypeSafeMatcher
+import org.junit.Rule
+import org.junit.Test
+import java.util.concurrent.TimeoutException
+
+@LargeTest
+class AccountsActivityEspressoTest {
+
+    @get:Rule
+    val activityScenarioRule = activityScenarioRule<AccountsActivity>()
+
+    private val username = "test"
+    private val password = "test"
+    private val baseUrl = "https://davtest.dev001.net/radicale/htpasswd/"
+
+
+    @Test
+    fun accountsActivityTest() {
+        skipIntroActivity()
+
+        onView(withId(R.id.fab)).perform(click())
+
+        // open first the option for Login with Base URL and then enter the test-data and confirm
+        onView(withText(R.string.login_type_url)).perform(click())
+        onView(withId(R.id.loginUrlBaseUrlEdittext)).perform(typeText(baseUrl), ViewActions.closeSoftKeyboard())
+        onView(withId(R.id.loginUrlUsernameEdittext)).perform(typeText(username), ViewActions.closeSoftKeyboard())
+        onView(withId(R.id.loginUrlPasswordEdittext)).perform(typeText(password), ViewActions.closeSoftKeyboard())
+        onView(withId(R.id.login)).perform(click())
+
+        // The detect configuration screen (detect_configuration.xml) is not asserted here, it's just skipped.
+        // login_account_details.xml is the next expected fragment, check if the expected headline appears and then click on the "Create Account" button
+        onView(isRoot()).perform(waitForView(R.id.accountName, 30000))
+
+        onView(withText(R.string.login_account_name_info)).check(matches(isDisplayed()))
+        onView(withId(R.id.create_account)).perform(click())
+
+        Thread.sleep(1000)
+
+        // check if the "test" calendar appeared
+        onView(isRoot()).perform(waitForView(R.id.title, 5000))
+        //onView(withId(R.id.title)).perform(waitForText("Test Addressbook", 30000))
+        onView(withText("Test Addressbook")).check(matches(withText("Test Addressbook")))
+
+        // Go back to the overview with all Accounts
+        Espresso.pressBack()
+        //Thread.sleep(2000)
+
+        // check if the account exists and click on it
+        onView(isRoot()).perform(waitForView((R.id.account_name), 5000))
+        onView(withText("test")).check(matches(withText("test")))
+        onView(withText("test")).perform(click())
+
+        // open the overflowMenu to delete the account
+        val overflowMenuButton = onView(
+                Matchers.allOf(withContentDescription("More options"),
+                        childAtPosition(
+                                childAtPosition(
+                                        withId(R.id.toolbar),
+                                        2),
+                                1),
+                        isDisplayed()))
+        overflowMenuButton.perform(click())
+
+        // click on the delete button
+        onView(withText(R.string.account_delete)).perform(click())
+        onView(withText(R.string.account_delete_confirmation_title)).check(matches(isDisplayed()))
+        // confirm deletion by clicking on YES
+        onView(withId(android.R.id.button1)).perform(click())
+
+        // doublecheck to make sure that the account doesn't exist anymore. The welcome text is displayed
+        onView(withText(R.string.account_list_empty)).check(matches(withText(R.string.account_list_empty)))
+    }
+
+    @Test
+    fun menuDrawerTest() {
+        skipIntroActivity()
+
+        // TESTING ABOUT DIALOG
+        // Open Drawer to click on navigation.
+        onView(withId(R.id.drawer_layout))
+                .check(matches(isClosed(Gravity.LEFT))) // Left Drawer should be closed.
+                .perform(DrawerActions.open()) // Open Drawer
+        // check if about can be opened
+        onView(withText(R.string.navigation_drawer_about)).perform(click())
+        onView(withText(R.string.about_copyright)).check(matches(isDisplayed()))
+        Espresso.pressBack()
+
+        // TESTING SETTINGS DIALOG
+        // Open Drawer to click on navigation.
+        onView(withId(R.id.drawer_layout))
+                .check(matches(isClosed(Gravity.LEFT))) // Left Drawer should be closed.
+                .perform(DrawerActions.open()) // Open Drawer
+        // check if about can be opened
+        onView(withText(R.string.navigation_drawer_settings)).perform(click())
+        onView(withText(R.string.app_settings_show_debug_info)).check(matches(isDisplayed()))
+        Espresso.pressBack()
+
+        // TESTING WEBSITE MENU ENTRY
+        // Open Drawer to click on navigation.
+        onView(withId(R.id.drawer_layout))
+                .check(matches(isClosed(Gravity.LEFT))) // Left Drawer should be closed.
+                .perform(DrawerActions.open()) // Open Drawer
+        // check if Website can be opened
+        //onView(withText(R.string.navigation_drawer_website)).perform(click())
+    }
+
+
+    private fun childAtPosition(
+            parentMatcher: Matcher<View>, position: Int): Matcher<View> {
+
+        return object : TypeSafeMatcher<View>() {
+            override fun describeTo(description: Description) {
+                description.appendText("Child at position $position in parent ")
+                parentMatcher.describeTo(description)
+            }
+
+            public override fun matchesSafely(view: View): Boolean {
+                val parent = view.parent
+                return parent is ViewGroup && parentMatcher.matches(parent)
+                        && view == parent.getChildAt(position)
+            }
+        }
+    }
+
+    private fun skipIntroActivity() {
+        try {
+            onView(withId(R.id.takeControl)).check(matches(withText(R.string.intro_slogan2)))   // intro_welcome is the first fragment, check first if the String Resource "intro_slogan2" is shown.
+            // click through up to 5 intro fragments
+            for (i in 1..5)
+                try {
+                    onView(withId(R.id.next)).perform(click())
+                } catch (ignored: Exception) { }
+            onView(withId(R.id.done)).perform(click())
+        } catch (ignored: NoMatchingViewException) {
+            // the IntroActivity or some fragments of it may not show up every time
+        }
+        onView(withText(R.string.account_list_empty)).check(matches(isDisplayed()))
+    }
+
+    /**
+     * This ViewAction tells espresso to wait till a certain view is found in the view hierarchy.
+     * Source: https://www.repeato.app/espresso-wait-for-view/
+     * @param viewId The id of the view to wait for.
+     * @param timeout The maximum time which espresso will wait for the view to show up (in milliseconds)
+     */
+    private fun waitForView(viewId: Int, timeout: Long): ViewAction {
+        return object : ViewAction {
+            override fun getConstraints(): Matcher<View> {
+                return isRoot()
+            }
+
+            override fun getDescription(): String {
+                return "wait for a specific view with id $viewId; during $timeout millis."
+            }
+
+            override fun perform(uiController: UiController, rootView: View) {
+                uiController.loopMainThreadUntilIdle()
+                val startTime = System.currentTimeMillis()
+                val endTime = startTime + timeout
+                val viewMatcher = withId(viewId)
+
+                do {
+                    // Iterate through all views on the screen and see if the view we are looking for is there already
+                    for (child in TreeIterables.breadthFirstViewTraversal(rootView)) {
+                        // found view with required ID
+                        if (viewMatcher.matches(child)) {
+                            return
+                        }
+                    }
+                    // Loops the main thread for a specified period of time.
+                    // Control may not return immediately, instead it'll return after the provided delay has passed and the queue is in an idle state again.
+                    uiController.loopMainThreadForAtLeast(100)
+                } while (System.currentTimeMillis() < endTime) // in case of a timeout we throw an exception -&gt; test fails
+                throw PerformException.Builder()
+                        .withCause(TimeoutException())
+                        .withActionDescription(this.description)
+                        .withViewDescription(HumanReadables.describe(rootView))
+                        .build()
+            }
+        }
+    }
+
+}
@@ -0,0 +1,208 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid.ui.setup
+
+import 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.*
+import org.junit.Before
+import org.junit.Test
+import java.net.URI
+
+class DavResourceFinderTest {
+
+    companion object {
+        private const val PATH_NO_DAV = "/nodav"
+        private const val PATH_CALDAV = "/caldav"
+        private const val PATH_CARDDAV = "/carddav"
+        private const val PATH_CALDAV_AND_CARDDAV = "/both-caldav-carddav"
+
+        private const val SUBPATH_PRINCIPAL = "/principal"
+        private const val SUBPATH_ADDRESSBOOK_HOMESET = "/addressbooks"
+        private const val SUBPATH_ADDRESSBOOK = "/addressbooks/private-contacts"
+    }
+
+    val server = MockWebServer()
+
+    lateinit var finder: DavResourceFinder
+    lateinit var client: HttpClient
+    lateinit var loginModel: LoginModel
+
+    @Before
+    fun initServerAndClient() {
+        server.dispatcher = TestDispatcher()
+        server.start()
+
+        loginModel = LoginModel()
+        loginModel.baseURI = URI.create("/")
+        loginModel.credentials = Credentials("mock", "12345")
+
+        finder = DavResourceFinder(InstrumentationRegistry.getInstrumentation().targetContext, loginModel)
+        client = HttpClient.Builder()
+                .addAuthentication(null, loginModel.credentials!!)
+                .build()
+    }
+
+    @After
+    fun stopServer() {
+        server.shutdown()
+    }
+
+
+    @Test
+    @SmallTest
+    fun testRememberIfAddressBookOrHomeset() {
+        // recognize home set
+        var info = ServiceInfo()
+        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)
+        assertEquals(server.url("$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET/"), info.homeSets.first())
+
+        // recognize address book
+        info = ServiceInfo()
+        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())
+        assertEquals(0, info.homeSets.size)
+    }
+
+    @Test
+    fun testProvidesService() {
+        assertFalse(finder.providesService(server.url(PATH_NO_DAV), DavResourceFinder.Service.CALDAV))
+        assertFalse(finder.providesService(server.url(PATH_NO_DAV), DavResourceFinder.Service.CARDDAV))
+
+        assertTrue(finder.providesService(server.url(PATH_CALDAV), DavResourceFinder.Service.CALDAV))
+        assertFalse(finder.providesService(server.url(PATH_CALDAV), DavResourceFinder.Service.CARDDAV))
+
+        assertTrue(finder.providesService(server.url(PATH_CARDDAV), DavResourceFinder.Service.CARDDAV))
+        assertFalse(finder.providesService(server.url(PATH_CARDDAV), DavResourceFinder.Service.CALDAV))
+
+        assertTrue(finder.providesService(server.url(PATH_CALDAV_AND_CARDDAV), DavResourceFinder.Service.CALDAV))
+        assertTrue(finder.providesService(server.url(PATH_CALDAV_AND_CARDDAV), DavResourceFinder.Service.CARDDAV))
+    }
+
+    @Test
+    fun testGetCurrentUserPrincipal() {
+        assertNull(finder.getCurrentUserPrincipal(server.url(PATH_NO_DAV), DavResourceFinder.Service.CALDAV))
+        assertNull(finder.getCurrentUserPrincipal(server.url(PATH_NO_DAV), DavResourceFinder.Service.CARDDAV))
+
+        assertEquals(
+                server.url(PATH_CALDAV + SUBPATH_PRINCIPAL),
+                finder.getCurrentUserPrincipal(server.url(PATH_CALDAV), DavResourceFinder.Service.CALDAV)
+        )
+        assertNull(finder.getCurrentUserPrincipal(server.url(PATH_CALDAV), DavResourceFinder.Service.CARDDAV))
+
+        assertEquals(
+                server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL),
+                finder.getCurrentUserPrincipal(server.url(PATH_CARDDAV), DavResourceFinder.Service.CARDDAV)
+        )
+        assertNull(finder.getCurrentUserPrincipal(server.url(PATH_CARDDAV), DavResourceFinder.Service.CALDAV))
+    }
+
+    @Test
+    fun testQueryEmailAddress() {
+        var info = ServiceInfo()
+        assertArrayEquals(
+                arrayOf("email1@example.com", "email2@example.com"),
+                finder.queryEmailAddress(server.url(PATH_CALDAV + SUBPATH_PRINCIPAL)).toTypedArray()
+        )
+        assertTrue(finder.queryEmailAddress(server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL)).isEmpty())
+    }
+
+
+    // mock server
+
+    class TestDispatcher: Dispatcher() {
+
+        override fun dispatch(request: RecordedRequest): MockResponse {
+            if (!checkAuth(request)) {
+                val authenticate = MockResponse().setResponseCode(401)
+                authenticate.setHeader("WWW-Authenticate", "Basic realm=\"test\"")
+                return authenticate
+            }
+
+            val path = request.path!!
+
+            if (request.method.equals("OPTIONS", true)) {
+                val dav = when {
+                    path.startsWith(PATH_CALDAV) -> "calendar-access"
+                    path.startsWith(PATH_CARDDAV) -> "addressbook"
+                    path.startsWith(PATH_CALDAV_AND_CARDDAV) -> "calendar-access, addressbook"
+                    else -> null
+                }
+                val response = MockResponse().setResponseCode(200)
+                if (dav != null)
+                    response.addHeader("DAV", dav)
+                return response
+            } else if (request.method.equals("PROPFIND", true)) {
+                val props: String?
+                when (path) {
+                    PATH_CALDAV,
+                    PATH_CARDDAV ->
+                        props = "<current-user-principal><href>$path$SUBPATH_PRINCIPAL</href></current-user-principal>"
+
+                    PATH_CARDDAV + SUBPATH_PRINCIPAL ->
+                        props = "<CARD:addressbook-home-set>" +
+                                "   <href>$PATH_CARDDAV$SUBPATH_ADDRESSBOOK_HOMESET</href>" +
+                                "</CARD:addressbook-home-set>"
+
+                    PATH_CARDDAV + SUBPATH_ADDRESSBOOK ->
+                        props = "<resourcetype>" +
+                                "   <collection/>" +
+                                "   <CARD:addressbook/>" +
+                                "</resourcetype>"
+
+                    PATH_CALDAV + SUBPATH_PRINCIPAL ->
+                        props = "<CAL:calendar-user-address-set>" +
+                                "  <href>urn:unknown-entry</href>" +
+                                "  <href>mailto:email1@example.com</href>" +
+                                "  <href>mailto:email2@example.com</href>" +
+                                "</CAL:calendar-user-address-set>"
+
+                    else -> props = null
+                }
+                Logger.log.info("Sending props: $props")
+                return MockResponse()
+                        .setResponseCode(207)
+                        .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav' xmlns:CAL='urn:ietf:params:xml:ns:caldav'>" +
+                                "<response>" +
+                                "   <href>${request.path}</href>" +
+                                "   <propstat><prop>$props</prop></propstat>" +
+                                "</response>" +
+                                "</multistatus>")
+            }
+
+            return MockResponse().setResponseCode(404)
+        }
+
+        private fun checkAuth(rq: RecordedRequest) =
+            rq.getHeader("Authorization") == "Basic bW9jazoxMjM0NQ=="
+
+    }
+
+}
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright (c) Ricki Hirner (bitfire web engineering).
+  ~ All rights reserved. This program and the accompanying materials
+  ~ are made available under the terms of the GNU Public License v3.0
+  ~ which accompanies this distribution, and is available at
+  ~ http://www.gnu.org/licenses/gpl.html
+  -->
+
+<resources>
+
+    <string name="app_name">Davx5Test</string>
+
+</resources>
@@ -0,0 +1,3 @@
+<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
+    android:accountType="at.bitfire.davdroid.SyncManagerTest"
+    android:label="Test Account" />
@@ -0,0 +1,272 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest package="at.bitfire.davdroid"
+          xmlns:android="http://schemas.android.com/apk/res/android"
+          xmlns:tools="http://schemas.android.com/tools"
+          android:installLocation="internalOnly">
+
+    <!-- normal permissions -->
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE"/>
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.READ_SYNC_STATS"/>
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED"/>
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
+
+    <!-- account management permissions not required for own accounts since API level 22 -->
+    <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"/>
+
+    <!-- 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 -->
+    <!-- getting the WiFi name (for "sync in Wifi only") requires
+      - coarse location (Android 8.1)
+      - fine location (Android 10) -->
+    <uses-permission-sdk-23 android:name="android.permission.ACCESS_COARSE_LOCATION"/>
+    <uses-permission-sdk-23 android:name="android.permission.ACCESS_FINE_LOCATION"/>
+    <!-- required since Android 10 to get the WiFi name while in background (= while syncing) -->
+    <uses-permission-sdk-23 android:name="android.permission.ACCESS_BACKGROUND_LOCATION"/>
+
+    <!-- ical4android declares task access permissions -->
+
+    <application
+        android:name=".App"
+        android:allowBackup="false"
+        android:networkSecurityConfig="@xml/network_security_config"
+        android:icon="@mipmap/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme"
+        android:resizeableActivity="true"
+        tools:ignore="UnusedAttribute"
+        android:supportsRtl="true">
+
+        <service android:name=".DavService"/>
+        <service android:name=".ForegroundService"/>
+
+        <activity android:name=".ui.intro.IntroActivity" android:theme="@style/AppTheme.NoActionBar" />
+        <activity
+            android:name=".ui.AccountsActivity"
+            android:label="@string/app_name"
+            android:theme="@style/AppTheme.NoActionBar">
+            <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">
+            <intent-filter>
+                <action android:name="android.intent.action.APPLICATION_PREFERENCES"/>
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".ui.DebugInfoActivity"
+            android:parentActivityName=".ui.AppSettingsActivity"
+            android:exported="true"
+            android:label="@string/debug_info_title">
+            <intent-filter>
+                <action android:name="android.intent.action.BUG_REPORT"/>
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".ui.PermissionsActivity"
+            android:label="@string/app_settings_security_app_permissions"
+            android:parentActivityName=".ui.AppSettingsActivity" />
+        <activity
+            android:name=".ui.TasksActivity"
+            android:label="@string/intro_tasks_title"
+            android:parentActivityName=".ui.AppSettingsActivity" />
+
+        <activity
+            android:name=".ui.setup.LoginActivity"
+            android:label="@string/login_title"
+            android:parentActivityName=".ui.AccountsActivity">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN"/>
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".ui.account.AccountActivity"
+            android:parentActivityName=".ui.AccountsActivity"
+            android:theme="@style/AppTheme.NoActionBar"/>
+        <activity
+            android:name=".ui.account.CreateAddressBookActivity"
+            android:label="@string/create_addressbook"
+            android:parentActivityName=".ui.account.AccountActivity" />
+        <activity
+            android:name=".ui.account.CreateCalendarActivity"
+            android:label="@string/create_calendar"
+            android:parentActivityName=".ui.account.AccountActivity" />
+        <activity
+            android:name=".ui.account.SettingsActivity"
+            android:parentActivityName=".ui.account.AccountActivity" />
+        <activity
+            android:name=".ui.account.WifiPermissionsActivity"
+            android:label="@string/wifi_permissions_label"
+            android:parentActivityName=".ui.account.SettingsActivity" />
+
+        <!-- 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.OpenTasksSyncAdapterService"
+            android:exported="true"
+            tools:ignore="ExportedService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/sync_opentasks"/>
+        </service>
+        <service
+            android:name=".syncadapter.TasksOrgSyncAdapterService"
+            android:exported="true"
+            tools:ignore="ExportedService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/sync_tasks_org"/>
+        </service>
+
+        <!-- account type "DAVx⁵ Address book" -->
+        <service
+            android:name=".syncadapter.NullAuthenticatorService"
+            android:exported="true">   <!-- Since Android 11, this must be true so that Google Contacts shows the address book accounts -->
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+
+            <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>
+
+        <receiver android:name=".BootCompletedReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
+        <!-- provider to share debug info/logs -->
+        <provider
+            android:name="androidx.core.content.FileProvider"
+            android:authorities="@string/authority_debug_provider"
+            android:grantUriPermissions="true"
+            android:exported="false">
+            <meta-data
+                android:name="android.support.FILE_PROVIDER_PATHS"
+                android:resource="@xml/debug_paths" />
+        </provider>
+
+    </application>
+
+    <!-- package visiblity – which apps do we need to see? -->
+    <queries>
+        <!-- task providers -->
+        <package android:name="org.dmfs.tasks" />
+        <package android:name="org.tasks" />
+
+        <!-- ICSx5 for Webcal feeds -->
+        <package android:name="at.bitfire.icsdroid"/>
+
+        <!-- apps that interact with contact, calendar, task data (for debug info) -->
+        <intent>
+            <action android:name="*" />
+            <data android:scheme="content" android:host="com.android.contacts" />
+        </intent>
+        <intent>
+            <action android:name="*" />
+            <data android:scheme="content" android:host="com.android.calendar" />
+        </intent>
+
+        <!-- Web browsers (to check whether a Web browser is installed before viewing a URL) -->
+        <intent>
+            <action android:name="android.intent.action.VIEW" />
+            <data android:scheme="https" />
+        </intent>
+
+        <!-- Custom Tabs support (e.g. Nextcloud Login Flow) -->
+        <intent>
+            <action android:name="android.support.customtabs.action.CustomTabsService" />
+        </intent>
+    </queries>
+
+</manifest>
@@ -0,0 +1,628 @@
+<h3 style="text-align: center;">GNU GENERAL PUBLIC LICENSE</h3>
+<p style="text-align: center;">Version 3, 29 June 2007</p>
+
+<p>Copyright &copy; 2007 Free Software Foundation, Inc.
+&lt;<a href="http://fsf.org/">http://fsf.org/</a>&gt;</p><p>
+Everyone is permitted to copy and distribute verbatim copies
+of this license document, but changing it is not allowed.</p>
+
+<h3><a name="preamble"></a>Preamble</h3>
+
+<p>The GNU General Public License is a free, copyleft license for
+software and other kinds of works.</p>
+
+<p>The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.</p>
+
+<p>When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.</p>
+
+<p>To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.</p>
+
+<p>For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.</p>
+
+<p>Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.</p>
+
+<p>For the developers\' and authors\' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users\' and
+authors\' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.</p>
+
+<p>Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users\' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.</p>
+
+<p>Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.</p>
+
+<p>The precise terms and conditions for copying, distribution and
+modification follow.</p>
+
+<h3><a name="terms"></a>TERMS AND CONDITIONS</h3>
+
+<h4><a name="section0"></a>0. Definitions.</h4>
+
+<p>&ldquo;This License&rdquo; refers to version 3 of the GNU General Public License.</p>
+
+<p>&ldquo;Copyright&rdquo; also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.</p>
+
+<p>&ldquo;The Program&rdquo; refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as &ldquo;you&rdquo;.  &ldquo;Licensees&rdquo; and
+&ldquo;recipients&rdquo; may be individuals or organizations.</p>
+
+<p>To &ldquo;modify&rdquo; a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a &ldquo;modified version&rdquo; of the
+earlier work or a work &ldquo;based on&rdquo; the earlier work.</p>
+
+<p>A &ldquo;covered work&rdquo; means either the unmodified Program or a work based
+on the Program.</p>
+
+<p>To &ldquo;propagate&rdquo; a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.</p>
+
+<p>To &ldquo;convey&rdquo; a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.</p>
+
+<p>An interactive user interface displays &ldquo;Appropriate Legal Notices&rdquo;
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.</p>
+
+<h4><a name="section1"></a>1. Source Code.</h4>
+
+<p>The &ldquo;source code&rdquo; for a work means the preferred form of the work
+for making modifications to it.  &ldquo;Object code&rdquo; means any non-source
+form of a work.</p>
+
+<p>A &ldquo;Standard Interface&rdquo; means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.</p>
+
+<p>The &ldquo;System Libraries&rdquo; of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+&ldquo;Major Component&rdquo;, in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.</p>
+
+<p>The &ldquo;Corresponding Source&rdquo; for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work\'s
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.</p>
+
+<p>The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.</p>
+
+<p>The Corresponding Source for a work in source code form is that
+same work.</p>
+
+<h4><a name="section2"></a>2. Basic Permissions.</h4>
+
+<p>All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.</p>
+
+<p>You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.</p>
+
+<p>Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.</p>
+
+<h4><a name="section3"></a>3. Protecting Users\' Legal Rights From Anti-Circumvention Law.</h4>
+
+<p>No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.</p>
+
+<p>When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work\'s
+users, your or third parties\' legal rights to forbid circumvention of
+technological measures.</p>
+
+<h4><a name="section4"></a>4. Conveying Verbatim Copies.</h4>
+
+<p>You may convey verbatim copies of the Program\'s source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.</p>
+
+<p>You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.</p>
+
+<h4><a name="section5"></a>5. Conveying Modified Source Versions.</h4>
+
+<p>You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:</p>
+
+<ul>
+<li>a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.</li>
+
+<li>b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    &ldquo;keep intact all notices&rdquo;.</li>
+
+<li>c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.</li>
+
+<li>d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.</li>
+</ul>
+
+<p>A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+&ldquo;aggregate&rdquo; if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation\'s users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.</p>
+
+<h4><a name="section6"></a>6. Conveying Non-Source Forms.</h4>
+
+<p>You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:</p>
+
+<ul>
+<li>a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.</li>
+
+<li>b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.</li>
+
+<li>c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.</li>
+
+<li>d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.</li>
+
+<li>e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.</li>
+</ul>
+
+<p>A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.</p>
+
+<p>A &ldquo;User Product&rdquo; is either (1) a &ldquo;consumer product&rdquo;, which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, &ldquo;normally used&rdquo; refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.</p>
+
+<p>&ldquo;Installation Information&rdquo; for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.</p>
+
+<p>If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).</p>
+
+<p>The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.</p>
+
+<p>Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.</p>
+
+<h4><a name="section7"></a>7. Additional Terms.</h4>
+
+<p>&ldquo;Additional permissions&rdquo; are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.</p>
+
+<p>When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.</p>
+
+<p>Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:</p>
+
+<ul>
+<li>a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or</li>
+
+<li>b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or</li>
+
+<li>c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or</li>
+
+<li>d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or</li>
+
+<li>e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or</li>
+
+<li>f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.</li>
+</ul>
+
+<p>All other non-permissive additional terms are considered &ldquo;further
+restrictions&rdquo; within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.</p>
+
+<p>If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.</p>
+
+<p>Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.</p>
+
+<h4><a name="section8"></a>8. Termination.</h4>
+
+<p>You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).</p>
+
+<p>However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.</p>
+
+<p>Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.</p>
+
+<p>Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.</p>
+
+<h4><a name="section9"></a>9. Acceptance Not Required for Having Copies.</h4>
+
+<p>You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.</p>
+
+<h4><a name="section10"></a>10. Automatic Licensing of Downstream Recipients.</h4>
+
+<p>Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.</p>
+
+<p>An &ldquo;entity transaction&rdquo; is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party\'s predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.</p>
+
+<p>You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.</p>
+
+<h4><a name="section11"></a>11. Patents.</h4>
+
+<p>A &ldquo;contributor&rdquo; is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor\'s &ldquo;contributor version&rdquo;.</p>
+
+<p>A contributor\'s &ldquo;essential patent claims&rdquo; are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, &ldquo;control&rdquo; includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.</p>
+
+<p>Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor\'s essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.</p>
+
+<p>In the following three paragraphs, a &ldquo;patent license&rdquo; is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To &ldquo;grant&rdquo; such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.</p>
+
+<p>If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  &ldquo;Knowingly relying&rdquo; means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient\'s use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.</p>
+
+<p>If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.</p>
+
+<p>A patent license is &ldquo;discriminatory&rdquo; if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.</p>
+
+<p>Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.</p>
+
+<h4><a name="section12"></a>12. No Surrender of Others\' Freedom.</h4>
+
+<p>If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.</p>
+
+<h4><a name="section13"></a>13. Use with the GNU Affero General Public License.</h4>
+
+<p>Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.</p>
+
+<h4><a name="section14"></a>14. Revised Versions of this License.</h4>
+
+<p>The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.</p>
+
+<p>Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License &ldquo;or any later version&rdquo; applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.</p>
+
+<p>If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy\'s
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.</p>
+
+<p>Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.</p>
+
+<h4><a name="section15"></a>15. Disclaimer of Warranty.</h4>
+
+<p>THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM &ldquo;AS IS&rdquo; WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.</p>
+
+<h4><a name="section16"></a>16. Limitation of Liability.</h4>
+
+<p>IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.</p>
+
+<h4><a name="section17"></a>17. Interpretation of Sections 15 and 16.</h4>
+
+<p>If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.</p>
+
+<p>END OF TERMS AND CONDITIONS</p>
@@ -0,0 +1,22 @@
+carddav.a1.net
+aol.com
+dav.edis.at
+dav.fruux.com
+caldav.gmx.net
+carddav.gmx.net
+icloud.com
+cloud.liberta.vip
+office.luckycloud.de
+calendar.mail.ru
+mailbox.org
+mailfence.com
+posteo.de:8443
+live.teambox.eu
+spica.t-online.de
+caldav.calendar.yahoo.com
+yandex.ru
+webmail.your-server.de/rpc.php/
+calendar.zoho.com
+calendar.zoho.eu
+contacts.zoho.com
+contacts.zoho.eu
@@ -0,0 +1 @@
+{"ar_SA":["abdunnasir"],"bg":["dpa_transifex","ma4ko"],"ca":["ettenmoors","hegocr_1709","jordibrus","Kintu","Solatec","zagur"],"cs":["Kryšpin","pavelb","tomas.odehnal"],"da":["knutztar","mjjzf","Tntdruid_","twikedk"],"de":["amandablue","anestiskaci","Atalanttore","corppneq","crit12","Gyges","hammaschlach","maxkl","nicolas_git","owncube","TheName","Waldmeisda","Wyrrrd","YvanM"],"el":["anestiskaci","diamond_gr","KristinaQejvanaj"],"es":["aluaces","Anoih","Ark74","Elhea","GranPC","jcvielma","oscfdezdz","plaguna","polkhas","sfouilleulb","xphnx"],"eu":["cockeredradiation","Osoitz","Thadah"],"fa":["ahangarha","amiraliakbari","javad.aboutorabi","joojoojoo","maryambehzi","mtashackori","Numb","taranehsaei"],"fi_FI":["raketti","tseipii"],"fr":["AlainR","alkino2","Amadeen","boutil","callmemagnus","chfo","chrcha","Floflr","grenatrad","jokx","Jorg722","JorisBodin","Llorc","LoiX07","mathieugfortin","Novick","paullbn","Poussinou","RomainTT","Synochy","Thecross","unareil","vincen","YvanM","ÉricB."],"fr_FR":["chrcha","Llorc","Poussinou","sfouilleulb"],"gl":["aluaces","pikamoku"],"hr":["tomiis"],"hr_HR":["tomiis"],"hu":["infeeeee","jtg","meskobalazs","Roshek","sfouilleulb"],"it":["Damtux","ed0","FranzMari","lzambarda","malaerba","noccio","nwandy","rickyroo","sfouilleulb","technezio"],"it_IT":["malaerba"],"ja":["Naofumi","yanorei32"],"nb_NO":["elonus"],"nl":["davtemp","dehart","erikhubers","frankyboy1963","glotzbach","toonvangerwen","XtremeNova"],"pl":["gsz","M4SK1N","mg6","oskarjakiela","TheName","TORminator","Valdnet"],"pt":["amalvarenga","wanderlei.huttel"],"pt_BR":["wanderlei.huttel"],"ru":["aigoshin","anm","ashed","astalavister","nick.savin","vaddd"],"sk_SK":["brango67","tiborepcek"],"sl_SI":["MrLaaky","uroszor"],"sr":["daimonion"],"sv":["campbelldavid","Mikaelb"],"szl":["chlodny"],"tr_TR":["ooguz","pultars"],"uk":["androsua","olexn","twixi007"],"uk_UA":["astalavister"],"vi":["bruhwut"],"zh_CN":["anolir","jxj2zzz79pfp9bpo","leoniscsem","linuxbckp","mofitt2016","oksjd","phy","spice2wolf"],"zh_TW":["linuxbckp","mofitt2016","phy","waiabsfabuloushk"]}
@@ -0,0 +1,29 @@
+package at.bitfire.davdroid
+
+import android.content.Context
+
+abstract class AndroidSingleton<T> {
+
+    var creatingSingleton = false
+    var singleton: T? = null
+
+    @Synchronized
+    fun getInstance(context: Context): T {
+        singleton?.let {
+            return it
+        }
+
+        if (creatingSingleton)
+            throw IllegalStateException("AndroidSingleton::getInstance() must not be called while createInstance()")
+        creatingSingleton = true
+
+        val newSingleton = createInstance(context.applicationContext)
+        singleton = newSingleton
+
+        creatingSingleton = false
+        return newSingleton
+    }
+
+    protected abstract fun createInstance(context: Context): T
+
+}
@@ -0,0 +1,99 @@
+/*
+ * 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.net.Uri
+import android.os.StrictMode
+import androidx.appcompat.content.res.AppCompatResources
+import androidx.core.graphics.drawable.toBitmap
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import at.bitfire.davdroid.ui.UiUtils
+import java.util.logging.Level
+import kotlin.concurrent.thread
+import kotlin.system.exitProcess
+
+@Suppress("unused")
+class App: Application(), Thread.UncaughtExceptionHandler {
+
+    companion object {
+
+        fun getLauncherBitmap(context: Context) =
+                AppCompatResources.getDrawable(context, R.mipmap.ic_launcher)?.toBitmap()
+
+        fun homepageUrl(context: Context) =
+                Uri.parse(context.getString(R.string.homepage_url)).buildUpon()
+                        .appendQueryParameter("pk_campaign", BuildConfig.APPLICATION_ID)
+                        .appendQueryParameter("pk_kwd", context::class.java.simpleName)
+                        .appendQueryParameter("app-version", BuildConfig.VERSION_NAME)
+                        .build()!!
+
+    }
+
+
+    override fun onCreate() {
+        super.onCreate()
+        Logger.initialize(this)
+
+        if (BuildConfig.DEBUG)
+            // debug builds
+            StrictMode.setVmPolicy(StrictMode.VmPolicy.Builder()
+                    .detectActivityLeaks()
+                    .detectFileUriExposure()
+                    .detectLeakedClosableObjects()
+                    .detectLeakedRegistrationObjects()
+                    .detectLeakedSqlLiteObjects()
+                    .penaltyLog()
+                    .build())
+        else // if (BuildConfig.FLAVOR == FLAVOR_STANDARD)
+            // handle uncaught exceptions in non-debug standard flavor
+            Thread.setDefaultUncaughtExceptionHandler(this)
+
+        NotificationUtils.createChannels(this)
+
+        // set light/dark mode
+        UiUtils.setTheme(this)      // when this is called in the asynchronous thread below, it recreates
+                                    // some current activity and causes an IllegalStateException in rare cases
+
+        // don't block UI for some background checks
+        thread {
+            // create/update app shortcuts
+            UiUtils.updateShortcuts(this)
+
+            // watch installed/removed apps
+            TasksWatcher(this)
+
+            // check whether a tasks app is currently installed
+            TasksWatcher.updateTaskSync(this)
+
+            // check/repair sync intervals
+            AccountSettings.repairSyncIntervals(this)
+
+            // foreground service (possible workaround for devices which prevent DAVx5 from being started)
+            ForegroundService.startIfEnabled(this)
+        }
+    }
+
+    override fun uncaughtException(t: Thread, e: Throwable) {
+        Logger.log.log(Level.SEVERE, "Unhandled exception!", e)
+
+        val intent = Intent(this, DebugInfoActivity::class.java)
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        intent.putExtra(DebugInfoActivity.EXTRA_CAUSE, e)
+        startActivity(intent)
+
+        exitProcess(1)
+    }
+
+}
@@ -0,0 +1,22 @@
+package at.bitfire.davdroid
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import at.bitfire.davdroid.log.Logger
+
+/**
+ * There are circumstances when Android drops automatic sync of accounts and resets them
+ * to manual synchronization, for instance when the device is booted into safe mode.
+ *
+ * This receiver causes the app to be started when the device is rebooted. When the app
+ * is started, it checks (and repairs, if necessary) the sync intervals in [App.onCreate].
+ */
+class BootCompletedReceiver: BroadcastReceiver() {
+
+    override fun onReceive(context: Context, intent: Intent) {
+        Logger.log.info("Device has been rebooted; checking sync intervals etc.")
+        // sync intervals are checked in App.onCreate()
+    }
+
+}
@@ -0,0 +1,12 @@
+package at.bitfire.davdroid
+
+import android.content.ContentProviderClient
+import android.os.Build
+
+@Suppress("DEPRECATION")
+fun ContentProviderClient.closeCompat() {
+    if (Build.VERSION.SDK_INT >= 24)
+        close()
+    else
+        release()
+}
@@ -0,0 +1,28 @@
+/*
+ * 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()
+
+    /**
+     * 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"
+
+}
@@ -0,0 +1,406 @@
+/*
+ * 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.IntentService
+import android.app.PendingIntent
+import android.content.ContentResolver
+import android.content.Intent
+import android.os.Binder
+import android.os.Bundle
+import androidx.annotation.WorkerThread
+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.HttpException
+import at.bitfire.dav4jvm.property.*
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.Collection
+import at.bitfire.davdroid.model.*
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import okhttp3.HttpUrl
+import okhttp3.OkHttpClient
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.logging.Level
+import kotlin.collections.*
+
+@Suppress("DEPRECATION")
+class DavService: IntentService("DavService") {
+
+    companion object {
+
+        const val ACTION_REFRESH_COLLECTIONS = "refreshCollections"
+        const val EXTRA_DAV_SERVICE_ID = "davServiceID"
+
+        /** Initialize a forced synchronization. Expects intent data
+            to be an URI of this format:
+            contents://<authority>/<account.type>/<account name>
+         **/
+        const val ACTION_FORCE_SYNC = "forceSync"
+
+        val DAV_COLLECTION_PROPERTIES = arrayOf(
+                ResourceType.NAME,
+                CurrentUserPrivilegeSet.NAME,
+                DisplayName.NAME,
+                Owner.NAME,
+                AddressbookDescription.NAME, SupportedAddressData.NAME,
+                CalendarDescription.NAME, CalendarColor.NAME, SupportedCalendarComponentSet.NAME,
+                Source.NAME
+        )
+
+    }
+
+    /**
+     * List of [Service] IDs for which the collections are currently refreshed
+     */
+    private val runningRefresh = Collections.synchronizedSet(HashSet<Long>())
+
+    /**
+     * Currently registered [RefreshingStatusListener]s, which will be notified
+     * when a collection refresh status changes
+     */
+    private val refreshingStatusListeners = Collections.synchronizedList(LinkedList<WeakReference<RefreshingStatusListener>>())
+
+    @WorkerThread
+    override fun onHandleIntent(intent: Intent?) {
+        if (intent == null)
+            return
+
+        val id = intent.getLongExtra(EXTRA_DAV_SERVICE_ID, -1)
+
+        when (intent.action) {
+            ACTION_REFRESH_COLLECTIONS ->
+                if (runningRefresh.add(id)) {
+                    refreshingStatusListeners.forEach { listener ->
+                        listener.get()?.onDavRefreshStatusChanged(id, true)
+                    }
+
+                    val db = AppDatabase.getInstance(this@DavService)
+                    refreshCollections(db, id)
+                }
+
+            ACTION_FORCE_SYNC -> {
+                val uri = intent.data!!
+                val authority = uri.authority!!
+                val account = Account(
+                        uri.pathSegments[1],
+                        uri.pathSegments[0]
+                )
+                forceSync(authority, account)
+            }
+
+        }
+    }
+
+
+    /* BOUND SERVICE PART
+       for communicating with the activities
+    */
+
+    interface RefreshingStatusListener {
+        fun onDavRefreshStatusChanged(id: Long, refreshing: Boolean)
+    }
+
+    private val binder = InfoBinder()
+
+    inner class InfoBinder: Binder() {
+        fun isRefreshing(id: Long) = runningRefresh.contains(id)
+
+        fun addRefreshingStatusListener(listener: RefreshingStatusListener, callImmediateIfRunning: Boolean) {
+            refreshingStatusListeners += WeakReference<RefreshingStatusListener>(listener)
+            if (callImmediateIfRunning)
+                synchronized(runningRefresh) {
+                    for (id in runningRefresh)
+                        listener.onDavRefreshStatusChanged(id, true)
+                }
+        }
+
+        fun removeRefreshingStatusListener(listener: RefreshingStatusListener) {
+            val iter = refreshingStatusListeners.iterator()
+            while (iter.hasNext()) {
+                val item = iter.next().get()
+                if (item == listener || item == null)
+                    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(db: AppDatabase, serviceId: Long) {
+        val homeSetDao = db.homeSetDao()
+        val collectionDao = db.collectionDao()
+
+        val service = db.serviceDao().get(serviceId) ?: throw IllegalArgumentException("Service not found")
+        val account = Account(service.accountName, getString(R.string.account_type))
+
+        val homeSets = homeSetDao.getByService(serviceId).associateBy { it.url }.toMutableMap()
+        val collections = collectionDao.getByService(serviceId).associateBy { it.url }.toMutableMap()
+
+        /**
+         * Checks if the given URL defines home sets and adds them to the home set list.
+         *
+         * @param personal Whether this is the "outer" call of the recursion.
+         *
+         * *true* = found home sets belong to the current-user-principal; recurse if
+         * calendar proxies or group memberships are found
+         *
+         * *false* = found home sets don't directly belong to the current-user-principal; don't recurse
+         *
+         * @throws java.io.IOException
+         * @throws HttpException
+         * @throws at.bitfire.dav4jvm.exception.DavException
+         */
+        fun queryHomeSets(client: OkHttpClient, url: HttpUrl, personal: Boolean = true) {
+            val related = mutableSetOf<HttpUrl>()
+
+            fun findRelated(root: HttpUrl, dav: Response) {
+                // refresh home sets: calendar-proxy-read/write-for
+                dav[CalendarProxyReadFor::class.java]?.let {
+                    for (href in it.hrefs) {
+                        Logger.log.fine("Principal is a read-only proxy for $href, checking for home sets")
+                        root.resolve(href)?.let { proxyReadFor ->
+                            related += proxyReadFor
+                        }
+                    }
+                }
+                dav[CalendarProxyWriteFor::class.java]?.let {
+                    for (href in it.hrefs) {
+                        Logger.log.fine("Principal is a read/write proxy for $href, checking for home sets")
+                        root.resolve(href)?.let { proxyWriteFor ->
+                            related += proxyWriteFor
+                        }
+                    }
+                }
+
+                // refresh home sets: direct group memberships
+                dav[GroupMembership::class.java]?.let {
+                    for (href in it.hrefs) {
+                        Logger.log.fine("Principal is member of group $href, checking for home sets")
+                        root.resolve(href)?.let { groupMembership ->
+                            related += groupMembership
+                        }
+                    }
+                }
+            }
+
+            val dav = DavResource(client, url)
+            when (service.type) {
+                Service.TYPE_CARDDAV ->
+                    try {
+                        dav.propfind(0, DisplayName.NAME, AddressbookHomeSet.NAME, GroupMembership.NAME) { response, _ ->
+                            response[AddressbookHomeSet::class.java]?.let { homeSet ->
+                                for (href in homeSet.hrefs)
+                                    dav.location.resolve(href)?.let {
+                                        val foundUrl = UrlUtils.withTrailingSlash(it)
+                                        homeSets[foundUrl] = HomeSet(0, service.id, personal, foundUrl)
+                                    }
+                            }
+
+                            if (personal)
+                                findRelated(dav.location, response)
+                        }
+                    } catch (e: HttpException) {
+                        if (e.code/100 == 4)
+                            Logger.log.log(Level.INFO, "Ignoring Client Error 4xx while looking for addressbook home sets", e)
+                        else
+                            throw e
+                    }
+                Service.TYPE_CALDAV -> {
+                    try {
+                        dav.propfind(0, DisplayName.NAME, CalendarHomeSet.NAME, CalendarProxyReadFor.NAME, CalendarProxyWriteFor.NAME, GroupMembership.NAME) { response, _ ->
+                            response[CalendarHomeSet::class.java]?.let { homeSet ->
+                                for (href in homeSet.hrefs)
+                                    dav.location.resolve(href)?.let {
+                                        val foundUrl = UrlUtils.withTrailingSlash(it)
+                                        homeSets[foundUrl] = HomeSet(0, service.id, personal, foundUrl)
+                                    }
+                            }
+
+                            if (personal)
+                                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
+                    }
+                }
+            }
+
+            // query related homesets (those that do not belong to the current-user-principal)
+            for (resource in related)
+                queryHomeSets(client, resource, false)
+        }
+
+        fun saveHomesets() {
+            DaoTools(homeSetDao).syncAll(
+                    homeSetDao.getByService(serviceId),
+                    homeSets,
+                    { it.url })
+        }
+
+        fun saveCollections() {
+            DaoTools(collectionDao).syncAll(
+                    collectionDao.getByService(serviceId),
+                    collections, { it.url }) { new, old ->
+                new.forceReadOnly = old.forceReadOnly
+                new.sync = old.sync
+            }
+        }
+
+        try {
+            Logger.log.info("Refreshing ${service.type} collections of service #$service")
+
+            // cancel previous notification
+            NotificationManagerCompat.from(this)
+                    .cancel(service.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS)
+
+            // create authenticating OkHttpClient (credentials taken from account settings)
+            HttpClient.Builder(this, AccountSettings(this, account))
+                    .setForeground(true)
+                    .build().use { client ->
+                val httpClient = client.okHttpClient
+
+                // refresh home set list (from principal)
+                service.principal?.let { principalUrl ->
+                    Logger.log.fine("Querying principal $principalUrl for home sets")
+                    queryHomeSets(httpClient, principalUrl)
+                }
+
+                // now refresh homesets and their member collections
+                val itHomeSets = homeSets.iterator()
+                while (itHomeSets.hasNext()) {
+                    val (homeSetUrl, homeSet) = itHomeSets.next()
+                    Logger.log.fine("Listing home set $homeSetUrl")
+
+                    try {
+                        DavResource(httpClient, homeSetUrl).propfind(1, *DAV_COLLECTION_PROPERTIES) { response, relation ->
+                            if (!response.isSuccess())
+                                return@propfind
+
+                            if (relation == Response.HrefRelation.SELF) {
+                                // this response is about the homeset itself
+                                homeSet.displayName = response[DisplayName::class.java]?.displayName
+                                homeSet.privBind = response[CurrentUserPrivilegeSet::class.java]?.mayBind ?: true
+                            }
+
+                            // in any case, check whether the response is about a useable collection
+                            val info = Collection.fromDavResponse(response) ?: return@propfind
+                            info.serviceId = serviceId
+                            info.refHomeSet = homeSet
+                            info.confirmed = true
+                            info.owner = response[Owner::class.java]?.href?.let { response.href.resolve(it) }
+                            Logger.log.log(Level.FINE, "Found collection", info)
+
+                            // remember usable collections
+                            if ((service.type == Service.TYPE_CARDDAV && info.type == Collection.TYPE_ADDRESSBOOK) ||
+                                    (service.type == Service.TYPE_CALDAV && arrayOf(Collection.TYPE_CALENDAR, Collection.TYPE_WEBCAL).contains(info.type)))
+                                collections[response.href] = info
+                        }
+                    } catch(e: HttpException) {
+                        if (e.code in arrayOf(403, 404, 410))
+                            // delete home set only if it was not accessible (40x)
+                            itHomeSets.remove()
+                    }
+                }
+
+                // check/refresh unconfirmed collections
+                val itCollections = collections.entries.iterator()
+                while (itCollections.hasNext()) {
+                    val (url, info) = itCollections.next()
+                    if (!info.confirmed)
+                        try {
+                            // this collection doesn't belong to a homeset anymore, otherwise it would have been confirmed
+                            info.homeSetId = null
+
+                            DavResource(httpClient, url).propfind(0, *DAV_COLLECTION_PROPERTIES) { response, _ ->
+                                if (!response.isSuccess())
+                                    return@propfind
+
+                                val collection = Collection.fromDavResponse(response) ?: return@propfind
+                                collection.confirmed = true
+
+                                // remove unusable collections
+                                if ((service.type == Service.TYPE_CARDDAV && collection.type != Collection.TYPE_ADDRESSBOOK) ||
+                                    (service.type == Service.TYPE_CALDAV && !arrayOf(Collection.TYPE_CALENDAR, Collection.TYPE_WEBCAL).contains(collection.type)) ||
+                                    (collection.type == Collection.TYPE_WEBCAL && collection.source == null))
+                                    itCollections.remove()
+                            }
+                        } catch(e: HttpException) {
+                            if (e.code in arrayOf(403, 404, 410))
+                                // delete collection only if it was not accessible (40x)
+                                itCollections.remove()
+                            else
+                                throw e
+                        }
+                }
+            }
+
+            db.runInTransaction {
+                saveHomesets()
+
+                // use refHomeSet (if available) to determine homeset ID
+                for (collection in collections.values)
+                    collection.refHomeSet?.let { homeSet ->
+                        collection.homeSetId = homeSet.id
+                    }
+                saveCollections()
+            }
+
+        } 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.EXTRA_CAUSE, e)
+            debugIntent.putExtra(DebugInfoActivity.EXTRA_ACCOUNT, account)
+
+            val notify = NotificationUtils.newBuilder(this, NotificationUtils.CHANNEL_GENERAL)
+                    .setSmallIcon(R.drawable.ic_sync_problem_notify)
+                    .setContentTitle(getString(R.string.dav_service_refresh_failed))
+                    .setContentText(getString(R.string.dav_service_refresh_couldnt_refresh))
+                    .setContentIntent(PendingIntent.getActivity(this, 0, debugIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+                    .setSubText(account.name)
+                    .setCategory(NotificationCompat.CATEGORY_ERROR)
+                    .build()
+            NotificationManagerCompat.from(this)
+                    .notify(serviceId.toString(), NotificationUtils.NOTIFY_REFRESH_COLLECTIONS, notify)
+        } finally {
+            runningRefresh.remove(serviceId)
+            refreshingStatusListeners.mapNotNull { it.get() }.forEach {
+                it.onDavRefreshStatusChanged(serviceId, false)
+            }
+        }
+
+    }
+
+}
@@ -0,0 +1,204 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid
+
+import android.accounts.Account
+import android.annotation.TargetApi
+import android.content.ContentResolver
+import android.content.Context
+import android.net.ConnectivityManager
+import android.os.Build
+import android.os.Bundle
+import android.provider.CalendarContract
+import android.provider.ContactsContract
+import androidx.core.content.getSystemService
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.resource.TaskUtils
+import okhttp3.HttpUrl
+import org.xbill.DNS.*
+import java.util.*
+
+/**
+ * Some WebDAV and related network utility methods
+ */
+object DavUtils {
+
+    enum class SyncStatus {
+        ACTIVE, PENDING, IDLE
+    }
+
+
+    @Suppress("FunctionName")
+    fun ARGBtoCalDAVColor(colorWithAlpha: Int): String {
+        val alpha = (colorWithAlpha shr 24) and 0xFF
+        val color = colorWithAlpha and 0xFFFFFF
+        return String.format(Locale.ROOT, "#%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(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<ConnectivityManager>()!!
+            val activeLink = connectivity.getLinkProperties(connectivity.activeNetwork)
+            if (activeLink != null) {
+                // get DNS servers of active network link and set them for dnsjava so that it can send SRV queries
+                val simpleResolvers = activeLink.dnsServers.map {
+                    Logger.log.fine("Using DNS server ${it.hostAddress}")
+                    val resolver = SimpleResolver()
+                    resolver.setAddress(it)
+                    resolver
+                }
+                val resolver = ExtendedResolver(simpleResolvers.toTypedArray())
+                lookup.setResolver(resolver)
+            } else
+                Logger.log.severe("Couldn't determine DNS servers, dnsjava queries (SRV/TXT records) won't work")
+        }
+    }
+
+    fun selectSRVRecord(records: Array<out Record>?): SRVRecord? {
+        if (records == null)
+            return null
+
+        val srvRecords = records.filterIsInstance(SRVRecord::class.java)
+        if (srvRecords.size <= 1)
+            return srvRecords.firstOrNull()
+
+        /* RFC 2782
+
+           Priority
+                The priority of this target host.  A client MUST attempt to
+                contact the target host with the lowest-numbered priority it can
+                reach; target hosts with the same priority SHOULD be tried in an
+                order defined by the weight field. [...]
+
+           Weight
+                A server selection mechanism.  The weight field specifies a
+                relative weight for entries with the same priority. [...]
+
+                To select a target to be contacted next, arrange all SRV RRs
+                (that have not been ordered yet) in any order, except that all
+                those with weight 0 are placed at the beginning of the list.
+
+                Compute the sum of the weights of those RRs, and with each RR
+                associate the running sum in the selected order. Then choose a
+                uniform random number between 0 and the sum computed
+                (inclusive), and select the RR whose running sum value is the
+                first in the selected order which is greater than or equal to
+                the random number selected. The target host specified in the
+                selected SRV RR is the next one to be contacted by the client.
+        */
+        val minPriority = srvRecords.map { it.priority }.minOrNull()
+        val useableRecords = srvRecords.filter { it.priority == minPriority }.sortedBy { it.weight != 0 }
+
+        val map = TreeMap<Int, SRVRecord>()
+        var runningWeight = 0
+        for (record in useableRecords) {
+            val weight = record.weight
+            runningWeight += weight
+            map[runningWeight] = record
+        }
+
+        val selector = (0..runningWeight).random()
+        return map.ceilingEntry(selector)!!.value
+    }
+
+    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
+    }
+
+
+    /**
+     * Returns the sync status of a given account. Checks the account itself and possible
+     * sub-accounts (address book accounts).
+     *
+     * @param authorities sync authorities to check (usually taken from [syncAuthorities])
+     *
+     * @return sync status of the given account
+     */
+    fun accountSyncStatus(context: Context, authorities: Iterable<String>, account: Account): SyncStatus {
+        // check active syncs
+        if (authorities.any { ContentResolver.isSyncActive(account, it) })
+            return SyncStatus.ACTIVE
+
+        val addrBookAccounts = LocalAddressBook.findAll(context, null, account).map { it.account }
+        if (addrBookAccounts.any { ContentResolver.isSyncActive(it, ContactsContract.AUTHORITY) })
+            return SyncStatus.ACTIVE
+
+        // check get pending syncs
+        if (authorities.any { ContentResolver.isSyncPending(account, it) } ||
+            addrBookAccounts.any { ContentResolver.isSyncPending(it, ContactsContract.AUTHORITY) })
+            return SyncStatus.PENDING
+
+        return SyncStatus.IDLE
+    }
+
+    /**
+     * Requests an immediate, manual sync of all available authorities for the given account.
+     *
+     * @param account account to sync
+     */
+    fun requestSync(context: Context, account: Account) {
+        for (authority in syncAuthorities(context)) {
+            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)
+        }
+    }
+
+    /**
+     * Returns a list of all available sync authorities for main accounts (!= address book accounts):
+     *
+     *   1. address books authority (not [ContactsContract.AUTHORITY], but the one which manages address book accounts)
+     *   1. calendar authority
+     *   1. tasks authority (if available)
+     *
+     * Checking the availability of authorities may be relatively expensive, so the
+     * result should be cached for the current operation.
+     *
+     * @return list of available sync authorities for main accounts
+     */
+    fun syncAuthorities(context: Context): List<String> {
+        val result = mutableListOf(
+                context.getString(R.string.address_books_authority),
+                CalendarContract.AUTHORITY
+        )
+
+        TaskUtils.currentProvider(context)?.let { taskProvider ->
+            result += taskProvider.authority
+        }
+
+        return result
+    }
+
+}
@@ -0,0 +1,62 @@
+package at.bitfire.davdroid
+
+import android.app.PendingIntent
+import android.app.Service
+import android.content.Context
+import android.content.Intent
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.davdroid.ui.AppSettingsActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+
+class ForegroundService : Service() {
+
+    companion object {
+
+        /**
+         * Starts/stops a foreground service, according to the app setting [Settings.FOREGROUND_SERVICE].
+         */
+        const val ACTION_FOREGROUND = "foreground"
+
+        fun isEnabled(context: Context): Boolean {
+            val settings = SettingsManager.getInstance(context)
+            return settings.getBooleanOrNull(Settings.FOREGROUND_SERVICE) == true
+        }
+
+        fun startIfEnabled(context: Context) {
+            if (isEnabled(context)) {
+                val serviceIntent = Intent(ACTION_FOREGROUND, null, context, ForegroundService::class.java)
+                if (Build.VERSION.SDK_INT >= 26)
+                    context.startForegroundService(serviceIntent)
+                else
+                    context.startService(serviceIntent)
+            }
+        }
+
+    }
+
+
+    override fun onBind(intent: Intent?) = null
+
+    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
+        if (isEnabled(this)) {
+            val settingsIntent = Intent(this, AppSettingsActivity::class.java).apply {
+                putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, Settings.FOREGROUND_SERVICE)
+            }
+            val builder = NotificationCompat.Builder(this, NotificationUtils.CHANNEL_STATUS)
+                    .setSmallIcon(R.drawable.ic_foreground_notify)
+                    .setContentTitle(getString(R.string.foreground_service_notify_title))
+                    .setContentText(getString(R.string.foreground_service_notify_text))
+                    .setStyle(NotificationCompat.BigTextStyle())
+                    .setContentIntent(PendingIntent.getActivity(this, 0, settingsIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+            startForeground(NotificationUtils.NOTIFY_FOREGROUND, builder.build())
+            return START_STICKY
+        } else {
+            stopForeground(true)
+            return START_NOT_STICKY
+        }
+    }
+
+}
@@ -0,0 +1,251 @@
+/*
+ * Copyright © Ricki Hirner (bitfire web engineering).
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the GNU Public License v3.0
+ * which accompanies this distribution, and is available at
+ * http://www.gnu.org/licenses/gpl.html
+ */
+
+package at.bitfire.davdroid
+
+import android.content.Context
+import android.os.Build
+import android.security.KeyChain
+import at.bitfire.cert4android.CustomCertManager
+import at.bitfire.dav4jvm.BasicDigestAuthHandler
+import at.bitfire.dav4jvm.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 at.bitfire.davdroid.settings.SettingsManager
+import okhttp3.*
+import okhttp3.brotli.BrotliInterceptor
+import okhttp3.internal.tls.OkHostnameVerifier
+import okhttp3.logging.HttpLoggingInterceptor
+import java.io.File
+import java.net.InetSocketAddress
+import java.net.Proxy
+import java.net.Socket
+import java.security.KeyStore
+import java.security.Principal
+import java.text.SimpleDateFormat
+import java.util.*
+import java.util.concurrent.TimeUnit
+import java.util.logging.Level
+import javax.net.ssl.*
+
+class HttpClient private constructor(
+        val okHttpClient: OkHttpClient,
+        private val certManager: CustomCertManager?
+): AutoCloseable {
+
+    companion object {
+        /** max. size of disk cache (10 MB) */
+        const val DISK_CACHE_MAX_SIZE: Long = 10*1024*1024
+
+        /** [OkHttpClient] singleton to build all clients from */
+        val sharedClient: OkHttpClient = OkHttpClient.Builder()
+                // Set timeouts. According to [AbstractThreadedSyncAdapter], when there is no network
+                // traffic within a minute, a sync will be cancelled.
+                .connectTimeout(15, TimeUnit.SECONDS)
+                .writeTimeout(30, TimeUnit.SECONDS)
+                .readTimeout(120, TimeUnit.SECONDS)
+                .pingInterval(45, TimeUnit.SECONDS)     // avoid cancellation because of missing traffic; only works for HTTP/2
+
+                // keep TLS 1.0 and 1.1 for now; remove when major browsers have dropped it (probably 2020)
+                .connectionSpecs(listOf(
+                        ConnectionSpec.CLEARTEXT,
+                        ConnectionSpec.COMPATIBLE_TLS
+                ))
+
+                // don't allow redirects by default, because it would break PROPFIND handling
+                .followRedirects(false)
+
+                // offer Brotli and gzip compression
+                .addInterceptor(BrotliInterceptor)
+
+                // 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 { message -> logger.finest(message) }
+                loggingInterceptor.level = HttpLoggingInterceptor.Level.BODY
+                orig.addInterceptor(loggingInterceptor)
+            }
+
+            if (context != null) {
+                val settings = SettingsManager.getInstance(context)
+
+                // custom proxy support
+                try {
+                    if (settings.getBoolean(Settings.OVERRIDE_PROXY)) {
+                        val address = InetSocketAddress(
+                                settings.getString(Settings.OVERRIDE_PROXY_HOST),
+                                settings.getInt(Settings.OVERRIDE_PROXY_PORT)
+                        )
+
+                        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)
+                }
+
+                // TODO don't instantiate CustomCertManager in .Builder (causes service leaks)
+                customCertManager(CustomCertManager(context, true /*BuildConfig.customCertsUI*/,
+                        !(settings.getBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES))))
+            }
+
+            // 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(context: Context): Builder {
+            for (dir in arrayOf(context.externalCacheDir, context.cacheDir).filterNotNull()) {
+                if (dir.exists() && dir.canWrite()) {
+                    val cacheDir = File(dir, "HttpClient")
+                    cacheDir.mkdir()
+                    Logger.log.fine("Using disk cache: $cacheDir")
+                    orig.cache(Cache(cacheDir, DISK_CACHE_MAX_SIZE))
+                    break
+                }
+            }
+            return this
+        }
+
+        fun 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 {
+            if (credentials.userName != null && credentials.password != null) {
+                val authHandler = BasicDigestAuthHandler(UrlUtils.hostToDomain(host), credentials.userName, credentials.password)
+                orig    .addNetworkInterceptor(authHandler)
+                        .authenticator(authHandler)
+            }
+            if (credentials.certificateAlias != null)
+                certificateAlias = credentials.certificateAlias
+            return this
+        }
+
+        fun build(): HttpClient {
+            val trustManager = certManager ?: run {
+                val factory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm())
+                factory.init(null as KeyStore?)
+                factory.trustManagers.first() as X509TrustManager
+            }
+
+            val hostnameVerifier = certManager?.hostnameVerifier(OkHostnameVerifier)
+                    ?: OkHostnameVerifier
+
+            var keyManager: KeyManager? = null
+            certificateAlias?.let { alias ->
+                val context = requireNotNull(context)
+
+                // get provider certificate and private key
+                val certs = KeyChain.getCertificateChain(context, alias) ?: return@let
+                val key = KeyChain.getPrivateKey(context, alias) ?: return@let
+                logger.fine("Using provider certificate $alias for authentication (chain length: ${certs.size})")
+
+                // create KeyManager
+                keyManager = object : X509ExtendedKeyManager() {
+                    override fun getServerAliases(p0: String?, p1: Array<out Principal>?): Array<String>? = null
+                    override fun chooseServerAlias(p0: String?, p1: Array<out Principal>?, p2: Socket?) = null
+
+                    override fun getClientAliases(p0: String?, p1: Array<out Principal>?) =
+                            arrayOf(alias)
+
+                    override fun chooseClientAlias(p0: Array<out String>?, p1: Array<out Principal>?, p2: Socket?) =
+                            alias
+
+                    override fun getCertificateChain(forAlias: String?) =
+                            certs.takeIf { forAlias == alias }
+
+                    override fun getPrivateKey(forAlias: String?) =
+                            key.takeIf { forAlias == alias }
+                }
+
+                // HTTP/2 doesn't support client certificates (yet)
+                // see https://tools.ietf.org/html/draft-ietf-httpbis-http2-secondary-certs-04
+                orig.protocols(listOf(Protocol.HTTP_1_1))
+            }
+
+            val sslContext = SSLContext.getInstance("TLS")
+            sslContext.init(
+                    if (keyManager != null) arrayOf(keyManager) else null,
+                    arrayOf(trustManager),
+                    null)
+            orig.sslSocketFactory(sslContext.socketFactory, trustManager)
+            orig.hostnameVerifier(hostnameVerifier)
+
+            return HttpClient(orig.build(), certManager)
+        }
+
+    }
+
+
+    private object UserAgentInterceptor: Interceptor {
+        // use Locale.ROOT because numbers may be encoded as non-ASCII characters in other locales
+        private val userAgentDateFormat = SimpleDateFormat("yyyy/MM/dd", Locale.ROOT)
+        private val userAgentDate = userAgentDateFormat.format(Date(BuildConfig.buildTime))
+        private val userAgent = "${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ($userAgentDate; dav4jvm; " +
+                "okhttp/${OkHttp.VERSION}) Android/${Build.VERSION.RELEASE}"
+
+        init {
+            Logger.log.info("Will set \"User-Agent: $userAgent\" for further requests")
+        }
+
+        override fun intercept(chain: Interceptor.Chain): Response {
+            val locale = Locale.getDefault()
+            val request = chain.request().newBuilder()
+                    .header("User-Agent", userAgent)
+                    .header("Accept-Language", "${locale.language}-${locale.country}, ${locale.language};q=0.7, *;q=0.5")
+                    .build()
+            return chain.proceed(request)
+        }
+
+    }
+
+}
@@ -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")
@@ -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
+    }
+
+}
@@ -0,0 +1,25 @@
+package at.bitfire.davdroid
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+
+abstract class PackageChangedReceiver(
+        val context: Context
+): BroadcastReceiver(), AutoCloseable {
+
+    init {
+        val filter = IntentFilter(Intent.ACTION_PACKAGE_ADDED).apply {
+            addAction(Intent.ACTION_PACKAGE_CHANGED)
+            addAction(Intent.ACTION_PACKAGE_REMOVED)
+            addDataScheme("package")
+        }
+        context.registerReceiver(this, filter)
+    }
+
+    override fun close() {
+        context.unregisterReceiver(this)
+    }
+
+}
@@ -0,0 +1,126 @@
+package at.bitfire.davdroid
+
+import android.Manifest
+import android.app.PendingIntent
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.location.LocationManager
+import android.net.Uri
+import android.os.Build
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.core.content.ContextCompat
+import androidx.core.location.LocationManagerCompat
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.ui.NotificationUtils
+import at.bitfire.davdroid.ui.PermissionsActivity
+
+object PermissionUtils {
+
+    val CONTACT_PERMISSIONS = arrayOf(
+            Manifest.permission.READ_CONTACTS,
+            Manifest.permission.WRITE_CONTACTS
+    )
+    val CALENDAR_PERMISSIONS = arrayOf(
+            Manifest.permission.READ_CALENDAR,
+            Manifest.permission.WRITE_CALENDAR
+    )
+
+    val WIFI_SSID_PERMISSIONS =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q)
+                arrayOf(Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.ACCESS_BACKGROUND_LOCATION)
+            else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O_MR1)
+                arrayOf(Manifest.permission.ACCESS_COARSE_LOCATION)
+            else
+                arrayOf()
+
+    /**
+     * Checks whether all conditions to access the current WiFi's SSID are met:
+     *
+     * 1. location permissions ([WIFI_SSID_PERMISSIONS]) granted (Android 8.1+)
+     * 2. location enabled (Android 9+)
+     *
+     * @return *true* if SSID can be obtained; *false* if the SSID will be <unknown> or something like that
+     */
+    fun canAccessWifiSsid(context: Context): Boolean {
+        // before Android 8.1, SSIDs are always readable
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O_MR1)
+            return true
+
+        val locationAvailable =
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.P)
+                    true    // Android <9 doesn't require active location services
+                else
+                    ContextCompat.getSystemService(context, LocationManager::class.java)?.let { locationManager ->
+                        LocationManagerCompat.isLocationEnabled(locationManager)
+                    } ?: /* location feature not available on this device */ false
+
+        return  havePermissions(context, WIFI_SSID_PERMISSIONS) &&
+                locationAvailable
+    }
+
+    /**
+     * Whether this app declares the given permission (regardless of whether it has been granted or not).
+     *
+     * @param permission  permission to check
+     *
+     * @return *true* if this app declares [permission] in the manifest; *false* otherwise
+     */
+    fun declaresPermission(packageManager: PackageManager, permission: String): Boolean {
+        val info = packageManager.getPackageInfo(BuildConfig.APPLICATION_ID, PackageManager.GET_PERMISSIONS)
+        return info.requestedPermissions.contains(permission)
+    }
+
+    /**
+     * Checks whether at least one of the given permissions is granted.
+     *
+     * @param context context to check
+     * @param permissions array of permissions to check
+     *
+     * @return whether at least one of [permissions] is granted
+     */
+    fun haveAnyPermission(context: Context, permissions: Array<String>) =
+            permissions.any { ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED }
+
+    /**
+     * Checks whether all given permissions are granted.
+     *
+     * @param context context to check
+     * @param permissions array of permissions to check
+     *
+     * @return whether all [permissions] are granted
+     */
+    fun havePermissions(context: Context, permissions: Array<String>) =
+            permissions.all { ContextCompat.checkSelfPermission(context, it) == PackageManager.PERMISSION_GRANTED }
+
+    /**
+     * Shows a notification about missing permissions.
+     *
+     * @param context notification context
+     * @param intent will be set as content Intent; if null, an Intent to launch PermissionsActivity will be used
+     */
+    fun notifyPermissions(context: Context, intent: Intent?) {
+        val contentIntent = intent ?: Intent(context, PermissionsActivity::class.java)
+        val notify = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_SYNC_ERRORS)
+                .setSmallIcon(R.drawable.ic_sync_problem_notify)
+                .setContentTitle(context.getString(R.string.sync_error_permissions))
+                .setContentText(context.getString(R.string.sync_error_permissions_text))
+                .setContentIntent(PendingIntent.getActivity(context, 0, contentIntent, PendingIntent.FLAG_UPDATE_CURRENT))
+                .setCategory(NotificationCompat.CATEGORY_ERROR)
+                .setAutoCancel(true)
+                .build()
+        NotificationManagerCompat.from(context)
+                .notify(NotificationUtils.NOTIFY_PERMISSIONS, notify)
+    }
+
+    fun showAppSettings(context: Context) {
+        val intent = Intent(android.provider.Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
+                Uri.fromParts("package", BuildConfig.APPLICATION_ID, null))
+        if (intent.resolveActivity(context.packageManager) != null)
+            context.startActivity(intent)
+        else
+            Logger.log.warning("App settings Intent not resolvable")
+    }
+
+}
@@ -0,0 +1,97 @@
+/*
+ * 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.accounts.AccountManager
+import android.content.ContentResolver
+import android.content.Context
+import android.content.Intent
+import androidx.annotation.WorkerThread
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.AppDatabase
+import at.bitfire.davdroid.model.Service
+import at.bitfire.davdroid.resource.TaskUtils
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.ical4android.TaskProvider
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+class TasksWatcher(
+        context: Context
+): PackageChangedReceiver(context) {
+
+    companion object {
+
+        @WorkerThread
+        fun updateTaskSync(context: Context) {
+            val tasksProvider = TaskUtils.currentProvider(context)
+            Logger.log.info("App launched or other package (un)installed; current tasks provider = $tasksProvider")
+
+            var permissionsRequired = false     // whether additional permissions are required
+            val currentProvider by lazy {       // only this provider shall be enabled (null to disable all providers)
+                TaskUtils.currentProvider(context)
+            }
+
+            // check all accounts and (de)activate task provider(s) if a CalDAV service is defined
+            val db = AppDatabase.getInstance(context)
+            val accountManager = AccountManager.get(context)
+            for (account in accountManager.getAccountsByType(context.getString(R.string.account_type))) {
+                val hasCalDAV = db.serviceDao().getByAccountAndType(account.name, Service.TYPE_CALDAV) != null
+                for (providerName in TaskProvider.ProviderName.values()) {
+                    val isSyncable = ContentResolver.getIsSyncable(account, providerName.authority)     // may be -1 (unknown state)
+                    val shallBeSyncable = hasCalDAV && providerName == currentProvider
+                    if ((shallBeSyncable && isSyncable != 1) || (!shallBeSyncable && isSyncable != 0)) {
+                        // enable/disable sync
+                        setSyncable(context, account, providerName.authority, shallBeSyncable)
+
+                        // if sync has just been enabled: check whether additional permissions are required
+                        if (shallBeSyncable && !PermissionUtils.havePermissions(context, providerName.permissions))
+                            permissionsRequired = true
+                    }
+                }
+            }
+
+            if (permissionsRequired) {
+                Logger.log.warning("Tasks synchronization is now enabled for at least one account, but permissions are not granted")
+                PermissionUtils.notifyPermissions(context, null)
+            }
+        }
+
+        private fun setSyncable(context: Context, account: Account, authority: String, syncable: Boolean) {
+            if (syncable) {
+                Logger.log.info("Enabling $authority sync for $account")
+                ContentResolver.setIsSyncable(account, authority, 1)
+                try {
+                    val settings = AccountSettings(context, account)
+                    val interval = settings.getSavedTasksSyncInterval() ?:
+                            SettingsManager.getInstance(context).getLong(Settings.DEFAULT_SYNC_INTERVAL)
+                    settings.setSyncInterval(authority, interval)
+                } catch (e: InvalidAccountException) {
+                    // account has already been removed
+                }
+            } else {
+                Logger.log.info("Disabling $authority sync for $account")
+                ContentResolver.setIsSyncable(account, authority, 0)
+            }
+        }
+
+    }
+
+
+    override fun onReceive(context: Context, intent: Intent) {
+        CoroutineScope(Dispatchers.Default).launch {
+            updateTaskSync(context)
+        }
+    }
+
+}
@@ -0,0 +1,79 @@
+package at.bitfire.davdroid
+
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+
+class TextTable(
+        vararg val headers: String
+) {
+
+    companion object {
+
+        fun indent(str: String, pos: Int): String =
+                " ".repeat(pos) +
+                str.split('\n').joinToString("\n" + " ".repeat(pos))
+
+    }
+
+
+    private val lines = mutableListOf<Array<String>>()
+
+    fun addLine(vararg values: Any?) {
+        if (values.size != headers.size)
+            throw IllegalArgumentException("Table line must have ${headers.size} column(s)")
+        lines += values.map {
+            it?.toString() ?: "—"
+        }.toTypedArray()
+    }
+
+    override fun toString(): String {
+        val sb = StringBuilder()
+
+        val headerWidths = headers.map { it.length }
+        val colWidths = Array<Int>(headers.size) { colIdx ->
+            Collections.max(listOf(headerWidths[colIdx]) + lines.map { it[colIdx] }.map { it.length })
+        }
+
+        // first line
+        sb.append("\n┌")
+        for (colIdx in 0 until headers.size)
+            sb  .append(StringUtils.repeat('─', colWidths[colIdx] + 2))
+                .append(if (colIdx == headers.size - 1) '┐' else '┬')
+        sb.append('\n')
+
+        // header
+        sb.append('│')
+        for (colIdx in 0 until headers.size)
+            sb  .append(' ')
+                .append(StringUtils.rightPad(headers[colIdx], colWidths[colIdx] + 1))
+                .append('│')
+        sb.append('\n')
+
+        // separator between header and body
+        sb.append('├')
+        for (colIdx in 0 until headers.size) {
+            sb  .append(StringUtils.repeat('─', colWidths[colIdx] + 2))
+                .append(if (colIdx == headers.size - 1) '┤' else '┼')
+        }
+        sb.append('\n')
+
+        // body
+        for (line in lines) {
+            for (colIdx in 0 until headers.size)
+                sb  .append("│ ")
+                    .append(StringUtils.rightPad(line[colIdx], colWidths[colIdx] + 1))
+            sb.append("│\n")
+        }
+
+        // last line
+        sb.append("└")
+        for (colIdx in 0 until headers.size) {
+            sb  .append("─".repeat(colWidths[colIdx] + 2))
+                .append(if (colIdx == headers.size - 1) '┘' else '┴')
+        }
+        sb.append("\n\n")
+
+        return sb.toString()
+    }
+
+}
@@ -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() {}
+
+}
@@ -0,0 +1,145 @@
+/*
+ * 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.app.Application
+import android.app.PendingIntent
+import android.content.Intent
+import android.content.SharedPreferences
+import android.os.Process
+import android.util.Log
+import android.widget.Toast
+import androidx.core.app.NotificationCompat
+import androidx.core.app.NotificationManagerCompat
+import androidx.preference.PreferenceManager
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.ui.AppSettingsActivity
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import at.bitfire.davdroid.ui.NotificationUtils
+import java.io.File
+import java.io.IOException
+import java.util.*
+import java.util.logging.FileHandler
+import java.util.logging.Level
+
+object Logger : SharedPreferences.OnSharedPreferenceChangeListener {
+
+    private const val LOG_TO_FILE = "log_to_file"
+
+    val log: java.util.logging.Logger = java.util.logging.Logger.getLogger("davx5")
+
+    private lateinit var context: Application
+    private lateinit var preferences: SharedPreferences
+
+
+    fun initialize(app: Application) {
+        context = app
+        preferences = PreferenceManager.getDefaultSharedPreferences(context)
+        preferences.registerOnSharedPreferenceChangeListener(this)
+
+        reinitialize()
+    }
+
+    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String) {
+        if (key == LOG_TO_FILE) {
+            log.info("Logging settings changed; re-initializing logger")
+            reinitialize()
+        }
+    }
+
+    @Synchronized
+    private fun reinitialize() {
+        val logToFile = preferences.getBoolean(LOG_TO_FILE, false)
+        val logVerbose = logToFile || BuildConfig.DEBUG || Log.isLoggable(log.name, Log.DEBUG)
+
+        log.info("Verbose logging: $logVerbose; to file: $logToFile")
+
+        // set logging level according to preferences
+        val rootLogger = java.util.logging.Logger.getLogger("")
+        rootLogger.level = if (logVerbose) Level.ALL else Level.INFO
+
+        // reset all handlers and add our own logcat handler
+        rootLogger.useParentHandlers = false
+        rootLogger.handlers.forEach { handler ->
+            rootLogger.removeHandler(handler)
+            if (handler is FileHandler)     // gracefully close previous verbose-logging FileHandlers
+                handler.close()
+        }
+        rootLogger.addHandler(LogcatHandler)
+
+        val nm = NotificationManagerCompat.from(context)
+        // log to external file according to preferences
+        if (logToFile) {
+            val logDir = debugDir() ?: return
+            val logFile = File(logDir, "davx5-log.txt")
+            if (logFile.createNewFile())
+                logFile.writeText("Log file created at ${Date()}; PID ${Process.myPid()}; UID ${Process.myUid()}\n")
+
+            try {
+                val fileHandler = FileHandler(logFile.toString(), true).apply {
+                    formatter = PlainTextFormatter.DEFAULT
+                }
+                rootLogger.addHandler(fileHandler)
+                log.info("Now logging to file: $logFile")
+
+                val builder = NotificationUtils.newBuilder(context, NotificationUtils.CHANNEL_DEBUG)
+                builder .setSmallIcon(R.drawable.ic_sd_card_notify)
+                        .setContentTitle(context.getString(R.string.app_settings_logging))
+                        .setCategory(NotificationCompat.CATEGORY_STATUS)
+                        .setPriority(NotificationCompat.PRIORITY_HIGH)
+                        .setContentText(context.getString(R.string.logging_notification_text, context.getString(R.string.app_name)))
+                        .setOngoing(true)
+
+                val shareIntent = Intent(Intent.ACTION_SEND, null, context, DebugInfoActivity::class.java)
+                shareIntent.putExtra(DebugInfoActivity.EXTRA_LOG_FILE, logFile.absolutePath)
+                shareIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                val pendingShare = PendingIntent.getActivity(context, 0, shareIntent, PendingIntent.FLAG_UPDATE_CURRENT)
+                builder.addAction(NotificationCompat.Action.Builder(
+                        R.drawable.ic_share,
+                        context.getString(R.string.logging_notification_view_share),
+                        pendingShare
+                ).build())
+
+                val prefIntent = Intent(context, AppSettingsActivity::class.java)
+                prefIntent.putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, LOG_TO_FILE)
+                prefIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                val pendingPref = PendingIntent.getActivity(context, 0, prefIntent, PendingIntent.FLAG_UPDATE_CURRENT)
+                builder.addAction(NotificationCompat.Action.Builder(
+                        R.drawable.ic_settings,
+                        context.getString(R.string.logging_notification_disable),
+                        pendingPref
+                ).build())
+
+                nm.notify(NotificationUtils.NOTIFY_EXTERNAL_FILE_LOGGING, builder.build())
+            } catch(e: IOException) {
+                log.log(Level.SEVERE, "Couldn't create log file", e)
+                Toast.makeText(context, context.getString(R.string.logging_couldnt_create_file), Toast.LENGTH_LONG).show()
+            }
+        } else {
+            // verbose logging is disabled -> cancel notification and remove old logs
+            nm.cancel(NotificationUtils.NOTIFY_EXTERNAL_FILE_LOGGING)
+            debugDir()?.deleteRecursively()
+        }
+    }
+
+
+    private fun debugDir(): File? {
+        val dir = File(context.filesDir, "debug")
+        if (dir.exists() && dir.isDirectory)
+            return dir
+
+        if (dir.mkdir())
+            return dir
+
+        Toast.makeText(context, context.getString(R.string.logging_couldnt_create_file), Toast.LENGTH_LONG).show()
+        return null
+    }
+
+}
@@ -0,0 +1,62 @@
+/*
+ * 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.*
+import java.util.logging.Formatter
+import java.util.logging.LogRecord
+
+class PlainTextFormatter private constructor(
+        private val logcat: Boolean
+): Formatter() {
+
+    companion object {
+        val LOGCAT = PlainTextFormatter(true)
+        val DEFAULT = PlainTextFormatter(false)
+
+        const val MAX_MESSAGE_LENGTH = 20000
+    }
+
+    override fun format(r: LogRecord): String {
+        val builder = StringBuilder()
+
+        if (!logcat)
+            builder .append(DateFormatUtils.format(r.millis, "yyyy-MM-dd HH:mm:ss", Locale.ROOT))
+                    .append(" ").append(r.threadID).append(" ")
+
+        val className = shortClassName(r.sourceClassName)
+        if (className != r.loggerName)
+            builder.append("[").append(className).append("] ")
+
+        builder.append(StringUtils.abbreviate(r.message, MAX_MESSAGE_LENGTH))
+
+        r.thrown?.let {
+            builder .append("\nEXCEPTION ")
+                    .append(ExceptionUtils.getStackTrace(it))
+        }
+
+        r.parameters?.let {
+            for ((idx, param) in it.withIndex())
+                builder.append("\n\tPARAMETER #").append(idx).append(" = ").append(param)
+        }
+
+        if (!logcat)
+            builder.append("\n")
+
+        return builder.toString()
+    }
+
+    private fun shortClassName(className: String) = className
+            .replace(Regex("^at\\.bitfire\\.(dav|cert4an|dav4an|ical4an|vcard4an)droid\\."), "")
+            .replace(Regex("\\$.*$"), "")
+
+}
@@ -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()
+
+}
@@ -0,0 +1,216 @@
+package at.bitfire.davdroid.model
+
+import android.content.Context
+import android.database.sqlite.SQLiteQueryBuilder
+import androidx.core.database.getStringOrNull
+import androidx.room.Database
+import androidx.room.Room
+import androidx.room.RoomDatabase
+import androidx.room.TypeConverters
+import androidx.room.migration.Migration
+import androidx.sqlite.db.SupportSQLiteDatabase
+import at.bitfire.davdroid.AndroidSingleton
+import at.bitfire.davdroid.TextTable
+import at.bitfire.davdroid.log.Logger
+import java.io.Writer
+
+@Suppress("ClassName")
+@Database(entities = [
+    Service::class,
+    HomeSet::class,
+    Collection::class,
+    SyncStats::class
+], exportSchema = true, version = 9)
+@TypeConverters(Converters::class)
+abstract class AppDatabase: RoomDatabase() {
+
+    abstract fun serviceDao(): ServiceDao
+    abstract fun homeSetDao(): HomeSetDao
+    abstract fun collectionDao(): CollectionDao
+    abstract fun syncStatsDao(): SyncStatsDao
+
+    companion object: AndroidSingleton<AppDatabase>() {
+
+        override fun createInstance(context: Context): AppDatabase =
+                Room.databaseBuilder(context.applicationContext, AppDatabase::class.java, "services.db")
+                    .addMigrations(*migrations)
+                    .fallbackToDestructiveMigration()   // as a last fallback, recreate database instead of crashing
+                    .build()
+
+
+        // migrations
+
+        val migrations: Array<Migration> = arrayOf(
+            object : Migration(8, 9) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    db.execSQL("CREATE TABLE syncstats (" +
+                            "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
+                            "collectionId INTEGER NOT NULL REFERENCES collection(id) ON DELETE CASCADE," +
+                            "authority TEXT NOT NULL," +
+                            "lastSync INTEGER NOT NULL)")
+                    db.execSQL("CREATE UNIQUE INDEX index_syncstats_collectionId_authority ON syncstats(collectionId, authority)")
+
+                    db.execSQL("CREATE INDEX index_collection_url ON collection(url)")
+                }
+            },
+
+            object : Migration(7, 8) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    db.execSQL("ALTER TABLE homeset ADD COLUMN personal INTEGER NOT NULL DEFAULT 1")
+                    db.execSQL("ALTER TABLE collection ADD COLUMN homeSetId INTEGER DEFAULT NULL REFERENCES homeset(id) ON DELETE SET NULL")
+                    db.execSQL("ALTER TABLE collection ADD COLUMN owner TEXT DEFAULT NULL")
+                    db.execSQL("CREATE INDEX index_collection_homeSetId_type ON collection(homeSetId, type)")
+                }
+            },
+
+            object : Migration(6, 7) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    db.execSQL("ALTER TABLE homeset ADD COLUMN privBind INTEGER NOT NULL DEFAULT 1")
+                    db.execSQL("ALTER TABLE homeset ADD COLUMN displayName TEXT DEFAULT NULL")
+                }
+            },
+
+            object : Migration(5, 6) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    val sql = arrayOf(
+                        // migrate "services" to "service": rename columns, make id NOT NULL
+                        "CREATE TABLE service(" +
+                                "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
+                                "accountName TEXT NOT NULL," +
+                                "type TEXT NOT NULL," +
+                                "principal TEXT DEFAULT NULL" +
+                                ")",
+                        "CREATE UNIQUE INDEX index_service_accountName_type ON service(accountName, type)",
+                        "INSERT INTO service(id, accountName, type, principal) SELECT _id, accountName, service, principal FROM services",
+                        "DROP TABLE services",
+
+                        // migrate "homesets" to "homeset": rename columns, make id NOT NULL
+                        "CREATE TABLE homeset(" +
+                                "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
+                                "serviceId INTEGER NOT NULL," +
+                                "url TEXT NOT NULL," +
+                                "FOREIGN KEY (serviceId) REFERENCES service(id) ON DELETE CASCADE" +
+                                ")",
+                        "CREATE UNIQUE INDEX index_homeset_serviceId_url ON homeset(serviceId, url)",
+                        "INSERT INTO homeset(id, serviceId, url) SELECT _id, serviceID, url FROM homesets",
+                        "DROP TABLE homesets",
+
+                        // migrate "collections" to "collection": rename columns, make id NOT NULL
+                        "CREATE TABLE collection(" +
+                                "id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT," +
+                                "serviceId INTEGER NOT NULL," +
+                                "type TEXT NOT NULL," +
+                                "url TEXT NOT NULL," +
+                                "privWriteContent INTEGER NOT NULL DEFAULT 1," +
+                                "privUnbind INTEGER NOT NULL DEFAULT 1," +
+                                "forceReadOnly INTEGER NOT NULL DEFAULT 0," +
+                                "displayName TEXT DEFAULT NULL," +
+                                "description TEXT DEFAULT NULL," +
+                                "color INTEGER DEFAULT NULL," +
+                                "timezone TEXT DEFAULT NULL," +
+                                "supportsVEVENT INTEGER DEFAULT NULL," +
+                                "supportsVTODO INTEGER DEFAULT NULL," +
+                                "supportsVJOURNAL INTEGER DEFAULT NULL," +
+                                "source TEXT DEFAULT NULL," +
+                                "sync INTEGER NOT NULL DEFAULT 0," +
+                                "FOREIGN KEY (serviceId) REFERENCES service(id) ON DELETE CASCADE" +
+                                ")",
+                        "CREATE INDEX index_collection_serviceId_type ON collection(serviceId,type)",
+                        "INSERT INTO collection(id, serviceId, type, url, privWriteContent, privUnbind, forceReadOnly, displayName, description, color, timezone, supportsVEVENT, supportsVTODO, source, sync) " +
+                                "SELECT _id, serviceID, type, url, privWriteContent, privUnbind, forceReadOnly, displayName, description, color, timezone, supportsVEVENT, supportsVTODO, source, sync FROM collections",
+                        "DROP TABLE collections"
+                    )
+                    sql.forEach { db.execSQL(it) }
+                }
+            },
+
+            object : Migration(4, 5) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    db.execSQL("ALTER TABLE collections ADD COLUMN privWriteContent INTEGER DEFAULT 0 NOT NULL")
+                    db.execSQL("UPDATE collections SET privWriteContent=NOT readOnly")
+
+                    db.execSQL("ALTER TABLE collections ADD COLUMN privUnbind INTEGER DEFAULT 0 NOT NULL")
+                    db.execSQL("UPDATE collections SET privUnbind=NOT readOnly")
+
+                    // there's no DROP COLUMN in SQLite, so just keep the "readOnly" column
+                }
+            },
+
+            object : Migration(3, 4) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    db.execSQL("ALTER TABLE collections ADD COLUMN forceReadOnly INTEGER DEFAULT 0 NOT NULL")
+                }
+            },
+
+            object : Migration(2, 3) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    // We don't have access to the context in a Room migration now, so
+                    // we will just drop those settings from old DAVx5 versions.
+                    Logger.log.warning("Dropping settings distrustSystemCerts and overrideProxy*")
+
+                    /*val edit = PreferenceManager.getDefaultSharedPreferences(context).edit()
+                    try {
+                        db.query("settings", arrayOf("setting", "value"), null, null, null, null, null).use { cursor ->
+                            while (cursor.moveToNext()) {
+                                when (cursor.getString(0)) {
+                                    "distrustSystemCerts" -> edit.putBoolean(App.DISTRUST_SYSTEM_CERTIFICATES, cursor.getInt(1) != 0)
+                                    "overrideProxy" -> edit.putBoolean(App.OVERRIDE_PROXY, cursor.getInt(1) != 0)
+                                    "overrideProxyHost" -> edit.putString(App.OVERRIDE_PROXY_HOST, cursor.getString(1))
+                                    "overrideProxyPort" -> edit.putInt(App.OVERRIDE_PROXY_PORT, cursor.getInt(1))
+
+                                    StartupDialogFragment.HINT_GOOGLE_PLAY_ACCOUNTS_REMOVED ->
+                                        edit.putBoolean(StartupDialogFragment.HINT_GOOGLE_PLAY_ACCOUNTS_REMOVED, cursor.getInt(1) != 0)
+                                    StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED ->
+                                        edit.putBoolean(StartupDialogFragment.HINT_OPENTASKS_NOT_INSTALLED, cursor.getInt(1) != 0)
+                                }
+                            }
+                        }
+                        db.execSQL("DROP TABLE settings")
+                    } finally {
+                        edit.apply()
+                    }*/
+                }
+            },
+
+            object : Migration(1, 2) {
+                override fun migrate(db: SupportSQLiteDatabase) {
+                    db.execSQL("ALTER TABLE collections ADD COLUMN type TEXT NOT NULL DEFAULT ''")
+                    db.execSQL("ALTER TABLE collections ADD COLUMN source TEXT DEFAULT NULL")
+                    db.execSQL("UPDATE collections SET type=(" +
+                            "SELECT CASE service WHEN ? THEN ? ELSE ? END " +
+                            "FROM services WHERE _id=collections.serviceID" +
+                            ")",
+                            arrayOf("caldav", "CALENDAR", "ADDRESS_BOOK"))
+                }
+            }
+        )
+
+    }
+
+
+    fun dump(writer: Writer) {
+        val db = openHelper.readableDatabase
+        db.beginTransactionNonExclusive()
+
+        // iterate through all tables
+        db.query(SQLiteQueryBuilder.buildQueryString(false, "sqlite_master", arrayOf("name"), "type='table'", null, null, null, null)).use { cursorTables ->
+            while (cursorTables.moveToNext()) {
+                val tableName = cursorTables.getString(0)
+
+                writer.append("$tableName\n")
+                db.query("SELECT * FROM $tableName").use { cursor ->
+                    val table = TextTable(*cursor.columnNames)
+                    val cols = cursor.columnCount
+                    // print rows
+                    while (cursor.moveToNext()) {
+                        val values = Array(cols) { idx -> cursor.getStringOrNull(idx) }
+                        table.addLine(*values)
+                    }
+                    writer.append(table.toString())
+                }
+            }
+            db.endTransaction()
+        }
+    }
+
+}
@@ -0,0 +1,170 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.*
+import at.bitfire.dav4jvm.Response
+import at.bitfire.dav4jvm.UrlUtils
+import at.bitfire.dav4jvm.property.*
+import at.bitfire.davdroid.DavUtils
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import org.apache.commons.lang3.StringUtils
+
+@Entity(tableName = "collection",
+        foreignKeys = [
+            ForeignKey(entity = Service::class, parentColumns = arrayOf("id"), childColumns = arrayOf("serviceId"), onDelete = ForeignKey.CASCADE),
+            ForeignKey(entity = HomeSet::class, parentColumns = arrayOf("id"), childColumns = arrayOf("homeSetId"), onDelete = ForeignKey.SET_NULL)
+        ],
+        indices = [
+            Index("serviceId","type"),
+            Index("homeSetId","type"),
+            Index("url")
+        ]
+)
+data class Collection(
+    @PrimaryKey(autoGenerate = true)
+    override var id: Long = 0,
+
+    var serviceId: Long = 0,
+    var homeSetId: Long? = null,
+
+    var type: String,
+    var url: HttpUrl,
+
+    var privWriteContent: Boolean = true,
+    var privUnbind: Boolean = true,
+    var forceReadOnly: Boolean = false,
+
+    var displayName: String? = null,
+    var description: String? = null,
+    var owner: HttpUrl? = null,
+
+    // CalDAV only
+    var color: Int? = null,
+
+    /** timezone definition (full VTIMEZONE) - not a TZID! **/
+    var timezone: String? = null,
+
+    /** whether the collection supports VEVENT; in case of calendars: null means true */
+    var supportsVEVENT: Boolean? = null,
+
+    /** whether the collection supports VTODO; in case of calendars: null means true */
+    var supportsVTODO: Boolean? = null,
+
+    /** whether the collection supports VJOURNAL; in case of calendars: null means true */
+    var supportsVJOURNAL: Boolean? = null,
+
+    /** Webcal subscription source URL */
+    var source: HttpUrl? = null,
+
+    /** whether this collection has been selected for synchronization */
+    var sync: Boolean = false
+
+): IdEntity() {
+
+    @Ignore
+    var refHomeSet: HomeSet? = null
+
+
+    companion object {
+
+        const val TYPE_ADDRESSBOOK = "ADDRESS_BOOK"
+        const val TYPE_CALENDAR = "CALENDAR"
+        const val TYPE_WEBCAL = "WEBCAL"
+
+        /**
+         * Generates a collection entity from a WebDAV response.
+         * @param dav WebDAV response
+         * @return null if the response doesn't represent a collection
+         */
+        fun fromDavResponse(dav: Response): Collection? {
+            val url = UrlUtils.withTrailingSlash(dav.href)
+            val type: String = dav[ResourceType::class.java]?.let { resourceType ->
+                when {
+                    resourceType.types.contains(ResourceType.ADDRESSBOOK) -> TYPE_ADDRESSBOOK
+                    resourceType.types.contains(ResourceType.CALENDAR)    -> TYPE_CALENDAR
+                    resourceType.types.contains(ResourceType.SUBSCRIBED)  -> TYPE_WEBCAL
+                    else -> null
+                }
+            } ?: return null
+
+            var privWriteContent = true
+            var privUnbind = true
+            dav[CurrentUserPrivilegeSet::class.java]?.let { privilegeSet ->
+                privWriteContent = privilegeSet.mayWriteContent
+                privUnbind = privilegeSet.mayUnbind
+            }
+
+            val displayName = StringUtils.trimToNull(dav[DisplayName::class.java]?.displayName)
+            val owner = dav[Owner::class.java]?.href?.let { ownerHref ->
+                dav.href.resolve(ownerHref)
+            }
+
+            var description: String? = null
+            var color: Int? = null
+            var timezone: String? = null
+            var supportsVEVENT: Boolean? = null
+            var supportsVTODO: Boolean? = null
+            var supportsVJOURNAL: Boolean? = null
+            var source: HttpUrl? = null
+            when (type) {
+                TYPE_ADDRESSBOOK -> {
+                    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
+                        supportsVJOURNAL = true
+                        dav[SupportedCalendarComponentSet::class.java]?.let {
+                            supportsVEVENT = it.supportsEvents
+                            supportsVTODO = it.supportsTasks
+                            supportsVJOURNAL = it.supportsJournal
+                        }
+                    } else { // Type.WEBCAL
+                        dav[Source::class.java]?.let {
+                            source = it.hrefs.firstOrNull()?.let { rawHref ->
+                                val href = rawHref
+                                        .replace("^webcal://".toRegex(), "http://")
+                                        .replace("^webcals://".toRegex(), "https://")
+                                href.toHttpUrlOrNull()
+                            }
+                        }
+                        supportsVEVENT = true
+                    }
+                }
+            }
+
+            return Collection(
+                    type = type,
+                    url = url,
+                    privWriteContent = privWriteContent,
+                    privUnbind = privUnbind,
+                    displayName = displayName,
+                    owner = owner,
+                    description = description,
+                    color = color,
+                    timezone = timezone,
+                    supportsVEVENT = supportsVEVENT,
+                    supportsVTODO = supportsVTODO,
+                    supportsVJOURNAL = supportsVJOURNAL,
+                    source = source
+            )
+        }
+
+    }
+
+
+    // non-persistent properties
+    @Ignore
+    var confirmed: Boolean = false
+
+
+    // calculated properties
+    fun title() = displayName ?: DavUtils.lastSegmentOfUrl(url)
+    fun readOnly() = forceReadOnly || !privWriteContent
+
+}
@@ -0,0 +1,55 @@
+package at.bitfire.davdroid.model
+
+import androidx.lifecycle.LiveData
+import androidx.paging.DataSource
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+
+@Dao
+interface CollectionDao: SyncableDao<Collection> {
+
+    @Query("SELECT * FROM collection WHERE id=:id")
+    fun get(id: Long): Collection?
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId")
+    fun getByService(serviceId: Long): List<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type=:type ORDER BY displayName, url")
+    fun getByServiceAndType(serviceId: Long, type: String): List<Collection>
+
+    /**
+     * Returns collections which
+     *   - support VEVENT and/or VTODO (= supported calendar collections), or
+     *   - have supportsVEVENT = supportsVTODO = null (= address books)
+     */
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type=:type " +
+            "AND (supportsVTODO OR supportsVEVENT OR (supportsVEVENT IS NULL AND supportsVTODO IS NULL)) ORDER BY displayName, URL")
+    fun pageByServiceAndType(serviceId: Long, type: String): DataSource.Factory<Int, Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND sync")
+    fun getByServiceAndSync(serviceId: Long): List<Collection>
+
+    @Query("SELECT collection.* FROM collection, homeset WHERE collection.serviceId=:serviceId AND type=:type AND homeSetId=homeset.id AND homeset.personal ORDER BY collection.displayName, collection.url")
+    fun pagePersonalByServiceAndType(serviceId: Long, type: String): DataSource.Factory<Int, Collection>
+
+    @Query("SELECT * FROM collection WHERE url=:url")
+    fun getByUrl(url: String): Collection?
+
+    @Query("SELECT COUNT(*) FROM collection WHERE serviceId=:serviceId AND sync")
+    fun observeHasSyncByService(serviceId: Long): LiveData<Boolean>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type='${Collection.TYPE_CALENDAR}' AND supportsVEVENT AND sync ORDER BY displayName, url")
+    fun getSyncCalendars(serviceId: Long): List<Collection>
+
+    @Query("SELECT * FROM collection WHERE serviceId=:serviceId AND type='${Collection.TYPE_CALENDAR}' AND supportsVTODO AND sync ORDER BY displayName, url")
+    fun getSyncTaskLists(serviceId: Long): List<Collection>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertOrReplace(collection: Collection)
+
+    @Insert
+    fun insert(collection: Collection)
+
+}
@@ -0,0 +1,17 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.TypeConverter
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+
+class Converters {
+
+    @TypeConverter
+    fun httpUrlToString(url: HttpUrl?) =
+            url?.toString()
+
+    @TypeConverter
+    fun stringToHttpUrl(url: String?): HttpUrl? =
+            url?.toHttpUrlOrNull()
+
+}
@@ -0,0 +1,22 @@
+/*
+ * 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
+) {
+
+    override fun toString(): String {
+        val maskedPassword = "*****".takeIf { password != null }
+        return "Credentials(userName=$userName, password=$maskedPassword, certificateAlias=$certificateAlias)"
+    }
+
+}
@@ -0,0 +1,46 @@
+package at.bitfire.davdroid.model
+
+import at.bitfire.davdroid.log.Logger
+import java.util.logging.Level
+
+class DaoTools<T: IdEntity>(dao: SyncableDao<T>): SyncableDao<T> by dao {
+
+    /**
+     * Synchronizes a list of "old" elements with a list of "new" elements so that the list
+     * only contain equal elements.
+     *
+     * @param allOld      list of old elements
+     * @param allNew      map of new elements (stored in key map)
+     * @param selectKey   generates a unique key from the element (will be called on old elements)
+     * @param prepareNew  prepares new elements (can be used to take over properties of old elements)
+     */
+    fun <K> syncAll(allOld: List<T>, allNew: Map<K,T>, selectKey: (T) -> K, prepareNew: (new: T, old: T) -> Unit = { _, _ -> }) {
+        Logger.log.log(Level.FINE, "Syncing tables", arrayOf(allOld, allNew))
+        val remainingNew = allNew.toMutableMap()
+        allOld.forEach { old ->
+            val key = selectKey(old)
+            val matchingNew = remainingNew[key]
+            if (matchingNew != null) {
+                // keep this old item, but maybe update it
+                matchingNew.id = old.id     // identity is proven by key
+                prepareNew(matchingNew, old)
+
+                if (matchingNew != old)
+                    update(matchingNew)
+
+                // remove from remainingNew
+                remainingNew -= key
+            } else {
+                // this old item is not present anymore, delete it
+                delete(old)
+            }
+        }
+
+        val toInsert = remainingNew.values.toList()
+        val insertIds = insert(toInsert)
+        insertIds.withIndex().forEach { (idx, id) ->
+            toInsert[idx].id = id
+        }
+    }
+
+}
@@ -0,0 +1,34 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import okhttp3.HttpUrl
+
+@Entity(tableName = "homeset",
+        foreignKeys = [
+            ForeignKey(entity = Service::class, parentColumns = arrayOf("id"), childColumns = arrayOf("serviceId"), onDelete = ForeignKey.CASCADE)
+        ],
+        indices = [
+            // index by service; no duplicate URLs per service
+            Index("serviceId", "url", unique = true)
+        ]
+)
+data class HomeSet(
+    @PrimaryKey(autoGenerate = true)
+    override var id: Long,
+
+    var serviceId: Long,
+
+    /**
+     * Whether this homeset belongs to the [Service.principal] given by [serviceId].
+     */
+    var personal: Boolean,
+
+    var url: HttpUrl,
+
+    var privBind: Boolean = true,
+
+    var displayName: String? = null
+): IdEntity()
@@ -0,0 +1,24 @@
+package at.bitfire.davdroid.model
+
+import androidx.lifecycle.LiveData
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+
+@Dao
+interface HomeSetDao: SyncableDao<HomeSet> {
+
+    @Query("SELECT * FROM homeset WHERE serviceId=:serviceId")
+    fun getByService(serviceId: Long): List<HomeSet>
+
+    @Query("SELECT * FROM homeset WHERE serviceId=:serviceId AND privBind")
+    fun getBindableByService(serviceId: Long): List<HomeSet>
+
+    @Query("SELECT COUNT(*) FROM homeset WHERE serviceId=:serviceId AND privBind")
+    fun hasBindableByService(serviceId: Long): LiveData<Boolean>
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertOrReplace(homeSet: HomeSet): Long
+
+}
@@ -0,0 +1,5 @@
+package at.bitfire.davdroid.model
+
+abstract class IdEntity {
+    abstract var id: Long
+}
@@ -0,0 +1,28 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Entity
+import androidx.room.Index
+import androidx.room.PrimaryKey
+import okhttp3.HttpUrl
+
+@Entity(tableName = "service",
+        indices = [
+            // only one service per type and account
+            Index("accountName", "type", unique = true)
+        ])
+data class Service(
+    @PrimaryKey(autoGenerate = true)
+    var id: Long,
+
+    var accountName: String,
+    var type: String,
+
+    var principal: HttpUrl?
+) {
+
+    companion object {
+        const val TYPE_CALDAV = "caldav"
+        const val TYPE_CARDDAV = "carddav"
+    }
+
+}
@@ -0,0 +1,33 @@
+package at.bitfire.davdroid.model
+
+import androidx.lifecycle.LiveData
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+import androidx.room.Query
+
+@Dao
+interface ServiceDao {
+
+    @Query("SELECT * FROM service WHERE accountName=:accountName AND type=:type")
+    fun getByAccountAndType(accountName: String, type: String): Service?
+
+    @Query("SELECT id FROM service WHERE accountName=:accountName AND type=:type")
+    fun getIdByAccountAndType(accountName: String, type: String): LiveData<Long>
+
+    @Query("SELECT * FROM service WHERE id=:id")
+    fun get(id: Long): Service?
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertOrReplace(service: Service): Long
+
+    @Query("DELETE FROM service")
+    fun deleteAll()
+
+    @Query("DELETE FROM service WHERE accountName NOT IN (:accountNames)")
+    fun deleteExceptAccounts(accountNames: Array<String>)
+
+    @Query("UPDATE service SET accountName=:newName WHERE accountName=:oldName")
+    fun renameAccount(oldName: String, newName: String)
+
+}
@@ -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.model
+
+import at.bitfire.dav4jvm.property.SyncToken
+import org.json.JSONException
+import org.json.JSONObject
+
+data class SyncState(
+        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
+) {
+
+    companion object {
+
+        private const val KEY_TYPE = "type"
+        private const val KEY_VALUE = "value"
+        private const val KEY_INITIAL_SYNC = "initialSync"
+
+        fun fromString(s: String?): SyncState? {
+            if (s == null)
+                return null
+
+            return try {
+                val json = JSONObject(s)
+                SyncState(
+                        Type.valueOf(json.getString(KEY_TYPE)),
+                        json.getString(KEY_VALUE),
+                        try { json.getBoolean(KEY_INITIAL_SYNC) } catch(e: JSONException) { null }
+                )
+            } catch (e: JSONException) {
+                null
+            }
+        }
+
+        fun fromSyncToken(token: SyncToken, initialSync: Boolean? = null) =
+                SyncState(Type.SYNC_TOKEN, requireNotNull(token.token), initialSync)
+
+    }
+
+    enum class Type { CTAG, SYNC_TOKEN }
+
+    override fun toString(): String {
+        val json = JSONObject()
+        json.put(KEY_TYPE, type.name)
+        json.put(KEY_VALUE, value)
+        initialSync?.let { json.put(KEY_INITIAL_SYNC, it) }
+        return json.toString()
+    }
+
+}
@@ -0,0 +1,24 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Entity
+import androidx.room.ForeignKey
+import androidx.room.Index
+import androidx.room.PrimaryKey
+
+@Entity(tableName = "syncstats",
+    foreignKeys = [
+        ForeignKey(childColumns = arrayOf("collectionId"), entity = Collection::class, parentColumns = arrayOf("id"), onDelete = ForeignKey.CASCADE)
+    ],
+    indices = [
+        Index("collectionId", "authority", unique = true),
+    ]
+)
+data class SyncStats(
+    @PrimaryKey(autoGenerate = true)
+    val id: Long,
+
+    val collectionId: Long,
+    val authority: String,
+
+    var lastSync: Long
+)
@@ -0,0 +1,13 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Dao
+import androidx.room.Insert
+import androidx.room.OnConflictStrategy
+
+@Dao
+interface SyncStatsDao {
+
+    @Insert(onConflict = OnConflictStrategy.REPLACE)
+    fun insertOrReplace(syncStats: SyncStats)
+
+}
@@ -0,0 +1,18 @@
+package at.bitfire.davdroid.model
+
+import androidx.room.Delete
+import androidx.room.Insert
+import androidx.room.Update
+
+interface SyncableDao<T: IdEntity> {
+
+    @Insert
+    fun insert(items: List<T>): LongArray
+
+    @Update
+    fun update(item: T)
+
+    @Delete
+    fun delete(item: T)
+
+}
@@ -0,0 +1,21 @@
+/*
+ * 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.provider.ContactsContract.RawContacts
+
+object UnknownProperties {
+
+    const val CONTENT_ITEM_TYPE = "x.davdroid/unknown-properties"
+
+    const val MIMETYPE = RawContacts.Data.MIMETYPE
+    const val RAW_CONTACT_ID = RawContacts.Data.RAW_CONTACT_ID
+    const val UNKNOWN_PROPERTIES = RawContacts.Data.DATA1
+
+}
@@ -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()
+
+}
@@ -0,0 +1,374 @@
+/*
+ * 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.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.Collection
+import at.bitfire.davdroid.model.SyncState
+import at.bitfire.davdroid.syncadapter.AccountUtils
+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: Collection): LocalAddressBook {
+            val account = Account(accountName(mainAccount, info), context.getString(R.string.account_type_address_book))
+            val userData = initialUserData(mainAccount, info.url.toString())
+            Logger.log.log(Level.INFO, "Creating local address book $account", userData)
+            if (!AccountUtils.createAccount(context, account, userData))
+                throw IllegalStateException("Couldn't create address book account")
+
+            val addressBook = LocalAddressBook(context, account, provider)
+            ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 1)
+            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
+            addressBook.readOnly = !info.privWriteContent || info.forceReadOnly
+
+            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 {
+                    try {
+                        it.mainAccount == mainAccount
+                    } catch(e: IllegalStateException) {
+                        false
+                    }
+                }
+                .toList()
+
+        fun accountName(mainAccount: Account, info: Collection): String {
+            val baos = ByteArrayOutputStream()
+            baos.write(info.url.hashCode())
+            val hash = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP or Base64.NO_PADDING)
+
+            val sb = StringBuilder(info.displayName.let {
+                if (it.isNullOrEmpty())
+                    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 tag: String
+        get() = "contacts-${account.name}"
+
+    override val title = account.name!!
+
+    /**
+     * Whether contact groups ([LocalGroup]) are included in query results
+     * and are affected by updates/deletes on generic members.
+     *
+     * For instance, if 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
+    /**
+     * The associated main account which this address book accounts belongs to.
+     * @throws IllegalStateException when no main account is assigned
+     */
+    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("No main account assigned to address book account")
+            }
+        }
+        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)
+
+    override 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, "NOT ${Groups.DIRTY}", null)
+        }
+
+        return number
+    }
+
+    override fun removeNotDirtyMarked(flags: Int): Int {
+        var number = provider!!.delete(rawContactsSyncUri(),
+                "NOT ${RawContacts.DIRTY} AND ${LocalContact.COLUMN_FLAGS}=?", arrayOf(flags.toString()))
+
+        if (includeGroups)
+            number += provider.delete(groupsSyncUri(),
+                    "NOT ${Groups.DIRTY} AND ${LocalGroup.COLUMN_FLAGS}=?", arrayOf(flags.toString()))
+
+        return number
+    }
+
+    fun update(info: Collection) {
+        val newAccountName = accountName(mainAccount, info)
+
+        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
+        }
+
+        val nowReadOnly = !info.privWriteContent || info.forceReadOnly
+        if (nowReadOnly != readOnly) {
+            Constants.log.info("Address book now read-only = $nowReadOnly, updating contacts")
+
+            // update address book itself
+            readOnly = nowReadOnly
+
+            // update raw contacts
+            val rawContactValues = ContentValues(1)
+            rawContactValues.put(RawContacts.RAW_CONTACT_IS_READ_ONLY, if (nowReadOnly) 1 else 0)
+            provider!!.update(rawContactsSyncUri(), rawContactValues, null, null)
+
+            // update data rows
+            val dataValues = ContentValues(1)
+            dataValues.put(ContactsContract.Data.IS_READ_ONLY, if (nowReadOnly) 1 else 0)
+            provider.update(syncAdapterURI(ContactsContract.Data.CONTENT_URI), dataValues, null, null)
+        }
+
+        // make sure it will still be synchronized when contacts are updated
+        if (ContentResolver.getIsSyncable(account, ContactsContract.AUTHORITY) <= 0)
+            ContentResolver.setIsSyncable(account, ContactsContract.AUTHORITY, 1)
+        if (!ContentResolver.getSyncAutomatically(account, ContactsContract.AUTHORITY))
+            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, null)
+    fun findDeletedGroups() = queryGroups(Groups.DELETED, null)
+
+    /**
+     * Returns an array of local contacts/groups which have been changed locally (DIRTY != 0).
+     * @throws RemoteException on content provider errors
+     */
+    override fun findDirty() =
+            if (includeGroups)
+                findDirtyContacts() + findDirtyGroups()
+            else
+                findDirtyContacts()
+    fun findDirtyContacts() = queryContacts(RawContacts.DIRTY, null)
+    fun findDirtyGroups() = queryGroups(Groups.DIRTY, null)
+
+    override fun forgetETags() {
+        if (includeGroups) {
+            val values = ContentValues(1)
+            values.putNull(AndroidGroup.COLUMN_ETAG)
+            provider!!.update(groupsSyncUri(), values, null, null)
+        }
+        val values = ContentValues(1)
+        values.putNull(AndroidContact.COLUMN_ETAG)
+        provider!!.update(rawContactsSyncUri(), values, null, null)
+    }
+
+
+    /**
+     * 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) ?: throw RemoteException("Couldn't create contact group")
+        return ContentUris.parseId(uri)
+    }
+
+    fun removeEmptyGroups() {
+        // find groups without members
+        /** should be done using {@link Groups.SUMMARY_COUNT}, but it's not implemented in Android yet */
+        queryGroups(null, null).filter { it.getMembers().isEmpty() }.forEach { group ->
+            Logger.log.log(Level.FINE, "Deleting group", group)
+            group.delete()
+        }
+    }
+
+}
@@ -0,0 +1,261 @@
+/*
+ * 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.ContentUris
+import android.content.ContentValues
+import android.net.Uri
+import android.provider.CalendarContract.Calendars
+import android.provider.CalendarContract.Events
+import at.bitfire.davdroid.Constants
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.Collection
+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: Collection): Uri {
+            val values = valuesFromCollectionInfo(info, true)
+
+            // ACCOUNT_NAME and ACCOUNT_TYPE are required (see docs)! If it's missing, other apps will crash.
+            values.put(Calendars.ACCOUNT_NAME, account.name)
+            values.put(Calendars.ACCOUNT_TYPE, account.type)
+
+            // Email address for scheduling. Used by the calendar provider to determine whether the
+            // user is ORGANIZER/ATTENDEE for a certain event.
+            values.put(Calendars.OWNER_ACCOUNT, account.name)
+
+            // flag as visible & synchronizable at creation, might be changed by user at any time
+            values.put(Calendars.VISIBLE, 1)
+            values.put(Calendars.SYNC_EVENTS, 1)
+            return create(account, provider, values)
+        }
+
+        private fun valuesFromCollectionInfo(info: Collection, withColor: Boolean): ContentValues {
+            val values = ContentValues()
+            values.put(Calendars.NAME, info.url.toString())
+            values.put(Calendars.CALENDAR_DISPLAY_NAME, if (info.displayName.isNullOrBlank()) 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)
+                }
+            }
+
+            // add base values for Calendars
+            values.putAll(calendarBaseValues)
+
+            return values
+        }
+    }
+
+    override val tag: String
+        get() = "events-${account.name}-$id"
+
+    override val title: String
+        get() = displayName ?: id.toString()
+
+    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: Collection, updateColor: Boolean) =
+            update(valuesFromCollectionInfo(info, updateColor))
+
+
+    override fun findDeleted() =
+            queryEvents("${Events.DELETED} AND ${Events.ORIGINAL_ID} IS NULL", null)
+
+    override fun findDirty(): List<LocalEvent> {
+        val dirty = LinkedList<LocalEvent>()
+
+        /*
+         * RFC 5545 3.8.7.4. Sequence Number
+         * When a calendar component is created, its sequence number is 0. It is monotonically incremented by the "Organizer's"
+         * CUA each time the "Organizer" makes a significant revision to the calendar component.
+         */
+        for (localEvent in queryEvents("${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NULL", null)) {
+            try {
+                val event = requireNotNull(localEvent.event)
+
+                val nonGroupScheduled = event.attendees.isEmpty()
+                val weAreOrganizer = localEvent.weAreOrganizer
+
+                val sequence = event.sequence
+                if (sequence == null)
+                    // sequence has not been assigned yet (i.e. this event was just locally created)
+                    event.sequence = 0
+                else if (nonGroupScheduled || weAreOrganizer)   // increase sequence
+                    event.sequence = sequence + 1
+
+            } catch(e: Exception) {
+                Logger.log.log(Level.WARNING, "Couldn't check/increase sequence", e)
+            }
+            dirty += localEvent
+        }
+
+        return dirty
+    }
+
+    override fun findByName(name: String) =
+            queryEvents("${Events._SYNC_ID}=?", arrayOf(name)).firstOrNull()
+
+
+    override fun markNotDirty(flags: Int): Int {
+        val values = ContentValues(1)
+        values.put(LocalEvent.COLUMN_FLAGS, flags)
+        return provider.update(eventsSyncURI(), values,
+                "${Events.CALENDAR_ID}=? AND NOT ${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NULL",
+                arrayOf(id.toString()))
+    }
+
+    override fun removeNotDirtyMarked(flags: Int): Int {
+        var deleted = 0
+        // list all non-dirty events with the given flags and delete every row + its exceptions
+        provider.query(eventsSyncURI(), arrayOf(Events._ID),
+                "${Events.CALENDAR_ID}=? AND NOT ${Events.DIRTY} AND ${Events.ORIGINAL_ID} IS NULL AND ${LocalEvent.COLUMN_FLAGS}=?",
+                arrayOf(id.toString(), flags.toString()), null)?.use { cursor ->
+            val batch = BatchOperation(provider)
+            while (cursor.moveToNext()) {
+                val id = cursor.getLong(0)
+                // delete event and possible exceptions (content provider doesn't delete exceptions itself)
+                batch.enqueue(BatchOperation.CpoBuilder
+                        .newDelete(eventsSyncURI())
+                        .withSelection("${Events._ID}=? OR ${Events.ORIGINAL_ID}=?", arrayOf(id.toString(), id.toString())))
+            }
+            deleted = batch.commit()
+        }
+        return deleted
+    }
+
+    override fun forgetETags() {
+        val values = ContentValues(1)
+        values.putNull(LocalEvent.COLUMN_ETAG)
+        provider.update(eventsSyncURI(), values, "${Events.CALENDAR_ID}=?",
+                arrayOf(id.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} 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.CpoBuilder
+                                .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.CpoBuilder.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} AND ${Events.ORIGINAL_ID} IS NOT NULL",
+                arrayOf(id.toString()), null)?.use { cursor ->
+            while (cursor.moveToNext()) {
+                Logger.log.fine("Found dirty exception, increasing SEQUENCE to re-schedule")
+                val id = cursor.getLong(0)             // can't be null (by definition)
+                val originalID = cursor.getLong(1)     // can't be null (by query)
+                val sequence = if (cursor.isNull(2)) 0 else cursor.getInt(2)
+
+                val batch = BatchOperation(provider)
+                // original event to DIRTY
+                batch.enqueue(BatchOperation.CpoBuilder
+                        .newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, originalID)))
+                        .withValue(Events.DIRTY, 1))
+                // increase SEQUENCE and set DIRTY to 0
+                batch.enqueue(BatchOperation.CpoBuilder
+                        .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)
+
+    }
+
+}
@@ -0,0 +1,77 @@
+/*
+ * 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<*>> {
+
+    /** a tag that uniquely identifies the collection (DAVx5-wide) */
+    val tag: String
+
+    /** collection title (used for user notifications etc.) **/
+    val title: String
+
+    var lastSyncState: SyncState?
+
+    /**
+     * Finds local resources of this collection which have been marked as *deleted* by the user
+     * or an app acting on their behalf.
+     *
+     * @return list of resources marked as *deleted*
+     */
+    fun findDeleted(): List<T>
+
+    /**
+     * Finds local resources of this collection which have been marked as *dirty*, i.e. resources
+     * which have been modified by the user or an app acting on their behalf.
+     *
+     * @return list of resources marked as *dirty*
+     */
+    fun findDirty(): List<T>
+
+    /**
+     * Finds a local resource of this collection with a given file name. (File names are assigned
+     * by the sync adapter.)
+     *
+     * @param name file name to look for
+     * @return resource with the given name, or null if none
+     */
+    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
+
+
+    /**
+     * Forgets the ETags of all members so that they will be reloaded from the server during sync.
+     */
+    fun forgetETags()
+
+}
@@ -0,0 +1,260 @@
+/*
+ * 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.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 org.apache.commons.lang3.StringUtils
+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 scheduleTag: String?
+        get() = null
+        set(_) = throw NotImplementedError()
+
+    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 prepareForUpload(): String {
+        var uid: String? = null
+        addressBook.provider!!.query(rawContactSyncURI(), arrayOf(COLUMN_UID), null, null, null)?.use { cursor ->
+            if (cursor.moveToNext())
+                uid = StringUtils.trimToNull(cursor.getString(0))
+        }
+
+        if (uid == null) {
+            // generate new UID
+            uid = UUID.randomUUID().toString()
+
+            val values = ContentValues(1)
+            values.put(COLUMN_UID, uid)
+            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+
+            contact!!.uid = uid
+        }
+
+        return "$uid.vcf"
+    }
+
+    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
+        if (scheduleTag != null)
+            throw IllegalArgumentException("Contacts must not have a Schedule-Tag")
+
+        val values = ContentValues(4)
+        if (fileName != null)
+            values.put(COLUMN_FILENAME, fileName)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(ContactsContract.RawContacts.DIRTY, 0)
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.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)
+
+        if (fileName != null)
+            this.fileName = fileName
+        this.eTag = eTag
+    }
+
+    override fun resetDeleted() {
+        val values = ContentValues(1)
+        values.put(ContactsContract.Groups.DELETED, 0)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+    }
+
+    fun resetDirty() {
+        val values = ContentValues(1)
+        values.put(ContactsContract.RawContacts.DIRTY, 0)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+    }
+
+    override fun updateFlags(flags: Int) {
+        val values = ContentValues(1)
+        values.put(COLUMN_FLAGS, flags)
+        addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+
+        this.flags = flags
+    }
+
+
+    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 builder = insertDataBuilder(UnknownProperties.RAW_CONTACT_ID)
+                    .withValue(UnknownProperties.MIMETYPE, UnknownProperties.CONTENT_ITEM_TYPE)
+                    .withValue(UnknownProperties.UNKNOWN_PROPERTIES, unknownProperties)
+            batch.enqueue(builder)
+        }
+    }
+
+
+    /**
+     * 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 hashCode = dataHashCode()
+        Logger.log.fine("Storing contact hash = $hashCode")
+
+        if (batch == null) {
+            val values = ContentValues(1)
+            values.put(COLUMN_HASHCODE, hashCode)
+            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
+        } else
+            batch.enqueue(BatchOperation.CpoBuilder
+                    .newUpdate(rawContactSyncURI())
+                    .withValue(COLUMN_HASHCODE, hashCode))
+    }
+
+    fun getLastHashCode(): Int {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.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.CpoBuilder
+                .newInsert(dataSyncURI())
+                .withValue(GroupMembership.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE)
+                .withValue(GroupMembership.RAW_CONTACT_ID, id)
+                .withValue(GroupMembership.GROUP_ROW_ID, groupID))
+        groupMemberships += groupID
+
+        batch.enqueue(BatchOperation.CpoBuilder
+                .newInsert(dataSyncURI())
+                .withValue(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
+                .withValue(CachedGroupMembership.RAW_CONTACT_ID, id)
+                .withValue(CachedGroupMembership.GROUP_ID, groupID)
+        )
+        cachedGroupMemberships += groupID
+    }
+
+    fun removeGroupMemberships(batch: BatchOperation) {
+        batch.enqueue(BatchOperation.CpoBuilder
+                .newDelete(dataSyncURI())
+                .withSelection(
+                        "${Data.RAW_CONTACT_ID}=? AND ${Data.MIMETYPE} IN (?,?)",
+                        arrayOf(id.toString(), GroupMembership.CONTENT_ITEM_TYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
+                ))
+        groupMemberships.clear()
+        cachedGroupMemberships.clear()
+    }
+
+    /**
+     * Returns the IDs of all groups the contact was member of (cached memberships).
+     * Cached memberships are kept in sync with memberships by DAVx5 and are used to determine
+     * whether a membership has been deleted/added when a raw contact is dirty.
+     * @return set of {@link GroupMembership#GROUP_ROW_ID} (may be empty)
+     * @throws FileNotFoundException if the current contact can't be found
+     * @throws RemoteException on contacts provider errors
+     */
+    fun getCachedGroupMemberships(): Set<Long> {
+        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: BatchOperation.CpoBuilder, update: Boolean) {
+        builder.withValue(COLUMN_FLAGS, flags)
+        super.buildContact(builder, update)
+    }
+
+    // factory
+
+    object Factory: AndroidContactFactory<LocalContact> {
+        override fun fromProvider(addressBook: AndroidAddressBook<LocalContact, *>, values: ContentValues) =
+                LocalContact(addressBook, values)
+    }
+
+}
@@ -0,0 +1,145 @@
+/*
+ * 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.ContentValues
+import android.provider.CalendarContract.Events
+import at.bitfire.davdroid.BuildConfig
+import at.bitfire.ical4android.*
+import net.fortuna.ical4j.model.property.ProdId
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+
+class LocalEvent: AndroidEvent, LocalResource<Event> {
+
+    companion object {
+        init {
+            ICalendar.prodId = ProdId("${BuildConfig.userAgent}/${BuildConfig.VERSION_NAME} ical4j/" + Ical4Android.ical4jVersion)
+        }
+
+        const val COLUMN_ETAG = Events.SYNC_DATA1
+        const val COLUMN_FLAGS = Events.SYNC_DATA2
+        const val COLUMN_SEQUENCE = Events.SYNC_DATA3
+        const val COLUMN_SCHEDULE_TAG = Events.SYNC_DATA4
+    }
+
+    override var fileName: String? = null
+        private set
+
+    override var eTag: String? = null
+    override var scheduleTag: String? = null
+
+    override var flags: Int = 0
+        private set
+
+    var weAreOrganizer = false
+        private set
+
+
+    constructor(calendar: AndroidCalendar<*>, event: Event, fileName: String?, eTag: String?, scheduleTag: String?, flags: Int): super(calendar, event) {
+        this.fileName = fileName
+        this.eTag = eTag
+        this.scheduleTag = scheduleTag
+        this.flags = flags
+    }
+
+    private constructor(calendar: AndroidCalendar<*>, values: ContentValues): super(calendar, values) {
+        fileName = values.getAsString(Events._SYNC_ID)
+        eTag = values.getAsString(COLUMN_ETAG)
+        scheduleTag = values.getAsString(COLUMN_SCHEDULE_TAG)
+        flags = values.getAsInteger(COLUMN_FLAGS) ?: 0
+    }
+
+    override fun populateEvent(row: ContentValues, groupScheduled: Boolean) {
+        val event = requireNotNull(event)
+
+        event.uid = row.getAsString(Events.UID_2445)
+        event.sequence = row.getAsInteger(COLUMN_SEQUENCE)
+
+        val isOrganizer = row.getAsInteger(Events.IS_ORGANIZER)
+        weAreOrganizer = isOrganizer != null && isOrganizer != 0
+
+        super.populateEvent(row, groupScheduled)
+    }
+
+    override fun buildEvent(recurrence: Event?, builder: BatchOperation.CpoBuilder) {
+        val event = requireNotNull(event)
+
+        val buildException = recurrence != null
+        val eventToBuild = recurrence ?: event
+
+        builder .withValue(Events.UID_2445, event.uid)
+                .withValue(COLUMN_SEQUENCE, eventToBuild.sequence)
+                .withValue(Events.DIRTY, 0)
+                .withValue(Events.DELETED, 0)
+                .withValue(COLUMN_FLAGS, flags)
+
+        if (buildException)
+            builder .withValue(Events.ORIGINAL_SYNC_ID, fileName)
+        else
+            builder .withValue(Events._SYNC_ID, fileName)
+                    .withValue(COLUMN_ETAG, eTag)
+                    .withValue(COLUMN_SCHEDULE_TAG, scheduleTag)
+
+        super.buildEvent(recurrence, builder)
+    }
+
+
+    override fun prepareForUpload(): String {
+        var uid: String? = null
+        calendar.provider.query(eventSyncURI(), arrayOf(Events.UID_2445), null, null, null)?.use { cursor ->
+            if (cursor.moveToNext())
+                uid = StringUtils.trimToNull(cursor.getString(0))
+        }
+
+        if (uid == null) {
+            // generate new UID
+            uid = UUID.randomUUID().toString()
+
+            val values = ContentValues(1)
+            values.put(Events.UID_2445, uid)
+            calendar.provider.update(eventSyncURI(), values, null, null)
+
+            event!!.uid = uid
+        }
+
+        return "$uid.ics"
+    }
+
+    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
+        val values = ContentValues(5)
+        if (fileName != null)
+            values.put(Events._SYNC_ID, fileName)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(COLUMN_SCHEDULE_TAG, scheduleTag)
+        values.put(COLUMN_SEQUENCE, event!!.sequence)
+        values.put(Events.DIRTY, 0)
+        calendar.provider.update(eventSyncURI(), values, null, null)
+
+        if (fileName != null)
+            this.fileName = fileName
+        this.eTag = eTag
+        this.scheduleTag = scheduleTag
+    }
+
+    override fun updateFlags(flags: Int) {
+        val values = ContentValues(1)
+        values.put(COLUMN_FLAGS, flags)
+        calendar.provider.update(eventSyncURI(), values, null, null)
+
+        this.flags = flags
+    }
+
+
+    object Factory: AndroidEventFactory<LocalEvent> {
+        override fun fromProvider(calendar: AndroidCalendar<*>, values: ContentValues) =
+                LocalEvent(calendar, values)
+    }
+
+}
@@ -0,0 +1,259 @@
+/*
+ * 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.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.vcard4android.*
+import org.apache.commons.lang3.StringUtils
+import java.util.*
+
+class LocalGroup: AndroidGroup, LocalAddress {
+
+    companion object {
+
+        const val COLUMN_FLAGS = Groups.SYNC4
+
+        /** marshalled list of member UIDs, as sent by server */
+        const val COLUMN_PENDING_MEMBERS = Groups.SYNC3
+
+        /**
+         * Processes all groups with non-null [COLUMN_PENDING_MEMBERS]: the pending memberships
+         * are applied (if possible) to keep 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.CpoBuilder
+                            .newUpdate(addressBook.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, id)))
+                            .withValue(COLUMN_PENDING_MEMBERS, null))
+
+                    batch.commit()
+                }
+            }
+        }
+
+    }
+
+
+    override var scheduleTag: String?
+        get() = null
+        set(value) = throw NotImplementedError()
+
+    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 prepareForUpload(): String {
+        var uid: String? = null
+        addressBook.provider!!.query(groupSyncUri(), arrayOf(AndroidContact.COLUMN_UID), null, null, null)?.use { cursor ->
+            if (cursor.moveToNext())
+                uid = StringUtils.trimToNull(cursor.getString(0))
+        }
+
+        if (uid == null) {
+            // generate new UID
+            uid = UUID.randomUUID().toString()
+
+            val values = ContentValues(1)
+            values.put(AndroidContact.COLUMN_UID, uid)
+            addressBook.provider!!.update(groupSyncUri(), values, null, null)
+
+            contact!!.uid = uid
+        }
+
+        return "$uid.vcf"
+    }
+
+    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
+        if (scheduleTag != null)
+            throw IllegalArgumentException("Contact groups must not have a Schedule-Tag")
+        val id = requireNotNull(id)
+
+        val values = ContentValues(3)
+        if (fileName != null)
+            values.put(COLUMN_FILENAME, fileName)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(Groups.DIRTY, 0)
+        update(values)
+
+        if (fileName != null)
+            this.fileName = fileName
+        this.eTag = eTag
+
+        // update cached group memberships
+        val batch = BatchOperation(addressBook.provider!!)
+
+        // delete cached group memberships
+        batch.enqueue(BatchOperation.CpoBuilder
+                .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.CpoBuilder
+                    .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))
+
+        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.CpoBuilder
+                    .newUpdate(addressBook.syncAdapterURI(ContentUris.withAppendedId(RawContacts.CONTENT_URI, member)))
+                    .withValue(RawContacts.DIRTY, 1))
+
+        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(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)
+    }
+
+}
@@ -0,0 +1,97 @@
+/*
+ * 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?
+
+    /**
+     * Remote file name for the resource, for instance `mycontact.vcf`. Also used to determine whether
+     * a dirty record has just been created (in this case, [fileName] is *null*) or modified
+     * (in this case, [fileName] is the remote file name).
+     */
+    val fileName: String?
+
+    /** remote ETag for the resource */
+    var eTag: String?
+
+    /** remote Schedule-Tag for the resource */
+    var scheduleTag: String?
+
+    /** bitfield of flags; currently either [FLAG_REMOTELY_PRESENT] or 0 */
+    val flags: Int
+
+    /**
+     * Prepares the resource for uploading:
+     *
+     *   1. If the resource doesn't have an UID yet, this method generates one and writes it to the content provider.
+     *   2. The new file name which can be used for the upload is derived from the UID and returned, but not
+     *   saved to the content provider. The sync manager is responsible for saving the file name that
+     *   was actually used.
+     *
+     * @return new file name of the resource (like "<uid>.vcf")
+     */
+    fun prepareForUpload(): String
+
+    /**
+     * Unsets the /dirty/ field of the resource. Typically used after successfully uploading a
+     * locally modified resource.
+     *
+     * @param fileName If this argument is not *null*, [LocalResource.fileName] will be set to its value.
+     * @param eTag ETag of the uploaded resource as returned by the server (null if the server didn't return one)
+     * @param scheduleTag CalDAV Schedule-Tag of the uploaded resource as returned by the server (null if not applicable or if the server didn't return one)
+     */
+    fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String? = null)
+
+    /**
+     * Sets (local) flags of the resource. At the moment, the only allowed values are
+     * 0 and [FLAG_REMOTELY_PRESENT].
+     */
+    fun updateFlags(flags: Int)
+
+
+    /**
+     * Adds the data object to the content provider and ensures that the dirty flag is clear.
+     *
+     * @return content URI of the created row (e.g. event URI)
+     */
+    fun add(): Uri
+
+    /**
+     * Updates the data object in the content provider and ensures that the dirty flag is clear.
+     *
+     * @return content URI of the updated row (e.g. event URI)
+     */
+    fun update(data: TData): Uri
+
+    /**
+     * Deletes the data object from the content provider.
+     *
+     * @return number of affected rows
+     */
+    fun delete(): Int
+
+}
@@ -0,0 +1,113 @@
+/*
+ * 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.ContentValues
+import at.bitfire.ical4android.*
+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 scheduleTag: 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: BatchOperation.CpoBuilder, update: Boolean) {
+        super.buildTask(builder, update)
+
+        builder .withValue(Tasks._SYNC_ID, fileName)
+                .withValue(COLUMN_ETAG, eTag)
+                .withValue(COLUMN_FLAGS, flags)
+    }
+
+
+    /* custom queries */
+
+    override fun prepareForUpload(): String {
+        var uid: String? = null
+        taskList.provider.client.query(taskSyncURI(), arrayOf(Tasks._UID), null, null, null)?.use { cursor ->
+            if (cursor.moveToNext())
+                uid = cursor.getString(0)
+        }
+
+        if (uid == null) {
+            // generate new UID
+            uid = UUID.randomUUID().toString()
+
+            val values = ContentValues(1)
+            values.put(Tasks._UID, uid)
+            taskList.provider.client.update(taskSyncURI(), values, null, null)
+
+            task!!.uid = uid
+        }
+
+        return "$uid.ics"
+    }
+
+    override fun clearDirty(fileName: String?, eTag: String?, scheduleTag: String?) {
+        if (scheduleTag != null)
+            Ical4Android.log.fine("Schedule-Tag for tasks not supported yet, won't save")
+
+        val values = ContentValues(4)
+        if (fileName != null)
+            values.put(Tasks._SYNC_ID, fileName)
+        values.put(COLUMN_ETAG, eTag)
+        values.put(Tasks.SYNC_VERSION, task!!.sequence)
+        values.put(Tasks._DIRTY, 0)
+        taskList.provider.client.update(taskSyncURI(), values, null, null)
+
+        if (fileName != null)
+            this.fileName = fileName
+        this.eTag = eTag
+    }
+
+    override fun updateFlags(flags: Int) {
+        if (id != null) {
+            val values = ContentValues(1)
+            values.put(COLUMN_FLAGS, flags)
+            taskList.provider.client.update(taskSyncURI(), values, null, null)
+        }
+
+        this.flags = flags
+    }
+
+
+    object Factory: AndroidTaskFactory<LocalTask> {
+        override fun fromProvider(taskList: AndroidTaskList<*>, values: ContentValues) =
+                LocalTask(taskList, values)
+    }
+}
@@ -0,0 +1,154 @@
+/*
+ * 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.ContentValues
+import android.content.Context
+import android.net.Uri
+import at.bitfire.davdroid.Constants
+import at.bitfire.davdroid.DavUtils
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.Collection
+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 create(account: Account, provider: TaskProvider, info: Collection): Uri {
+            val values = valuesFromCollectionInfo(info, true)
+            values.put(TaskLists.OWNER, account.name)
+            values.put(TaskLists.SYNC_ENABLED, 1)
+            values.put(TaskLists.VISIBLE, 1)
+            return create(account, provider, values)
+        }
+
+        @SuppressLint("Recycle")
+        @Throws(Exception::class)
+        fun onRenameAccount(context: Context, oldName: String, newName: String) {
+            TaskProvider.acquire(context)?.use { provider ->
+                val values = ContentValues(1)
+                values.put(Tasks.ACCOUNT_NAME, newName)
+                provider.client.update(
+                        Tasks.getContentUri(provider.name.authority),
+                        values,
+                        "${Tasks.ACCOUNT_NAME}=?", arrayOf(oldName)
+                )
+            }
+        }
+
+        private fun valuesFromCollectionInfo(info: Collection, withColor: Boolean): ContentValues {
+            val values = ContentValues(3)
+            values.put(TaskLists._SYNC_ID, info.url.toString())
+            values.put(TaskLists.LIST_NAME, if (info.displayName.isNullOrBlank()) DavUtils.lastSegmentOfUrl(info.url) else info.displayName)
+
+            if (withColor)
+                values.put(TaskLists.LIST_COLOR, info.color ?: Constants.DAVDROID_GREEN_RGBA)
+
+            return values
+        }
+
+    }
+
+    override val tag: String
+        get() = "tasks-${account.name}-$id"
+
+    override val title: String
+        get() = name ?: id.toString()
+
+    override var lastSyncState: SyncState?
+        get() {
+            try {
+                provider.client.query(taskListSyncUri(), arrayOf(TaskLists.SYNC_VERSION),
+                        null, null, null)?.use { cursor ->
+                    if (cursor.moveToNext())
+                        cursor.getString(0)?.let {
+                            return SyncState.fromString(it)
+                        }
+                }
+            } catch (e: Exception) {
+                Logger.log.log(Level.WARNING, "Couldn't read sync state", e)
+            }
+            return null
+        }
+        set(state) {
+            val values = ContentValues(1)
+            values.put(TaskLists.SYNC_VERSION, state?.toString())
+            provider.client.update(taskListSyncUri(), values, null, null)
+        }
+
+
+    fun update(info: Collection, updateColor: Boolean) =
+            update(valuesFromCollectionInfo(info, updateColor))
+
+
+    override fun findDeleted() = queryTasks(Tasks._DELETED, null)
+
+    override fun findDirty(): List<LocalTask> {
+        val tasks = queryTasks(Tasks._DIRTY, null)
+        for (localTask in tasks) {
+            try {
+                val task = requireNotNull(localTask.task)
+                val sequence = task.sequence
+                if (sequence == null)   // sequence has not been assigned yet (i.e. this task was just locally created)
+                    task.sequence = 0
+                else                    // task was modified, increase sequence
+                    task.sequence = sequence + 1
+            } catch(e: Exception) {
+                Logger.log.log(Level.WARNING, "Couldn't check/increase sequence", e)
+            }
+        }
+        return tasks
+    }
+
+    override fun findByName(name: String) =
+            queryTasks("${Tasks._SYNC_ID}=?", arrayOf(name)).firstOrNull()
+
+
+    override fun markNotDirty(flags: Int): Int {
+        val values = ContentValues(1)
+        values.put(LocalTask.COLUMN_FLAGS, flags)
+        return provider.client.update(tasksSyncUri(), values,
+                "${Tasks.LIST_ID}=? AND ${Tasks._DIRTY}=0",
+                arrayOf(id.toString()))
+    }
+
+    override fun removeNotDirtyMarked(flags: Int) =
+            provider.client.delete(tasksSyncUri(),
+                    "${Tasks.LIST_ID}=? AND NOT ${Tasks._DIRTY} AND ${LocalTask.COLUMN_FLAGS}=?",
+                    arrayOf(id.toString(), flags.toString()))
+
+    override fun forgetETags() {
+        val values = ContentValues(1)
+        values.putNull(LocalEvent.COLUMN_ETAG)
+        provider.client.update(tasksSyncUri(), values, "${Tasks.LIST_ID}=?",
+                arrayOf(id.toString()))
+    }
+
+
+    object Factory: AndroidTaskListFactory<LocalTaskList> {
+
+        override fun newInstance(account: Account, provider: TaskProvider, id: Long) =
+                LocalTaskList(account, provider, id)
+
+    }
+
+}
@@ -0,0 +1,34 @@
+package at.bitfire.davdroid.resource
+
+import android.content.Context
+import at.bitfire.davdroid.TasksWatcher
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.ical4android.TaskProvider.ProviderName
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+object TaskUtils {
+
+    fun currentProvider(context: Context): ProviderName? {
+        val preferredAuthority = SettingsManager.getInstance(context).getString(Settings.PREFERRED_TASKS_PROVIDER)
+        ProviderName.values()
+                .sortedByDescending { it.authority == preferredAuthority }
+                .forEach { providerName ->
+            if (context.packageManager.resolveContentProvider(providerName.authority, 0) != null)
+                return providerName
+        }
+        return null
+    }
+
+    fun isAvailable(context: Context) = currentProvider(context) != null
+
+    fun setPreferredProvider(context: Context, providerName: ProviderName) {
+        SettingsManager.getInstance(context).putString(Settings.PREFERRED_TASKS_PROVIDER, providerName.authority)
+        CoroutineScope(Dispatchers.Default).launch {
+            TasksWatcher.updateTaskSync(context)
+        }
+    }
+
+}
@@ -0,0 +1,678 @@
+/*
+ * 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.ContentResolver
+import android.content.ContentUris
+import android.content.ContentValues
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.os.Parcel
+import android.os.RemoteException
+import android.provider.CalendarContract
+import android.provider.CalendarContract.ExtendedProperties
+import android.provider.ContactsContract
+import android.util.Base64
+import androidx.annotation.WorkerThread
+import androidx.core.content.ContextCompat
+import at.bitfire.davdroid.InvalidAccountException
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.TasksWatcher
+import at.bitfire.davdroid.closeCompat
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.AppDatabase
+import at.bitfire.davdroid.model.Collection
+import at.bitfire.davdroid.model.Credentials
+import at.bitfire.davdroid.model.Service
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.resource.LocalTask
+import at.bitfire.davdroid.resource.TaskUtils
+import at.bitfire.ical4android.AndroidCalendar
+import at.bitfire.ical4android.AndroidEvent
+import at.bitfire.ical4android.TaskProvider
+import at.bitfire.ical4android.TaskProvider.ProviderName.OpenTasks
+import at.bitfire.ical4android.UnknownProperty
+import at.bitfire.vcard4android.ContactsStorageException
+import at.bitfire.vcard4android.GroupMethod
+import net.fortuna.ical4j.model.Property
+import net.fortuna.ical4j.model.property.Url
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import org.apache.commons.lang3.StringUtils
+import org.dmfs.tasks.contract.TaskContract
+import java.io.ByteArrayInputStream
+import java.io.ObjectInputStream
+import java.util.logging.Level
+
+/**
+ * Manages settings of an account.
+ *
+ * @throws InvalidAccountException on construction when the account doesn't exist (anymore)
+ */
+@Suppress("FunctionName")
+class AccountSettings(
+        val context: Context,
+        val account: Account
+) {
+
+    companion object {
+
+        const val CURRENT_VERSION = 12
+        const val KEY_SETTINGS_VERSION = "version"
+
+        const val KEY_SYNC_INTERVAL_ADDRESSBOOKS = "sync_interval_addressbooks"
+        const val KEY_SYNC_INTERVAL_CALENDARS = "sync_interval_calendars"
+
+        /** Stores the tasks sync interval (in seconds) so that it can be set again when the provider is switched */
+        const val KEY_SYNC_INTERVAL_TASKS = "sync_interval_tasks"
+
+        const val KEY_USERNAME = "user_name"
+        const val KEY_CERTIFICATE_ALIAS = "certificate_alias"
+
+        const val KEY_WIFI_ONLY = "wifi_only"               // sync on WiFi only (default: false)
+        const val KEY_WIFI_ONLY_SSIDS = "wifi_only_ssids"   // restrict sync to specific WiFi SSIDs
+
+        /** Time range limitation to the past [in days]. Values:
+         *
+         * - null: default value (DEFAULT_TIME_RANGE_PAST_DAYS)
+         * - <0 (typically -1): no limit
+         * - n>0: entries more than n days in the past won't be synchronized
+         */
+        const val KEY_TIME_RANGE_PAST_DAYS = "time_range_past_days"
+        const val DEFAULT_TIME_RANGE_PAST_DAYS = 90
+
+        /**
+         * Whether a default alarm shall be assigned to received events/tasks which don't have an alarm.
+         * Value can be null (no default alarm) or an integer (default alarm shall be created this
+         * number of minutes before the event/task).
+         */
+        const val KEY_DEFAULT_ALARM = "default_alarm"
+
+        /** Whether DAVx5 sets the local calendar color to the value from service DB at every sync
+         value = *null* (not existing): true (default);
+                 "0"                    false */
+        const val KEY_MANAGE_CALENDAR_COLORS = "manage_calendar_colors"
+
+        /** Whether DAVx5 populates and uses CalendarContract.Colors
+         value = *null* (not existing)   false (default);
+                 "1"                     true */
+        const val KEY_EVENT_COLORS = "event_colors"
+
+        /** Contact group method:
+         *null (not existing)*     groups as separate vCards (default);
+         "CATEGORIES"              groups are per-contact CATEGORIES
+         */
+        const val KEY_CONTACT_GROUP_METHOD = "contact_group_method"
+
+        /** UI preference: Show only personal collections
+         value = *null* (not existing)   show all collections (default);
+         "1"                             show only personal collections */
+        const val KEY_SHOW_ONLY_PERSONAL = "show_only_personal"
+
+        const val SYNC_INTERVAL_MANUALLY = -1L
+
+
+        fun initialUserData(credentials: Credentials?): Bundle {
+            val bundle = Bundle(2)
+            bundle.putString(KEY_SETTINGS_VERSION, CURRENT_VERSION.toString())
+
+            if (credentials != null) {
+                if (credentials.userName != null)
+                    bundle.putString(KEY_USERNAME, credentials.userName)
+                if (credentials.certificateAlias != null)
+                    bundle.putString(KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
+            }
+
+            return bundle
+        }
+
+        fun repairSyncIntervals(context: Context) {
+            val addressBooksAuthority = context.getString(R.string.address_books_authority)
+            val taskAuthority = TaskUtils.currentProvider(context)?.authority
+
+            val am = AccountManager.get(context)
+            for (account in am.getAccountsByType(context.getString(R.string.account_type)))
+                try {
+                    val settings = AccountSettings(context, account)
+
+                    // repair address book sync
+                    settings.getSavedAddressbooksSyncInterval()?.let { shouldBe ->
+                        val current = settings.getSyncInterval(addressBooksAuthority)
+                        if (current != shouldBe) {
+                            Logger.log.warning("${account.name}: $addressBooksAuthority sync interval should be $shouldBe but is $current -> setting to $current")
+                            settings.setSyncInterval(addressBooksAuthority, shouldBe)
+                        }
+                    }
+
+                    // repair calendar sync
+                    settings.getSavedCalendarsSyncInterval()?.let { shouldBe ->
+                        val current = settings.getSyncInterval(CalendarContract.AUTHORITY)
+                        if (current != shouldBe) {
+                            Logger.log.warning("${account.name}: ${CalendarContract.AUTHORITY} sync interval should be $shouldBe but is $current -> setting to $current")
+                            settings.setSyncInterval(CalendarContract.AUTHORITY, shouldBe)
+                        }
+                    }
+
+                    if (taskAuthority != null)
+                    // repair calendar sync
+                        settings.getSavedTasksSyncInterval()?.let { shouldBe ->
+                            val current = settings.getSyncInterval(taskAuthority)
+                            if (current != shouldBe) {
+                                Logger.log.warning("${account.name}: $taskAuthority sync interval should be $shouldBe but is $current -> setting to $current")
+                                settings.setSyncInterval(taskAuthority, shouldBe)
+                            }
+                        }
+                } catch (ignored: InvalidAccountException) {
+                    // account doesn't exist (anymore)
+                }
+        }
+
+    }
+    
+    
+    val accountManager: AccountManager = AccountManager.get(context)
+    val settings = SettingsManager.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
+    }
+
+    /**
+     * Sets the sync interval and enables/disables automatic sync for the given account and authority.
+     * Does *not* call [ContentResolver.setIsSyncable].
+     *
+     * This method blocks until the settings have arrived in the sync framework, so it should not
+     * be called from the UI thread.
+     *
+     * @param authority sync authority (like [CalendarContract.AUTHORITY])
+     * @param seconds if [SYNC_INTERVAL_MANUALLY]: automatic sync will be disabled;
+     * otherwise: automatic sync will be enabled and set to the given number of seconds
+     *
+     * @return whether the sync interval was successfully set
+     */
+    @WorkerThread
+    fun setSyncInterval(authority: String, seconds: Long): Boolean {
+        /* Ugly hack: because there is no callback for when the sync status/interval has been
+        updated, we need to make this call blocking. */
+        val setInterval: () -> Boolean =
+                if (seconds == SYNC_INTERVAL_MANUALLY) {
+                    {
+                        Logger.log.fine("Disabling automatic sync of $account/$authority")
+                        ContentResolver.setSyncAutomatically(account, authority, false)
+
+                        /* return */ !ContentResolver.getSyncAutomatically(account, authority)
+                    }
+                } else {
+                    {
+                        Logger.log.fine("Setting automatic sync of $account/$authority to $seconds seconds")
+                        ContentResolver.setSyncAutomatically(account, authority, true)
+                        ContentResolver.addPeriodicSync(account, authority, Bundle(), seconds)
+
+                        /* return */ ContentResolver.getSyncAutomatically(account, authority) &&
+                                ContentResolver.getPeriodicSyncs(account, authority).firstOrNull()?.period == seconds
+                    }
+                }
+
+        // try up to 10 times with 100 ms pause
+        var success = false
+        for (idxTry in 0 until 10) {
+            success = setInterval()
+            if (success)
+                break
+            Thread.sleep(100)
+        }
+
+        if (!success)
+            return false
+
+        // store sync interval in account settings (used when the provider is switched)
+        if (authority == context.getString(R.string.address_books_authority))
+            accountManager.setUserData(account, KEY_SYNC_INTERVAL_ADDRESSBOOKS, seconds.toString())
+        else if (authority == CalendarContract.AUTHORITY)
+            accountManager.setUserData(account, KEY_SYNC_INTERVAL_CALENDARS, seconds.toString())
+        else if (TaskProvider.ProviderName.values().any { it.authority == authority })
+            accountManager.setUserData(account, KEY_SYNC_INTERVAL_TASKS, seconds.toString())
+
+        return true
+    }
+
+    fun getSavedAddressbooksSyncInterval() = accountManager.getUserData(account, KEY_SYNC_INTERVAL_ADDRESSBOOKS)?.toLong()
+    fun getSavedCalendarsSyncInterval() = accountManager.getUserData(account, KEY_SYNC_INTERVAL_CALENDARS)?.toLong()
+    fun getSavedTasksSyncInterval() = accountManager.getUserData(account, KEY_SYNC_INTERVAL_TASKS)?.toLong()
+
+    fun getSyncWifiOnly() =
+            if (settings.containsKey(KEY_WIFI_ONLY))
+                settings.getBoolean(KEY_WIFI_ONLY)
+            else
+                accountManager.getUserData(account, KEY_WIFI_ONLY) != null
+    fun setSyncWiFiOnly(wiFiOnly: Boolean) =
+            accountManager.setUserData(account, KEY_WIFI_ONLY, if (wiFiOnly) "1" else null)
+
+    fun getSyncWifiOnlySSIDs(): List<String>? =
+            if (getSyncWifiOnly()) {
+                val strSsids = if (settings.containsKey(KEY_WIFI_ONLY_SSIDS))
+                    settings.getString(KEY_WIFI_ONLY_SSIDS)
+                else
+                    accountManager.getUserData(account, KEY_WIFI_ONLY_SSIDS)
+                strSsids?.split(',')
+            } else
+                null
+    fun setSyncWifiOnlySSIDs(ssids: List<String>?) =
+            accountManager.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 = strDays.toInt()
+            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())
+
+    /**
+     * Takes the default alarm setting (in this order) from
+     *
+     * 1. the local account settings
+     * 2. the settings provider (unless the value is -1 there).
+     *
+     * @return A default reminder shall be created this number of minutes before the start of every
+     * non-full-day event without reminder. *null*: No default reminders shall be created.
+     */
+    fun getDefaultAlarm() =
+            accountManager.getUserData(account, KEY_DEFAULT_ALARM)?.toInt() ?:
+            settings.getIntOrNull(KEY_DEFAULT_ALARM)?.takeIf { it != -1 }
+
+    /**
+     * Sets the default alarm value in the local account settings, if the new value differs
+     * from the value of the settings provider. If the new value is the same as the value of
+     * the settings provider, the local setting will be deleted, so that the settings provider
+     * value applies.
+     *
+     * @param minBefore The number of minutes a default reminder shall be created before the
+     * start of every non-full-day event without reminder. *null*: No default reminders shall be created.
+     */
+    fun setDefaultAlarm(minBefore: Int?) =
+            accountManager.setUserData(account, KEY_DEFAULT_ALARM,
+                    if (minBefore == settings.getIntOrNull(KEY_DEFAULT_ALARM)?.takeIf { it != -1 })
+                        null
+                    else
+                        minBefore?.toString())
+
+    fun getManageCalendarColors() = if (settings.containsKey(KEY_MANAGE_CALENDAR_COLORS))
+        settings.getBoolean(KEY_MANAGE_CALENDAR_COLORS)
+    else
+        accountManager.getUserData(account, KEY_MANAGE_CALENDAR_COLORS) == null
+    fun setManageCalendarColors(manage: Boolean) =
+            accountManager.setUserData(account, KEY_MANAGE_CALENDAR_COLORS, if (manage) null else "0")
+
+    fun getEventColors() = if (settings.containsKey(KEY_EVENT_COLORS))
+            settings.getBoolean(KEY_EVENT_COLORS)
+                else
+            accountManager.getUserData(account, KEY_EVENT_COLORS) != null
+    fun setEventColors(useColors: Boolean) =
+            accountManager.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)
+    }
+
+
+    // UI settings
+
+    /**
+     * Whether only personal collections should be shown.
+     *
+     * @return [Pair] of values:
+     *
+     *   1. (first) whether only personal collections should be shown
+     *   2. (second) whether the user shall be able to change the setting (= setting not locked)
+     */
+    fun getShowOnlyPersonal(): Pair<Boolean, Boolean> =
+            when (settings.getIntOrNull(KEY_SHOW_ONLY_PERSONAL)) {
+                0 -> Pair(false, false)
+                1 -> Pair(true, false)
+                else /* including -1 */ -> Pair(accountManager.getUserData(account, KEY_SHOW_ONLY_PERSONAL) != null, true)
+            }
+
+    fun setShowOnlyPersonal(showOnlyPersonal: Boolean) {
+        accountManager.setUserData(account, KEY_SHOW_ONLY_PERSONAL, if (showOnlyPersonal) "1" else null)
+    }
+
+
+    // update from previous account settings
+
+    private fun update(baseVersion: Int) {
+        for (toVersion in baseVersion+1 ..CURRENT_VERSION) {
+            val fromVersion = toVersion-1
+            Logger.log.info("Updating account ${account.name} from version $fromVersion to $toVersion")
+            try {
+                val 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","FunctionName")
+    /**
+     * Store event URLs as URL (extended property) instead of unknown property. At the same time,
+     * convert legacy unknown properties to the current format.
+     */
+    private fun update_11_12() {
+        if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED)
+            context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.use { provider ->
+                // Attention: CalendarProvider does NOT limit the results of the ExtendedProperties query
+                // to the given account! So all extended properties will be processed number-of-accounts times.
+                val extUri = AndroidCalendar.syncAdapterURI(ExtendedProperties.CONTENT_URI, account)
+
+                provider.query(extUri, arrayOf(
+                        ExtendedProperties._ID,     // idx 0
+                        ExtendedProperties.NAME,    // idx 1
+                        ExtendedProperties.VALUE    // idx 2
+                ), null, null, null)?.use { cursor ->
+                    while (cursor.moveToNext()) {
+                        val id = cursor.getLong(0)
+                        val rawValue = cursor.getString(2)
+
+                        val uri by lazy {
+                            AndroidCalendar.syncAdapterURI(ContentUris.withAppendedId(ExtendedProperties.CONTENT_URI, id), account)
+                        }
+
+                        when (cursor.getString(1)) {
+                            UnknownProperty.CONTENT_ITEM_TYPE -> {
+                                // unknown property; check whether it's a URL
+                                try {
+                                    val property = UnknownProperty.fromJsonString(rawValue)
+                                    if (property is Url) {  // rewrite to MIMETYPE_URL
+                                        val newValues = ContentValues(2)
+                                        newValues.put(ExtendedProperties.NAME, AndroidEvent.MIMETYPE_URL)
+                                        newValues.put(ExtendedProperties.VALUE, property.value)
+                                        provider.update(uri, newValues, null, null)
+                                    }
+                                } catch (e: Exception) {
+                                    Logger.log.log(Level.WARNING, "Couldn't rewrite URL from unknown property to ${AndroidEvent.MIMETYPE_URL}", e)
+                                }
+                            }
+                            "unknown-property" -> {
+                                // unknown property (deprecated format); convert to current format
+                                try {
+                                    val stream = ByteArrayInputStream(Base64.decode(rawValue, Base64.NO_WRAP))
+                                    ObjectInputStream(stream).use {
+                                        (it.readObject() as? Property)?.let { property ->
+                                            // rewrite to current format
+                                            val newValues = ContentValues(2)
+                                            newValues.put(ExtendedProperties.NAME, UnknownProperty.CONTENT_ITEM_TYPE)
+                                            newValues.put(ExtendedProperties.VALUE, UnknownProperty.toJsonString(property))
+                                            provider.update(uri, newValues, null, null)
+                                        }
+                                    }
+                                } catch(e: Exception) {
+                                    Logger.log.log(Level.WARNING, "Couldn't rewrite deprecated unknown property to current format", e)
+                                }
+                            }
+                            "unknown-property.v2" -> {
+                                // unknown property (deprecated MIME type); rewrite to current MIME type
+                                val newValues = ContentValues(1)
+                                newValues.put(ExtendedProperties.NAME, UnknownProperty.CONTENT_ITEM_TYPE)
+                                provider.update(uri, newValues, null, null)
+                            }
+                        }
+                    }
+                }
+            }
+    }
+
+    @Suppress("unused","FunctionName")
+    /**
+     * The tasks sync interval should be stored in account settings. It's used to set the sync interval
+     * again when the tasks provider is switched.
+     */
+    private fun update_10_11() {
+        TaskUtils.currentProvider(context)?.let { provider ->
+            val interval = getSyncInterval(provider.authority)
+            if (interval != null)
+                accountManager.setUserData(account, KEY_SYNC_INTERVAL_TASKS, interval.toString())
+        }
+    }
+
+    @Suppress("unused","FunctionName")
+    /**
+     * Task synchronization now handles alarms, categories, relations and unknown properties.
+     * Setting task ETags to null will cause them to be downloaded (and parsed) again.
+     *
+     * Also update the allowed reminder types for calendars.
+     **/
+    private fun update_9_10() {
+        TaskProvider.acquire(context, OpenTasks)?.use { provider ->
+            val tasksUri = TaskProvider.syncAdapterUri(provider.tasksUri(), account)
+            val emptyETag = ContentValues(1)
+            emptyETag.putNull(LocalTask.COLUMN_ETAG)
+            provider.client.update(tasksUri, emptyETag, "${TaskContract.Tasks._DIRTY}=0 AND ${TaskContract.Tasks._DELETED}=0", null)
+        }
+
+        @SuppressLint("Recycle")
+        if (ContextCompat.checkSelfPermission(context, android.Manifest.permission.WRITE_CALENDAR) == PackageManager.PERMISSION_GRANTED)
+            context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { provider ->
+                provider.update(AndroidCalendar.syncAdapterURI(CalendarContract.Calendars.CONTENT_URI, account),
+                        AndroidCalendar.calendarBaseValues, null, null)
+                provider.closeCompat()
+            }
+    }
+
+    @Suppress("unused","FunctionName")
+    /**
+     * It seems that somehow some non-CalDAV accounts got OpenTasks syncable, which caused battery problems.
+     * Disable it on those accounts for the future.
+     */
+    private fun update_8_9() {
+        val db = AppDatabase.getInstance(context)
+        val hasCalDAV = db.serviceDao().getByAccountAndType(account.name, Service.TYPE_CALDAV) != null
+        if (!hasCalDAV && ContentResolver.getIsSyncable(account, OpenTasks.authority) != 0) {
+            Logger.log.info("Disabling OpenTasks sync for $account")
+            ContentResolver.setIsSyncable(account, OpenTasks.authority, 0)
+        }
+    }
+
+    @Suppress("unused","FunctionName")
+    @SuppressLint("Recycle")
+    /**
+     * There is a mistake in this method. [TaskContract.Tasks.SYNC_VERSION] is used to store the
+     * SEQUENCE and should not be used for the eTag.
+     */
+    private fun update_7_8() {
+        TaskProvider.acquire(context, OpenTasks)?.use { 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 {
+                provider.closeCompat()
+            }
+        }
+
+        // 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")?.toHttpUrlOrNull()
+                    if (url == null)
+                        Logger.log.info("No address book URL, ignoring account")
+                    else {
+                        // create new address book
+                        val info = Collection(url = url, type = Collection.TYPE_ADDRESSBOOK, displayName = account.name)
+                        Logger.log.log(Level.INFO, "Creating new address book account", url)
+                        val addressBookAccount = Account(LocalAddressBook.accountName(account, info), context.getString(R.string.account_type_address_book))
+                        if (!accountManager.addAccountExplicitly(addressBookAccount, null, LocalAddressBook.initialUserData(account, info.url.toString())))
+                            throw ContactsStorageException("Couldn't create address book account")
+
+                        // move contacts to new address book
+                        Logger.log.info("Moving contacts from $account to $addressBookAccount")
+                        val newAccount = ContentValues(2)
+                        newAccount.put(ContactsContract.RawContacts.ACCOUNT_NAME, addressBookAccount.name)
+                        newAccount.put(ContactsContract.RawContacts.ACCOUNT_TYPE, addressBookAccount.type)
+                        val affected = provider.update(ContactsContract.RawContacts.CONTENT_URI.buildUpon()
+                                .appendQueryParameter(ContactsContract.RawContacts.ACCOUNT_NAME, account.name)
+                                .appendQueryParameter(ContactsContract.RawContacts.ACCOUNT_TYPE, account.type)
+                                .appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true").build(),
+                                newAccount,
+                                "${ContactsContract.RawContacts.ACCOUNT_NAME}=? AND ${ContactsContract.RawContacts.ACCOUNT_TYPE}=?",
+                                arrayOf(account.name, account.type))
+                        Logger.log.info("$affected contacts moved to new address book")
+                    }
+
+                    ContactsContract.SyncState.set(provider, account, null)
+                }
+            } catch(e: RemoteException) {
+                throw ContactsStorageException("Couldn't migrate contacts to new address book", e)
+            } finally {
+                parcel.recycle()
+                provider.closeCompat()
+            }
+        }
+
+        // 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), 4*3600)
+    }
+
+    /* Android 7.1.1 OpenTasks fix */
+    @Suppress("unused")
+    private fun update_4_5() {
+        // call PackageChangedReceiver which then enables/disables OpenTasks sync when it's (not) available
+        TasksWatcher.updateTaskSync(context)
+    }
+
+    @Suppress("unused")
+    private fun update_3_4() {
+        setGroupMethod(GroupMethod.CATEGORIES)
+    }
+
+    // updates from AccountSettings version 2 and below are not supported anymore
+
+}
@@ -0,0 +1,69 @@
+/*
+ * 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.TextTable
+import java.io.Writer
+
+abstract class BaseDefaultsProvider(
+        val context: Context,
+        val settingsManager: SettingsManager
+): SettingsProvider {
+
+    abstract val booleanDefaults: Map<String, Boolean>
+    abstract val intDefaults: Map<String, Int>
+    abstract val longDefaults: Map<String, Long>
+    abstract val stringDefaults: Map<String, String?>
+
+
+    override fun canWrite() = false
+
+    override fun close() {
+        // override this, if needed
+    }
+
+    override fun forceReload() {
+        // override this, if needed
+    }
+
+
+    override fun contains(key: String) =
+            booleanDefaults.containsKey(key) ||
+            intDefaults.containsKey(key) ||
+            longDefaults.containsKey(key) ||
+            stringDefaults.containsKey(key)
+
+    override fun getBoolean(key: String) = booleanDefaults[key]
+    override fun getInt(key: String) = intDefaults[key]
+    override fun getLong(key: String) = longDefaults[key]
+    override fun getString(key: String) = stringDefaults[key]
+
+    override fun putBoolean(key: String, value: Boolean?) = throw NotImplementedError()
+    override fun putInt(key: String, value: Int?) = throw NotImplementedError()
+    override fun putLong(key: String, value: Long?) = throw NotImplementedError()
+    override fun putString(key: String, value: String?) = throw NotImplementedError()
+
+    override fun remove(key: String) = throw NotImplementedError()
+
+
+    override fun dump(writer: Writer) {
+        val strValues = mutableMapOf<String, String?>()
+        strValues.putAll(booleanDefaults.mapValues { (_, value) -> value.toString() })
+        strValues.putAll(intDefaults.mapValues { (_, value) -> value.toString() })
+        strValues.putAll(longDefaults.mapValues { (_, value) -> value.toString() })
+        strValues.putAll(stringDefaults)
+
+        val table = TextTable("Setting", "Value")
+        for ((key, value) in strValues.toSortedMap())
+            table.addLine(key, value)
+        writer.write(table.toString())
+    }
+
+}
@@ -0,0 +1,78 @@
+package at.bitfire.davdroid.settings
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.net.ConnectivityManager
+import android.os.Build
+import androidx.core.content.getSystemService
+
+class DefaultsProvider(
+        context: Context,
+        settingsManager: SettingsManager
+): BaseDefaultsProvider(context, settingsManager) {
+
+    override val booleanDefaults = mutableMapOf(
+        Pair(Settings.DISTRUST_SYSTEM_CERTIFICATES, false),
+        Pair(Settings.OVERRIDE_PROXY, false)
+    )
+
+    override val intDefaults = mapOf(
+            Pair(Settings.OVERRIDE_PROXY_PORT, 8118)
+    )
+
+    override val longDefaults = mapOf<String, Long>(
+            Pair(Settings.DEFAULT_SYNC_INTERVAL, 4*3600)    /* 4 hours */
+    )
+
+    override val stringDefaults = mapOf(
+            Pair(Settings.OVERRIDE_PROXY_HOST, "localhost")
+    )
+
+    val dataSaverChangedListener by lazy {
+        object: BroadcastReceiver() {
+            override fun onReceive(context: Context, intent: Intent) {
+                evaluateDataSaver(true)
+            }
+        }
+    }
+
+
+    init {
+        if (Build.VERSION.SDK_INT >= 24) {
+            val dataSaverChangedFilter = IntentFilter(ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED)
+            context.registerReceiver(dataSaverChangedListener, dataSaverChangedFilter)
+            evaluateDataSaver()
+        }
+    }
+
+    override fun forceReload() {
+        evaluateDataSaver()
+    }
+
+    override fun close() {
+        if (Build.VERSION.SDK_INT >= 24)
+            context.unregisterReceiver(dataSaverChangedListener)
+    }
+
+    fun evaluateDataSaver(notify: Boolean = false) {
+        if (Build.VERSION.SDK_INT >= 24) {
+            context.getSystemService<ConnectivityManager>()?.let { connectivityManager ->
+                if (connectivityManager.restrictBackgroundStatus == ConnectivityManager.RESTRICT_BACKGROUND_STATUS_ENABLED)
+                    booleanDefaults[AccountSettings.KEY_WIFI_ONLY] = true
+                else
+                    booleanDefaults -= AccountSettings.KEY_WIFI_ONLY
+            }
+            if (notify)
+                settingsManager.onSettingsChanged()
+        }
+    }
+
+
+    class Factory : SettingsProviderFactory {
+        override fun getProviders(context: Context, settingsManager: SettingsManager) =
+                listOf(DefaultsProvider(context, settingsManager))
+    }
+
+}
@@ -0,0 +1,30 @@
+package at.bitfire.davdroid.settings
+
+import androidx.appcompat.app.AppCompatDelegate
+
+object Settings {
+
+    const val FOREGROUND_SERVICE = "foreground_service"
+
+    const val DISTRUST_SYSTEM_CERTIFICATES = "distrust_system_certs"
+
+    const val OVERRIDE_PROXY = "override_proxy"
+    const val OVERRIDE_PROXY_HOST = "override_proxy_host"
+    const val OVERRIDE_PROXY_PORT = "override_proxy_port"
+
+    /**
+     * Default sync interval (long), in seconds.
+     * Used to initialize an account.
+     */
+    const val DEFAULT_SYNC_INTERVAL = "default_sync_interval"
+
+    /**
+     * Preferred theme (light/dark). Value must be one of [AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM]
+     * (default if setting is missing), [AppCompatDelegate.MODE_NIGHT_NO] or [AppCompatDelegate.MODE_NIGHT_YES].
+     */
+    const val PREFERRED_THEME = "preferred_theme"
+    const val PREFERRED_THEME_DEFAULT = AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM
+
+    const val PREFERRED_TASKS_PROVIDER = "preferred_tasks_provider"
+
+}
@@ -0,0 +1,175 @@
+/*
+ * 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.util.NoSuchPropertyException
+import androidx.annotation.AnyThread
+import at.bitfire.davdroid.AndroidSingleton
+import at.bitfire.davdroid.log.Logger
+import java.io.Writer
+import java.lang.ref.WeakReference
+import java.util.*
+import java.util.logging.Level
+
+/**
+ * Settings manager which coordinates [SettingsProvider]s to read/write
+ * application settings.
+ */
+class SettingsManager private constructor(
+        context: Context
+) {
+
+    companion object: AndroidSingleton<SettingsManager>() {
+        override fun createInstance(context: Context) = SettingsManager(context)
+    }
+
+    private val providers = LinkedList<SettingsProvider>()
+    private var writeProvider: SettingsProvider? = null
+
+    private val observers = LinkedList<WeakReference<OnChangeListener>>()
+
+    init {
+        val factories = ServiceLoader.load(SettingsProviderFactory::class.java, context.classLoader)
+        Logger.log.fine("Loading settings providers from ${factories.count()} factories")
+        for (factory in factories)
+            providers.addAll(factory.getProviders(context, this))
+
+        writeProvider = providers.first { it.canWrite() }
+        Logger.log.fine("Changed settings are handled by $writeProvider")
+    }
+
+    /**
+     * Requests all providers to reload their settings.
+     */
+    @AnyThread
+    fun forceReload() {
+        for (provider in providers)
+            provider.forceReload()
+        onSettingsChanged()
+    }
+
+
+    /*** OBSERVERS ***/
+
+    fun addOnChangeListener(observer: OnChangeListener) {
+        synchronized(observers) {
+            observers += WeakReference(observer)
+        }
+    }
+
+    fun removeOnChangeListener(observer: OnChangeListener) {
+        synchronized(observers) {
+            observers.removeAll { it.get() == null || it.get() == observer }
+        }
+    }
+
+    /**
+     * Notifies registered listeners about changes in the configuration.
+     * Should be called by config providers when settings have changed.
+     */
+    @AnyThread
+    fun onSettingsChanged() {
+        synchronized(observers) {
+            for (observer in observers.mapNotNull { it.get() })
+                observer.onSettingsChanged()
+        }
+    }
+
+
+    /*** SETTINGS ACCESS ***/
+
+    fun containsKey(key: String) = providers.any { it.contains(key) }
+
+    private fun<T> getValue(key: String, reader: (SettingsProvider) -> T?): T? {
+        Logger.log.fine("Looking up setting $key")
+        val result: T? = null
+        for (provider in providers)
+            try {
+                val value = reader(provider)
+                Logger.log.finer("${provider::class.java.simpleName}: $key = $value")
+                if (value != null) {
+                    Logger.log.fine("Looked up setting $key -> $value")
+                    return value
+                }
+            } catch(e: Exception) {
+                Logger.log.log(Level.SEVERE, "Couldn't read setting from $provider", e)
+            }
+        Logger.log.fine("Looked up setting $key -> no result")
+        return result
+    }
+
+    fun getBooleanOrNull(key: String): Boolean? = getValue(key) { provider -> provider.getBoolean(key) }
+    fun getBoolean(key: String): Boolean = getBooleanOrNull(key) ?: throw NoSuchPropertyException(key)
+
+    fun getIntOrNull(key: String): Int? = getValue(key) { provider -> provider.getInt(key) }
+    fun getInt(key: String): Int = getIntOrNull(key) ?: throw NoSuchPropertyException(key)
+
+    fun getLongOrNull(key: String): Long? = getValue(key) { provider -> provider.getLong(key) }
+    fun getLong(key: String) = getLongOrNull(key) ?: throw NoSuchPropertyException(key)
+
+    fun getString(key: String) = getValue(key) { provider -> provider.getString(key) }
+
+
+    fun isWritable(key: String): Boolean {
+        for (provider in providers) {
+            if (provider.canWrite())
+                return true
+            else if (provider.contains(key))
+                // non-writeable provider contains this key -> setting will always be provided by this read-only provider
+                return false
+        }
+        return false
+    }
+
+    private fun<T> putValue(key: String, value: T?, writer: (SettingsProvider) -> Unit) {
+        Logger.log.fine("Trying to write setting $key = $value")
+        val provider = writeProvider ?: return
+        try {
+            writer(provider)
+        } catch (e: Exception) {
+            Logger.log.log(Level.SEVERE, "Couldn't write setting to $writeProvider", e)
+        }
+    }
+
+    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) = putString(key, null)
+
+
+    /*** HELPERS ***/
+
+    fun dump(writer: Writer) {
+        for ((idx, provider) in providers.withIndex()) {
+            writer.write("${idx + 1}. ${provider::class.java.simpleName} canWrite=${provider.canWrite()}\n")
+            provider.dump(writer)
+        }
+    }
+
+
+    interface OnChangeListener {
+        /**
+         * Will be called when something has changed in a [SettingsProvider].
+         * May run in worker thread!
+         */
+        @AnyThread
+        fun onSettingsChanged()
+    }
+
+}
@@ -0,0 +1,54 @@
+/*
+ * 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.annotation.AnyThread
+import java.io.Writer
+
+/**
+ * Defines a settings provider, which provides settings from a certain source
+ * to the [SettingsManager].
+ *
+ * Implementations must be thread-safe and synchronize get/put operations on their own.
+ */
+interface SettingsProvider {
+
+    /**
+     * Whether this provider can write settings.
+     *
+     * If this method returns false, the put...() methods will never be called for this provider.
+     *
+     * @return true = this provider provides read/write settings;
+     *         false = this provider provides read-only settings
+     */
+    fun canWrite(): Boolean
+
+    fun close()
+
+    @AnyThread
+    fun forceReload()
+
+    fun contains(key: String): Boolean
+
+    fun getBoolean(key: String): Boolean?
+    fun getInt(key: String): Int?
+    fun getLong(key: String): Long?
+    fun getString(key: String): String?
+
+    fun putBoolean(key: String, value: Boolean?)
+    fun putInt(key: String, value: Int?)
+    fun putLong(key: String, value: Long?)
+    fun putString(key: String, value: String?)
+
+    fun remove(key: String)
+
+
+    fun dump(writer: Writer)
+
+}
@@ -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 SettingsProviderFactory {
+
+    fun getProviders(context: Context, settingsManager: SettingsManager): Iterable<SettingsProvider>
+
+}
@@ -0,0 +1,139 @@
+/*
+ * 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 androidx.preference.PreferenceManager
+import at.bitfire.davdroid.TextTable
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.AppDatabase
+import java.io.Writer
+
+class SharedPreferencesProvider(
+        val context: Context,
+        val settingsManager: SettingsManager
+): 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 canWrite() = true
+
+    override fun onSharedPreferenceChanged(sharedPreferences: SharedPreferences, key: String) {
+        settingsManager.onSettingsChanged()
+    }
+
+
+    override fun contains(key: String) = preferences.contains(key)
+
+    private fun<T> getValue(key: String, reader: (SharedPreferences) -> T): T? =
+            try {
+                if (preferences.contains(key))
+                    reader(preferences)
+                else
+                    null
+            } catch(e: ClassCastException) {
+                null
+            }
+
+    override fun getBoolean(key: String) =
+            getValue(key) { preferences -> preferences.getBoolean(key, /* will never be used: */ false) }
+
+    override fun getInt(key: String) =
+            getValue(key) { preferences -> preferences.getInt(key, /* will never be used: */ -1) }
+
+    override fun getLong(key: String) =
+            getValue(key) { preferences -> preferences.getLong(key, /* will never be used: */ -1) }
+
+    override fun getString(key: String): String? =
+            preferences.getString(key, /* will never be used: */ null)
+
+
+    private fun<T> putValue(key: String, value: T?, writer: (SharedPreferences.Editor, T) -> Unit) {
+        if (value == null)
+            remove(key)
+        else {
+            Logger.log.fine("Writing setting $key = $value")
+            val edit = preferences.edit()
+            writer(edit, value)
+            edit.apply()
+        }
+    }
+
+    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) {
+        Logger.log.fine("Removing setting $key")
+        preferences.edit().remove(key).apply()
+    }
+
+
+    override fun dump(writer: Writer) {
+        val table = TextTable("Setting", "Value")
+        for ((key, value) in preferences.all.toSortedMap())
+            table.addLine(key, value)
+        writer.write(table.toString())
+    }
+
+
+
+    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
+        AppDatabase.getInstance(context)
+    }
+
+
+    class Factory : SettingsProviderFactory {
+        override fun getProviders(context: Context, settingsManager: SettingsManager) = listOf(SharedPreferencesProvider(context, settingsManager))
+    }
+
+}
@@ -0,0 +1,75 @@
+/*
+ * 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.os.Bundle
+import at.bitfire.davdroid.ui.setup.LoginActivity
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+
+
+/**
+ * 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 {
+
+    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 == AccountManager.ACTION_AUTHENTICATOR_INTENT }
+
+
+    override fun onAccountsUpdated(accounts: Array<out Account>?) {
+        CoroutineScope(Dispatchers.Default).launch {
+            AccountUtils.cleanupAccounts(this@AccountAuthenticatorService)
+        }
+    }
+
+
+    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
+
+    }
+}
@@ -0,0 +1,97 @@
+package at.bitfire.davdroid.syncadapter
+
+import android.accounts.Account
+import android.accounts.AccountManager
+import android.content.Context
+import android.os.Bundle
+import androidx.annotation.AnyThread
+import at.bitfire.davdroid.R
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.AppDatabase
+import at.bitfire.davdroid.resource.LocalAddressBook
+import java.util.logging.Level
+
+object AccountUtils {
+
+    @AnyThread
+    @Synchronized
+    fun cleanupAccounts(context: Context) {
+        val accountManager = AccountManager.get(context)
+
+        val accounts = accountManager.getAccountsByType(context.getString(R.string.account_type))
+        val accountNames = accounts.map { it.name }
+        Logger.log.log(Level.INFO, "Cleaning up orphaned accounts. Current accounts:", accountNames)
+
+        // 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
+        val db = AppDatabase.getInstance(context)
+        val serviceDao = db.serviceDao()
+        if (accountNames.isEmpty())
+            serviceDao.deleteAll()
+        else
+            serviceDao.deleteExceptAccounts(accountNames.toTypedArray())
+    }
+
+    /**
+     * Creates an account and makes sure the user data are set correctly.
+     *
+     * @param context  operating context
+     * @param account  account to create
+     * @param userData user data to set
+     *
+     * @return whether the account has been created
+     *
+     * @throws IllegalArgumentException when user data contains non-String values
+     * @throws IllegalStateException if user data can't be set
+     */
+    fun createAccount(context: Context, account: Account, userData: Bundle, password: String? = null): Boolean {
+        // validate user data
+        for (key in userData.keySet()) {
+            userData.get(key)?.let { entry ->
+                if (entry !is String)
+                    throw IllegalArgumentException("userData[$key] is ${entry::class.java} (expected: String)")
+            }
+        }
+
+        // create account
+        val manager = AccountManager.get(context)
+        if (!manager.addAccountExplicitly(account, password, userData))
+            return false
+
+        // Android seems to lose the initial user data sometimes, so set it a second time if that happens
+        // https://forums.bitfire.at/post/11644
+        if (!verifyUserData(context, account, userData))
+            for (key in userData.keySet())
+                manager.setUserData(account, key, userData.getString(key))
+
+        if (!verifyUserData(context, account, userData))
+            throw IllegalStateException("Android doesn't store user data in account")
+
+        return true
+    }
+
+    private fun verifyUserData(context: Context, account: Account, userData: Bundle): Boolean {
+        val accountManager = AccountManager.get(context)
+        userData.keySet().forEach { key ->
+            val stored = accountManager.getUserData(account, key)
+            val expected = userData.getString(key)
+            if (stored != expected) {
+                Logger.log.warning("Stored user data \"$stored\" differs from expected data \"$expected\" for $key")
+                return false
+            }
+        }
+        return true
+    }
+
+}
@@ -0,0 +1,25 @@
+/*
+ * 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
+
+@Suppress("ImplicitNullableNothingType")
+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
+
+}
@@ -0,0 +1,125 @@
+/*
+ * 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.ContentProviderClient
+import android.content.ContentResolver
+import android.content.Context
+import android.content.SyncResult
+import android.content.pm.PackageManager
+import android.os.Bundle
+import android.provider.ContactsContract
+import androidx.core.content.ContextCompat
+import at.bitfire.davdroid.closeCompat
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.AppDatabase
+import at.bitfire.davdroid.model.Collection
+import at.bitfire.davdroid.model.Service
+import at.bitfire.davdroid.resource.LocalAddressBook
+import at.bitfire.davdroid.settings.AccountSettings
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+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
+
+                if (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): Boolean {
+            val db = AppDatabase.getInstance(context)
+            val service = db.serviceDao().getByAccountAndType(account.name, Service.TYPE_CARDDAV)
+
+            val remoteAddressBooks = mutableMapOf<HttpUrl, Collection>()
+            if (service != null)
+                for (collection in db.collectionDao().getByServiceAndSync(service.id))
+                    remoteAddressBooks[collection.url] = collection
+
+            if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CONTACTS) != PackageManager.PERMISSION_GRANTED) {
+                if (remoteAddressBooks.isEmpty())
+                    Logger.log.info("No contacts permission, but no address book selected for synchronization")
+                else
+                    Logger.log.warning("No contacts permission, but address books are selected for synchronization")
+                return false
+            }
+
+            val contactsProvider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)
+            try {
+                if (contactsProvider == null) {
+                    Logger.log.severe("Couldn't access contacts provider")
+                    syncResult.databaseError = true
+                    return false
+                }
+
+                // delete/update local address books
+                for (addressBook in LocalAddressBook.findAll(context, contactsProvider, account)) {
+                    val url = addressBook.url.toHttpUrl()
+                    val info = remoteAddressBooks[url]
+                    if (info == null) {
+                        Logger.log.log(Level.INFO, "Deleting obsolete local address book", url)
+                        addressBook.delete()
+                    } else {
+                        // remote CollectionInfo found for this local collection, update data
+                        try {
+                            Logger.log.log(Level.FINE, "Updating local address book $url", info)
+                            addressBook.update(info)
+                        } catch (e: Exception) {
+                            Logger.log.log(Level.WARNING, "Couldn't rename address book account", e)
+                        }
+                        // we already have a local address book for this remote collection, don't take into consideration anymore
+                        remoteAddressBooks -= url
+                    }
+                }
+
+                // create new local address books
+                for ((_, info) in remoteAddressBooks) {
+                    Logger.log.log(Level.INFO, "Adding local address book", info)
+                    LocalAddressBook.create(context, contactsProvider, account, info)
+                }
+            } finally {
+                contactsProvider?.closeCompat()
+            }
+
+            return true
+        }
+
+    }
+
+}
@@ -0,0 +1,186 @@
+/*
+ * 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.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.DateUtils
+import at.bitfire.ical4android.Event
+import at.bitfire.ical4android.InvalidCalendarException
+import net.fortuna.ical4j.model.component.VAlarm
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrlOrNull
+import okhttp3.RequestBody
+import okhttp3.RequestBody.Companion.toRequestBody
+import java.io.ByteArrayOutputStream
+import java.io.Reader
+import java.io.StringReader
+import java.time.Duration
+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 = (localCollection.name ?: return false).toHttpUrlOrNull() ?: 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? =
+            remoteExceptionContext {
+                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 generateUpload(resource: LocalEvent): RequestBody = localExceptionContext(resource) {
+        val event = requireNotNull(resource.event)
+        Logger.log.log(Level.FINE, "Preparing upload of event ${resource.fileName}", event)
+
+        val os = ByteArrayOutputStream()
+        event.write(os)
+
+        os.toByteArray().toRequestBody(DavCalendar.MIME_ICALENDAR_UTF8)
+    }
+
+    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 remoteExceptionContext { 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")
+        remoteExceptionContext {
+            it.multiget(bunch) { response, _ ->
+                responseExceptionContext(response) {
+                    if (!response.isSuccess()) {
+                        Logger.log.warning("Received non-successful multiget response for ${response.href}")
+                        return@responseExceptionContext
+                    }
+
+                    val eTag = response[GetETag::class.java]?.eTag
+                            ?: throw DavException("Received multi-get response without ETag")
+                    val scheduleTag = response[ScheduleTag::class.java]?.scheduleTag
+
+                    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, scheduleTag, StringReader(iCal))
+                }
+            }
+        }
+    }
+
+    override fun postProcess() {
+    }
+
+
+    // helpers
+
+    private fun processVEvent(fileName: String, eTag: String, scheduleTag: String?, reader: Reader) {
+        val events: List<Event>
+        try {
+            events = Event.eventsFromReader(reader)
+        } catch (e: InvalidCalendarException) {
+            Logger.log.log(Level.SEVERE, "Received invalid iCalendar, ignoring", e)
+            notifyInvalidResource(e, fileName)
+            return
+        }
+
+        if (events.size == 1) {
+            val event = events.first()
+
+            // set default reminder for non-full-day events, if requested
+            val defaultAlarmMinBefore = accountSettings.getDefaultAlarm()
+            if (defaultAlarmMinBefore != null && DateUtils.isDateTime(event.dtStart) && event.alarms.isEmpty()) {
+                val alarm = VAlarm(Duration.ofMinutes(-defaultAlarmMinBefore.toLong()))
+                Logger.log.log(Level.FINE, "${event.uid}: Adding default alarm", alarm)
+                event.alarms += alarm
+            }
+
+            // update local event, if it exists
+            localExceptionContext(localCollection.findByName(fileName)) { local ->
+                if (local != null) {
+                    Logger.log.log(Level.INFO, "Updating $fileName in local calendar", event)
+                    local.eTag = eTag
+                    local.scheduleTag = scheduleTag
+                    local.update(event)
+                    syncResult.stats.numUpdates++
+                } else {
+                    Logger.log.log(Level.INFO, "Adding $fileName to local calendar", event)
+                    localExceptionContext(LocalEvent(localCollection, event, fileName, eTag, scheduleTag, 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)
+
+}
@@ -0,0 +1,108 @@
+/*
+ * 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.CalendarContract
+import at.bitfire.davdroid.log.Logger
+import at.bitfire.davdroid.model.AppDatabase
+import at.bitfire.davdroid.model.Collection
+import at.bitfire.davdroid.model.Service
+import at.bitfire.davdroid.resource.LocalCalendar
+import at.bitfire.davdroid.settings.AccountSettings
+import at.bitfire.ical4android.AndroidCalendar
+import okhttp3.HttpUrl
+import okhttp3.HttpUrl.Companion.toHttpUrl
+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)
+
+                val priorityCalendars = priorityCollections(extras)
+                val calendars = AndroidCalendar
+                        .find(account, provider, LocalCalendar.Factory, "${CalendarContract.Calendars.SYNC_EVENTS}!=0", null)
+                        .sortedByDescending { priorityCalendars.contains(it.id) }
+                for (calendar in calendars) {
+                    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) {
+            val db = AppDatabase.getInstance(context)
+            val service = db.serviceDao().getByAccountAndType(account.name, Service.TYPE_CALDAV)
+
+            val remoteCalendars = mutableMapOf<HttpUrl, Collection>()
+            if (service != null)
+                for (collection in db.collectionDao().getSyncCalendars(service.id)) {
+                    remoteCalendars[collection.url] = collection
+                }
+
+            // delete/update local calendars
+            val updateColors = settings.getManageCalendarColors()
+            for (calendar in AndroidCalendar.find(account, provider, LocalCalendar.Factory, null, null))
+                calendar.name?.let {
+                    val url = it.toHttpUrl()
+                    val info = remoteCalendars[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
+                        remoteCalendars -= url
+                    }
+                }
+
+            // create new local calendars
+            for ((_, info) in remoteCalendars) {
+                Logger.log.log(Level.INFO, "Adding local calendar", info)
+                LocalCalendar.create(account, provider, info)
+            }
+        }
+
+    }
+
+}
				`@@ -0,0 +1 @@`
				{"ar_SA":["abdunnasir"],"bg":["dpa_transifex","ma4ko"],"ca":["ettenmoors","hegocr_1709","jordibrus","Kintu","Solatec","zagur"],"cs":["Kryšpin","pavelb","tomas.odehnal"],"da":["knutztar","mjjzf","Tntdruid_","twikedk"],"de":["amandablue","anestiskaci","Atalanttore","corppneq","crit12","Gyges","hammaschlach","maxkl","nicolas_git","owncube","TheName","Waldmeisda","Wyrrrd","YvanM"],"el":["anestiskaci","diamond_gr","KristinaQejvanaj"],"es":["aluaces","Anoih","Ark74","Elhea","GranPC","jcvielma","oscfdezdz","plaguna","polkhas","sfouilleulb","xphnx"],"eu":["cockeredradiation","Osoitz","Thadah"],"fa":["ahangarha","amiraliakbari","javad.aboutorabi","joojoojoo","maryambehzi","mtashackori","Numb","taranehsaei"],"fi_FI":["raketti","tseipii"],"fr":["AlainR","alkino2","Amadeen","boutil","callmemagnus","chfo","chrcha","Floflr","grenatrad","jokx","Jorg722","JorisBodin","Llorc","LoiX07","mathieugfortin","Novick","paullbn","Poussinou","RomainTT","Synochy","Thecross","unareil","vincen","YvanM","ÉricB."],"fr_FR":["chrcha","Llorc","Poussinou","sfouilleulb"],"gl":["aluaces","pikamoku"],"hr":["tomiis"],"hr_HR":["tomiis"],"hu":["infeeeee","jtg","meskobalazs","Roshek","sfouilleulb"],"it":["Damtux","ed0","FranzMari","lzambarda","malaerba","noccio","nwandy","rickyroo","sfouilleulb","technezio"],"it_IT":["malaerba"],"ja":["Naofumi","yanorei32"],"nb_NO":["elonus"],"nl":["davtemp","dehart","erikhubers","frankyboy1963","glotzbach","toonvangerwen","XtremeNova"],"pl":["gsz","M4SK1N","mg6","oskarjakiela","TheName","TORminator","Valdnet"],"pt":["amalvarenga","wanderlei.huttel"],"pt_BR":["wanderlei.huttel"],"ru":["aigoshin","anm","ashed","astalavister","nick.savin","vaddd"],"sk_SK":["brango67","tiborepcek"],"sl_SI":["MrLaaky","uroszor"],"sr":["daimonion"],"sv":["campbelldavid","Mikaelb"],"szl":["chlodny"],"tr_TR":["ooguz","pultars"],"uk":["androsua","olexn","twixi007"],"uk_UA":["astalavister"],"vi":["bruhwut"],"zh_CN":["anolir","jxj2zzz79pfp9bpo","leoniscsem","linuxbckp","mofitt2016","oksjd","phy","spice2wolf"],"zh_TW":["linuxbckp","mofitt2016","phy","waiabsfabuloushk"]}