Fix core instrumentation tests

- Add managed device for testing
- Set device to "Pixel 3" with API level 34
- Use AOSP system image source

.github/CODEOWNERS

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

.github/FUNDING.yml

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

.github/ISSUE_TEMPLATE/config.yml

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

.github/ISSUE_TEMPLATE/qualified-bug.yml

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

.github/ISSUE_TEMPLATE/qualified-feature.yml

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

.github/dependabot.yml

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

.github/pull_request_template.md

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

.github/release.yml

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

.github/workflows/codeql.yml

@@ -0,0 +1,50 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main-ose ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main-ose ]
+  schedule:
+    - cron: '22 10 * * 1'
+
+concurrency:
+  group: codeql-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v6
+    - uses: actions/setup-java@v5
+      with:
+        distribution: temurin
+        java-version: 21
+    - uses: gradle/actions/setup-gradle@v5
+      with:
+        cache-encryption-key: ${{ secrets.gradle_encryption_key }}
+        cache-read-only: true         # gradle user home cache is generated by test jobs
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v4
+      with:
+        languages: java-kotlin
+        build-mode: manual            # autobuild uses older JDK
+
+    - name: Build                     # we must not use build cache here
+      run: ./gradlew --no-daemon --configuration-cache app:assembleDebug
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v4
+      with:
+        category: "/language:${{matrix.language}}"

.github/workflows/dependency-submission.yml

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

.github/workflows/release.yml

@@ -0,0 +1,47 @@
+name: Create release
+on:
+  push:
+    tags:
+      - v*
+
+concurrency:
+  group: release-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  prerelease: ${{ contains(github.ref_name, '-alpha') || contains(github.ref_name, '-beta') || contains(github.ref_name, '-rc') }}
+
+jobs:
+  build:
+    name: Create release
+    permissions:
+      contents: write
+      discussions: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v5
+
+      - name: Prepare keystore
+        run: echo ${{ secrets.android_keystore_base64 }} | base64 -d >$GITHUB_WORKSPACE/keystore.jks
+
+      - name: Build signed package
+        # Use build cache to speed up building of build variants, but clean caches from previous tests before
+        run: ./gradlew --build-cache --configuration-cache --no-daemon app:clean app:assembleRelease
+        env:
+          ANDROID_KEYSTORE: ${{ github.workspace }}/keystore.jks
+          ANDROID_KEYSTORE_PASSWORD: ${{ secrets.android_keystore_password }}
+          ANDROID_KEY_ALIAS: ${{ secrets.android_key_alias }}
+          ANDROID_KEY_PASSWORD: ${{ secrets.android_key_password }}
+
+      - name: Create Github release
+        uses: softprops/action-gh-release@v2
+        with:
+          prerelease: ${{ env.prerelease }}
+          files: app/build/outputs/apk/ose/release/*.apk
+          fail_on_unmatched_files: true
+          generate_release_notes: true

.github/workflows/test-dev.yml

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

.gitignore

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

.gitlab-ci.yml

@@ -1,31 +0,0 @@
-image: registry.gitlab.com/bitfireat/davdroid:latest
-
-before_script:
-  - git submodule update --init --recursive
-  - export GRADLE_USER_HOME=`pwd`/.gradle; chmod +x gradlew
-
-cache:
-  paths:
-     - .gradle/
-     - apk/
-
-test:
-  script:
-    - (cd /sdk/emulator; ./emulator @test -no-audio -no-window & wait-for-emulator.sh)
-    - (mkdir -p apk && cd apk && wget -q https://f-droid.org/repo/org.dmfs.tasks_481.apk && adb install org.dmfs.tasks_481.apk)
-    - ./gradlew check mergeAndroidReports
-  artifacts:
-    paths:
-      - app/build/outputs/lint-results-debug.html
-      - app/build/reports
-      - build/reports
-
-pages:
-  script:
-    - ./gradlew app:dokka
-    - mkdir public && mv app/build/dokka public
-  artifacts:
-    paths:
-      - public
-  only:
-    - master-ose

.gitmodules

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

.idea/codeStyles/Project.xml

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

.idea/codeStyles/codeStyleConfig.xml

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

.idea/copyright/LICENSE.xml

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

.idea/copyright/profiles_settings.xml

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

AUTHORS

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

CONTRIBUTING.md

@@ -0,0 +1,99 @@
+
+**Thank you for your interest in contributing to DAVx⁵!**
+
+
+# Licensing
+
+All work in this repository is [licensed under the GPLv3](LICENSE).
+
+We (bitfire.at, initial and main contributors) are also asking you to give us
+permission to use your contribution for related non-open source projects
+like [Managed DAVx⁵](https://www.davx5.com/organizations/managed-davx5).
+
+If you send us a pull request, our CLA bot will ask you to sign the
+Contributor's License Agreement so that we can use your contribution.
+
+
+# Copyright notice
+
+Make sure that every file that contains significant work (at least every code file)
+starts with the copyright header. Android Studio should do so automatically because the
+configuration is stored in the repository (`.idea/copyright`).
+
+
+# Style guide
+
+Please adhere to the [Kotlin style guide](https://developer.android.com/kotlin/style-guide) and
+the following hints to make the source code uniform.
+
+**Have a look at similar files and copy their style if you're not certain.**
+
+Sample file (pay attention to blank lines and other formatting):
+
+```
+<Copyright header, see above>
+
+class MyClass(int arg1) : SuperClass() {
+
+    companion object {
+
+        const val CONSTANT_STRING = "Constant String";
+
+        fun staticMethod() {	// Use static methods when you don't need the object context.
+            // …
+        }
+
+    }
+
+    var someProperty: String = "12345"
+    var someRelatedProperty: Int = 12345
+
+    init {
+        // constructor
+    }
+
+
+    /**
+     * Use KDoc to document important methods. Don't use it dogmatically, but writing proper documentation
+     * (not just the method name with spaces) helps you to re-think what the method shall really do.
+     */
+    fun aFun1() {		// Group methods by some logic (for instance, the order in which they will be called)
+    }				// and alphabetically within a group.
+
+    fun anotherFun() {
+        // …
+    }
+
+
+    fun somethingCompletelyDifferent() {	// two blank lines to separate groups
+    }
+
+    fun helperForSomethingCompletelyDifferent() {
+        someCall(arg1, arg2, arg3, arg4)	// function calls: stick to one line unless it becomes confusing
+    }
+
+
+    class Model(				// two blank lines before inner classes
+        someArgument: SomeLongClass,		// arguments in multiple lines when they're too long for one line
+        anotherArgument: AnotherLongType,
+        thirdArgument: AnotherLongTypeName
+    ) : ViewModel() {
+
+        fun abc() {
+        }
+
+    }
+
+}
+```
+
+In general, use one blank line to separate things within one group of things, and two blank lines
+to separate groups. In rare cases, when methods are tightly coupled and are only helpers for another
+method, they may follow the calling method without separating blank lines.
+
+## Tests
+
+Test classes should be in the appropriate directory (see existing tests) and in the same package as the
+tested class. Tests are usually be named like `methodToBeTested_Condition()`, see
+[Test apps on Android](https://developer.android.com/training/testing/).
+

README.md

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

SECURITY.md

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

app-ose/build.gradle.kts

@@ -0,0 +1,126 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.compose.compiler)
+    alias(libs.plugins.hilt)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    compileSdk = 36
+
+    defaultConfig {
+        minSdk = 24        // Android 7.0
+        targetSdk = 36     // Android 16
+
+        applicationId = "at.bitfire.davdroid"
+
+        versionCode = 405090005
+        versionName = "4.5.9"
+
+        //base.archivesName = "davx5-$versionCode-$versionName"
+    }
+
+    java {
+        toolchain {
+            languageVersion = JavaLanguageVersion.of(21)
+        }
+    }
+
+    compileOptions {
+        isCoreLibraryDesugaringEnabled = true
+    }
+
+    buildFeatures {
+        compose = true
+    }
+
+    // Java namespace for our classes (not to be confused with Android package ID)
+    namespace = "com.davx5.ose"
+
+    flavorDimensions += "distribution"
+    productFlavors {
+        create("ose") {
+            dimension = "distribution"
+            versionNameSuffix = "-ose"
+        }
+    }
+
+    androidResources {
+        generateLocaleConfig = true
+    }
+
+    buildTypes {
+        getByName("release") {
+            isMinifyEnabled = true
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules-release.pro")
+
+            isShrinkResources = true
+
+            signingConfig = signingConfigs.findByName("bitfire")
+        }
+    }
+
+    signingConfigs {
+        create("bitfire") {
+            storeFile = file(System.getenv("ANDROID_KEYSTORE") ?: "/dev/null")
+            storePassword = System.getenv("ANDROID_KEYSTORE_PASSWORD")
+            keyAlias = System.getenv("ANDROID_KEY_ALIAS")
+            keyPassword = System.getenv("ANDROID_KEY_PASSWORD")
+        }
+    }
+
+    @Suppress("UnstableApiUsage")
+    testOptions {
+        managedDevices {
+            localDevices {
+                create("virtual") {
+                    device = "Pixel 3"
+                    // TBD: API level 35 and higher causes network tests to fail sometimes, see https://github.com/bitfireAT/davx5-ose/issues/1525
+                    // Suspected reason: https://developer.android.com/about/versions/15/behavior-changes-all#background-network-access
+                    apiLevel = 34
+                    systemImageSource = "aosp-atd"
+                }
+            }
+        }
+    }
+}
+
+dependencies {
+    // include core module
+    implementation(project(":core"))
+
+    // Kotlin / Android
+    implementation(libs.kotlin.stdlib)
+    implementation(libs.kotlinx.coroutines)
+    coreLibraryDesugaring(libs.android.desugaring)
+
+    // Hilt
+    implementation(libs.hilt.android.base)
+    ksp(libs.androidx.hilt.compiler)
+    ksp(libs.hilt.android.compiler)
+
+    // support libs
+    implementation(libs.androidx.core)
+    implementation(libs.androidx.hilt.work)
+    implementation(libs.androidx.lifecycle.viewmodel.base)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.work.base)
+
+    // Jetpack Compose
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.compose.material3)
+    debugImplementation(libs.androidx.compose.ui.tooling)
+    implementation(libs.androidx.compose.ui.toolingPreview)
+
+    // own libraries
+    implementation(libs.bitfire.cert4android)
+
+    // third-party libs
+    implementation(libs.guava)
+    implementation(libs.okhttp.base)
+    implementation(libs.openid.appauth)
+}

app-ose/src/main/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+        android:installLocation="internalOnly">
+
+    <application android:name=".App"/>
+
+</manifest>

app-ose/src/main/kotlin/com/davx5/ose/App.kt

@@ -0,0 +1,83 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose
+
+import android.app.Application
+import androidx.hilt.work.HiltWorkerFactory
+import androidx.work.Configuration
+import at.bitfire.davdroid.di.scope.DefaultDispatcher
+import at.bitfire.davdroid.log.LogManager
+import at.bitfire.davdroid.startup.StartupPlugin
+import at.bitfire.davdroid.sync.account.AccountsCleanupWorker
+import at.bitfire.davdroid.ui.UiUtils
+import dagger.hilt.android.HiltAndroidApp
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.DelicateCoroutinesApi
+import kotlinx.coroutines.GlobalScope
+import kotlinx.coroutines.launch
+import java.util.logging.Logger
+import javax.inject.Inject
+
+@HiltAndroidApp
+class App: Application(), Configuration.Provider {
+
+    @Inject
+    lateinit var logger: Logger
+
+    /**
+     * Creates the [at.bitfire.davdroid.log.LogManager] singleton and thus initializes logging.
+     */
+    @Inject
+    lateinit var logManager: LogManager
+
+    @Inject
+    @DefaultDispatcher
+    lateinit var defaultDispatcher: CoroutineDispatcher
+
+    @Inject
+    lateinit var plugins: Set<@JvmSuppressWildcards StartupPlugin>
+
+    @Inject
+    lateinit var workerFactory: HiltWorkerFactory
+
+    override val workManagerConfiguration: Configuration
+        get() = Configuration.Builder()
+            .setWorkerFactory(workerFactory)
+            .build()
+
+
+    override fun onCreate() {
+        super.onCreate()
+
+        logger.fine("Logging using LogManager $logManager")
+
+        // set light/dark mode
+        UiUtils.updateTheme(this)   // when this is called in the asynchronous thread below, it recreates
+                                 // some current activity and causes an IllegalStateException in rare cases
+
+        // run startup plugins (sync)
+        for (plugin in plugins.sortedBy { it.priority() }) {
+            logger.fine("Running startup plugin: $plugin (onAppCreate)")
+            plugin.onAppCreate()
+        }
+
+        // don't block UI for some background checks
+        @OptIn(DelicateCoroutinesApi::class)
+        GlobalScope.launch(defaultDispatcher) {
+            // clean up orphaned accounts in DB from time to time
+            AccountsCleanupWorker.Companion.enable(this@App)
+
+            // create/update app shortcuts
+            UiUtils.updateShortcuts(this@App)
+
+            // run startup plugins (async)
+            for (plugin in plugins.sortedBy { it.priorityAsync() }) {
+                logger.fine("Running startup plugin: $plugin (onAppCreateAsync)")
+                plugin.onAppCreateAsync()
+            }
+        }
+    }
+
+}

app-ose/src/main/res/resources.properties

@@ -0,0 +1,2 @@
+# Set default locale
+unqualifiedResLocale=en-US

app-ose/src/ose/AndroidManifest.xml

@@ -0,0 +1,27 @@
+<!--
+  ~ Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+  -->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <application>
+
+        <!-- AppAuth login flow redirect -->
+        <activity
+            android:name="net.openid.appauth.RedirectUriReceiverActivity"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW"/>
+                <category android:name="android.intent.category.DEFAULT"/>
+                <category android:name="android.intent.category.BROWSABLE"/>
+                <data
+                    tools:ignore="AppLinkUrlError"
+                        android:scheme="${applicationId}"
+                    android:path="/oauth2/redirect"/>
+            </intent-filter>
+        </activity>
+
+    </application>
+
+</manifest>

app-ose/src/ose/kotlin/com/davx5/ose/DebugInfoCrashHandler.kt

@@ -0,0 +1,50 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose
+
+import android.content.Context
+import at.bitfire.davdroid.ui.DebugInfoActivity
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import java.util.logging.Level
+import java.util.logging.Logger
+import javax.inject.Inject
+
+class DebugInfoCrashHandler @Inject constructor(
+    @ApplicationContext private val context: Context,
+    private val logger: Logger
+): Thread.UncaughtExceptionHandler {
+
+    @Module
+    @InstallIn(SingletonComponent::class)
+    interface DebugInfoCrashHandlerModule {
+        @Binds
+        fun debugInfoCrashHandler(
+            debugInfoCrashHandler: DebugInfoCrashHandler
+        ): Thread.UncaughtExceptionHandler
+    }
+
+    // See https://developer.android.com/about/versions/oreo/android-8.0-changes#loue
+    val originalCrashHandler = Thread.getDefaultUncaughtExceptionHandler()
+
+
+    override fun uncaughtException(t: Thread, e: Throwable) {
+        logger.log(Level.SEVERE, "Unhandled exception in thread ${t.id}!", e)
+
+        // start debug info activity with exception (will be started in a new process)
+        val intent = DebugInfoActivity.IntentBuilder(context)
+            .withCause(e)
+            .newTask()
+            .build()
+        context.startActivity(intent)
+
+        // pass through to default handler to kill the process
+        originalCrashHandler?.uncaughtException(t, e)
+    }
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/ColorSchemesModule.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import androidx.compose.material3.ColorScheme
+import at.bitfire.davdroid.di.scope.DarkColorScheme
+import at.bitfire.davdroid.di.scope.LightColorScheme
+import at.bitfire.davdroid.ui.OseTheme
+import dagger.Module
+import dagger.Provides
+import dagger.hilt.InstallIn
+import dagger.hilt.components.SingletonComponent
+
+@Module
+@InstallIn(SingletonComponent::class)
+class ColorSchemesModule {
+
+    @Provides
+    @LightColorScheme
+    fun lightColorScheme(): ColorScheme = OseTheme.lightScheme
+
+    @Provides
+    @DarkColorScheme
+    fun darkColorScheme(): ColorScheme = OseTheme.darkScheme
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/CustomCertManagerModule.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import android.content.Context
+import at.bitfire.cert4android.CustomCertManager
+import at.bitfire.cert4android.CustomCertStore
+import at.bitfire.cert4android.SettingsProvider
+import at.bitfire.davdroid.settings.Settings
+import at.bitfire.davdroid.settings.SettingsManager
+import at.bitfire.davdroid.ui.ForegroundTracker
+import dagger.Module
+import dagger.Provides
+import dagger.Reusable
+import dagger.hilt.InstallIn
+import dagger.hilt.android.qualifiers.ApplicationContext
+import dagger.hilt.components.SingletonComponent
+import okhttp3.internal.tls.OkHostnameVerifier
+import java.util.Optional
+
+/**
+ * cert4android integration module
+ */
+@Module
+@InstallIn(SingletonComponent::class)
+class CustomCertManagerModule {
+
+    @Provides
+    fun customCertStore(@ApplicationContext context: Context): Optional<CustomCertStore> =
+        Optional.of(CustomCertStore.getInstance(context))
+
+    @Provides
+    @Reusable
+    fun customCertManager(
+        customCertStore: Optional<CustomCertStore>,
+        settings: SettingsManager
+    ): Optional<CustomCertManager> =
+        Optional.of(
+            CustomCertManager(
+            certStore = customCertStore.get(),
+            settings = object : SettingsProvider {
+
+                override val appInForeground: Boolean
+                    get() = ForegroundTracker.inForeground.value
+
+                override val trustSystemCerts: Boolean
+                    get() = !settings.getBoolean(Settings.DISTRUST_SYSTEM_CERTIFICATES)
+
+            }
+        ))
+
+    @Provides
+    @Reusable
+    fun customHostnameVerifier(
+        customCertManager: Optional<CustomCertManager>
+    ): Optional<CustomCertManager.HostnameVerifier> =
+        Optional.of(customCertManager.get().HostnameVerifier(OkHostnameVerifier))
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/di/OseFlavorModule.kt

@@ -0,0 +1,51 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.di
+
+import at.bitfire.davdroid.ui.AccountsDrawerHandler
+import at.bitfire.davdroid.ui.OseAccountsDrawerHandler
+import at.bitfire.davdroid.ui.about.AboutActivity
+import at.bitfire.davdroid.ui.intro.IntroPageFactory
+import at.bitfire.davdroid.ui.setup.LoginTypesProvider
+import com.davx5.ose.ui.about.OpenSourceLicenseInfoProvider
+import com.davx5.ose.ui.intro.OseIntroPageFactory
+import at.bitfire.davdroid.ui.setup.StandardLoginTypesProvider
+import dagger.Binds
+import dagger.Module
+import dagger.hilt.InstallIn
+import dagger.hilt.android.components.ActivityComponent
+import dagger.hilt.android.components.ViewModelComponent
+import dagger.hilt.components.SingletonComponent
+
+interface OseModules {
+
+    @Module
+    @InstallIn(ActivityComponent::class)
+    interface ForActivities {
+        @Binds
+        fun accountsDrawerHandler(impl: OseAccountsDrawerHandler): AccountsDrawerHandler
+
+        @Binds
+        fun loginTypesProvider(impl: StandardLoginTypesProvider): LoginTypesProvider
+    }
+
+    @Module
+    @InstallIn(ViewModelComponent::class)
+    interface ForViewModels {
+        @Binds
+        fun appLicenseInfoProvider(impl: OpenSourceLicenseInfoProvider): AboutActivity.AppLicenseInfoProvider
+
+        @Binds
+        fun loginTypesProvider(impl: StandardLoginTypesProvider): LoginTypesProvider
+    }
+
+    @Module
+    @InstallIn(SingletonComponent::class)
+    interface Global {
+        @Binds
+        fun introPageFactory(impl: OseIntroPageFactory): IntroPageFactory
+    }
+
+}

app-ose/src/ose/kotlin/com/davx5/ose/ui/about/OpenSourceLicenseInfoProvider.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.ui.about
+
+import android.content.Context
+import android.text.Spanned
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.text.AnnotatedString
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.core.text.HtmlCompat
+import androidx.lifecycle.ViewModel
+import androidx.lifecycle.viewModelScope
+import androidx.lifecycle.viewmodel.compose.viewModel
+import at.bitfire.davdroid.di.scope.IoDispatcher
+import at.bitfire.davdroid.ui.UiUtils.toAnnotatedString
+import at.bitfire.davdroid.ui.about.AboutActivity
+import com.google.common.io.CharStreams
+import dagger.hilt.android.lifecycle.HiltViewModel
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineDispatcher
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class OpenSourceLicenseInfoProvider @Inject constructor(): AboutActivity.AppLicenseInfoProvider {
+
+    @Composable
+    override fun LicenseInfo() {
+        LicenseInfoGpl()
+    }
+
+    @Composable
+    fun LicenseInfoGpl(
+        model: Model = viewModel()
+    ) {
+        model.gpl?.let { OpenSourceLicenseInfo(it.toAnnotatedString()) }
+    }
+
+
+    @HiltViewModel
+    class Model @Inject constructor(
+        @ApplicationContext private val context: Context,
+        @IoDispatcher private val ioDispatcher: CoroutineDispatcher
+    ): ViewModel() {
+
+        var gpl by mutableStateOf<Spanned?>(null)
+
+        init {
+            viewModelScope.launch(ioDispatcher) {
+                context.resources.assets.open("gplv3.html").use { inputStream ->
+                    val raw = CharStreams.toString(inputStream.bufferedReader())
+                    gpl = HtmlCompat.fromHtml(raw, HtmlCompat.FROM_HTML_MODE_LEGACY)
+                }
+            }
+        }
+
+    }
+
+}
+
+
+@Composable
+fun OpenSourceLicenseInfo(license: AnnotatedString) {
+    Text(text = license)
+}
+
+@Composable
+@Preview
+fun OpenSourceLicenseInfo_Preview() {
+    OpenSourceLicenseInfo(AnnotatedString("It's open-source."))
+}

app-ose/src/ose/kotlin/com/davx5/ose/ui/intro/OseIntroPageFactory.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright © All Contributors. See LICENSE and AUTHORS in the root directory for details.
+ */
+
+package com.davx5.ose.ui.intro
+
+import at.bitfire.davdroid.ui.intro.BackupsPage
+import at.bitfire.davdroid.ui.intro.BatteryOptimizationsPage
+import at.bitfire.davdroid.ui.intro.IntroPageFactory
+import at.bitfire.davdroid.ui.intro.OpenSourcePage
+import at.bitfire.davdroid.ui.intro.PermissionsIntroPage
+import at.bitfire.davdroid.ui.intro.TasksIntroPage
+import at.bitfire.davdroid.ui.intro.WelcomePage
+import javax.inject.Inject
+
+class OseIntroPageFactory @Inject constructor(
+    backupsPage: BackupsPage,
+    batteryOptimizationsPage: BatteryOptimizationsPage,
+    openSourcePage: OpenSourcePage,
+    permissionsIntroPage: PermissionsIntroPage,
+    tasksIntroPage: TasksIntroPage
+): IntroPageFactory {
+
+    override val introPages = arrayOf(
+        WelcomePage(),
+        tasksIntroPage,
+        permissionsIntroPage,
+        batteryOptimizationsPage,
+        backupsPage,
+        openSourcePage
+    )
+
+}

app/build.gradle

@@ -1,108 +0,0 @@
-/*
- * Copyright (c) Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-apply plugin: 'com.android.application'
-apply plugin: 'kotlin-android'
-apply plugin: 'kotlin-android-extensions'
-apply plugin: 'org.jetbrains.dokka-android'
-
-android {
-    compileSdkVersion 27
-    buildToolsVersion '27.0.1'
-
-    defaultConfig {
-        applicationId "at.bitfire.davdroid"
-
-        versionCode 205
-        buildConfigField "long", "buildTime", System.currentTimeMillis() + "L"
-        buildConfigField "boolean", "customCerts", "true"
-
-        minSdkVersion 19        // Android 4.4
-        targetSdkVersion 27     // Android 8.1
-
-        // when using this, make sure that notification icons are real bitmaps
-        vectorDrawables.useSupportLibrary = true
-    }
-
-    flavorDimensions "type"
-
-    productFlavors {
-        standard {
-            versionName "1.10.1.1-ose"
-
-            buildConfigField "boolean", "customCerts", "true"
-            buildConfigField "boolean", "customCertsUI", "true"
-        }
-    }
-
-    buildTypes {
-        debug {
-            minifyEnabled false
-        }
-        release {
-            minifyEnabled true
-            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
-        }
-    }
-
-    lintOptions {
-        disable 'GoogleAppIndexingWarning'      // we don't need Google indexing, thanks
-        disable 'ImpliedQuantity', 'MissingQuantity'		// quantities from Transifex may vary
-        disable 'MissingTranslation', 'ExtraTranslation'	// translations from Transifex are not always up to date
-        disable "OnClick"     // doesn't recognize Kotlin onClick methods
-        disable 'Recycle'           // doesn't understand Lombok's @Cleanup
-        disable 'RtlEnabled'
-        disable 'RtlHardcoded'
-        disable 'Typos'
-    }
-    packagingOptions {
-        exclude 'META-INF/DEPENDENCIES'
-        exclude 'META-INF/LICENSE'
-    }
-
-    defaultConfig {
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
-    }
-}
-
-dependencies {
-    compile project(':cert4android')
-    compile project(':dav4android')
-    compile project(':ical4android')
-    compile project(':vcard4android')
-
-    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
-
-    compile 'com.android.support:appcompat-v7:27.0.2'
-    compile 'com.android.support:cardview-v7:27.0.2'
-    compile 'com.android.support:design:27.0.2'
-    compile 'com.android.support:preference-v14:27.0.2'
-
-    compile 'com.github.yukuku:ambilwarna:2.0.1'
-
-    compile 'com.squareup.okhttp3:logging-interceptor:3.9.1'
-    compile 'commons-io:commons-io:2.6'
-    compile 'dnsjava:dnsjava:2.1.8'
-    compile 'org.apache.commons:commons-lang3:3.6'
-    compile 'org.apache.commons:commons-collections4:4.1'
-
-    // for tests
-    //noinspection GradleDynamicVersion
-    androidTestCompile('com.android.support.test:runner:+') {
-        exclude group: 'com.android.support', module: 'support-annotations'
-    }
-    //noinspection GradleDynamicVersion
-    androidTestCompile('com.android.support.test:rules:+') {
-        exclude group: 'com.android.support', module: 'support-annotations'
-    }
-    androidTestCompile 'junit:junit:4.12'
-    androidTestCompile 'com.squareup.okhttp3:mockwebserver:3.9.1'
-
-    testCompile 'junit:junit:4.12'
-    testCompile 'com.squareup.okhttp3:mockwebserver:3.9.1'
-}

app/proguard-rules.txt

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

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

@@ -1,128 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid;
-
-import android.support.test.InstrumentationRegistry.getInstrumentation
-import at.bitfire.cert4android.CustomCertManager
-import okhttp3.OkHttpClient
-import okhttp3.Request
-import okhttp3.mockwebserver.MockWebServer
-import org.apache.commons.io.IOUtils
-import org.apache.commons.lang3.ArrayUtils.contains
-import org.junit.After
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.Test
-import java.net.Socket
-import java.security.KeyFactory
-import java.security.KeyStore
-import java.security.Principal
-import java.security.cert.CertificateFactory
-import java.security.cert.X509Certificate
-import java.security.spec.PKCS8EncodedKeySpec
-import javax.net.ssl.SSLSocket
-import javax.net.ssl.TrustManagerFactory
-import javax.net.ssl.X509ExtendedKeyManager
-import javax.net.ssl.X509TrustManager
-
-class CustomTlsSocketFactoryTest {
-
-    lateinit var certMgr: CustomCertManager
-    lateinit var factory: CustomTlsSocketFactory
-    val server = MockWebServer()
-
-    @Before
-    fun startServer() {
-        certMgr = CustomCertManager(getInstrumentation().context, false, true)
-        factory = CustomTlsSocketFactory(null, certMgr)
-        server.start()
-    }
-
-    @After
-    fun stopServer() {
-        server.shutdown()
-        certMgr.close()
-    }
-
-
-    @Test
-    fun testSendClientCertificate() {
-        var public: X509Certificate? = null
-        javaClass.classLoader.getResourceAsStream("sample.crt").use {
-            public = CertificateFactory.getInstance("X509").generateCertificate(it) as? X509Certificate
-        }
-        assertNotNull(public)
-
-        val keyFactory = KeyFactory.getInstance("RSA")
-        val private = keyFactory.generatePrivate(PKCS8EncodedKeySpec(readResource("sample.key")))
-        assertNotNull(private)
-
-        val keyStore = KeyStore.getInstance("AndroidKeyStore")
-        keyStore.load(null)
-        val alias = "sample"
-        keyStore.setKeyEntry(alias, private, null, arrayOf(public))
-        assertTrue(keyStore.containsAlias(alias))
-
-        val trustManagerFactory = TrustManagerFactory.getInstance("X509")
-        trustManagerFactory.init(null as KeyStore?)
-        val trustManager = trustManagerFactory.trustManagers.first() as X509TrustManager
-
-        val factory = CustomTlsSocketFactory(object: X509ExtendedKeyManager() {
-            override fun getServerAliases(p0: String?, p1: Array<out Principal>?): Array<String>? = null
-            override fun chooseServerAlias(p0: String?, p1: Array<out Principal>?, p2: Socket?) = null
-
-            override fun getClientAliases(p0: String?, p1: Array<out Principal>?) =
-                    arrayOf(alias)
-
-            override fun chooseClientAlias(p0: Array<out String>?, p1: Array<out Principal>?, p2: Socket?) =
-                    alias
-
-            override fun getCertificateChain(forAlias: String?) =
-                    arrayOf(public).takeIf { forAlias == alias }
-
-            override fun getPrivateKey(forAlias: String?) =
-                    private.takeIf { forAlias == alias }
-        }, trustManager)
-
-        /* known client cert test URLs (thanks!):
-        *  - https://prod.idrix.eu/secure/
-        *  - https://server.cryptomix.com/secure/
-        */
-        val client = OkHttpClient.Builder()
-                .sslSocketFactory(factory, trustManager)
-                .build()
-        client.newCall(Request.Builder()
-                .get()
-                .url("https://prod.idrix.eu/secure/")
-                .build()).execute().use { response ->
-            assertTrue(response.isSuccessful)
-            assertTrue(response.body()!!.string().contains("CN=User Cert,O=Internet Widgits Pty Ltd,ST=Some-State,C=CA"))
-        }
-    }
-
-    @Test
-    fun testUpgradeTLS() {
-        val s = factory.createSocket(server.hostName, server.port)
-        assertTrue(s is SSLSocket)
-        val ssl = s as SSLSocket
-
-        assertFalse(contains(ssl.enabledProtocols, "SSLv3"))
-        assertTrue(contains(ssl.enabledProtocols, "TLSv1"))
-        assertTrue(contains(ssl.enabledProtocols, "TLSv1.1"))
-        assertTrue(contains(ssl.enabledProtocols, "TLSv1.2"))
-    }
-
-
-    private fun readResource(name: String): ByteArray {
-        this.javaClass.classLoader.getResourceAsStream(name).use {
-            return IOUtils.toByteArray(it)
-        }
-    }
-
-}

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

@@ -1,133 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.model;
-
-import android.content.ContentValues;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.IOException;
-
-import at.bitfire.dav4android.DavResource;
-import at.bitfire.dav4android.exception.DavException;
-import at.bitfire.dav4android.exception.HttpException;
-import at.bitfire.dav4android.property.ResourceType;
-import at.bitfire.davdroid.HttpClient;
-import at.bitfire.davdroid.model.ServiceDB.Collections;
-import okhttp3.mockwebserver.MockResponse;
-import okhttp3.mockwebserver.MockWebServer;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-public class CollectionInfoTest {
-
-    HttpClient httpClient;
-    MockWebServer server = new MockWebServer();
-
-    @Before
-    public void setUp() {
-        httpClient = new HttpClient.Builder().build();
-    }
-
-    @After
-    public void shutDown() {
-        httpClient.close();
-    }
-
-
-    @Test
-    public void testFromDavResource() throws IOException, HttpException, DavException {
-        // r/w address book
-        server.enqueue(new 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>"));
-
-        DavResource dav = new DavResource(httpClient.getOkHttpClient(), server.url("/"));
-        dav.propfind(0, ResourceType.NAME);
-        CollectionInfo info = new CollectionInfo(dav);
-        assertEquals(CollectionInfo.Type.ADDRESS_BOOK, info.getType());
-        assertFalse(info.getReadOnly());
-        assertEquals("My Contacts", info.getDisplayName());
-        assertEquals("My Contacts Description", info.getDescription());
-
-        // read-only calendar, no display name
-        server.enqueue(new 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>"));
-
-        dav = new DavResource(httpClient.getOkHttpClient(), server.url("/"));
-        dav.propfind(0, ResourceType.NAME);
-        info = new CollectionInfo(dav);
-        assertEquals(CollectionInfo.Type.CALENDAR, info.getType());
-        assertTrue(info.getReadOnly());
-        assertNull(info.getDisplayName());
-        assertEquals("My Calendar", info.getDescription());
-        assertEquals(0xFFFF0000, (int)info.getColor());
-        assertEquals("tzdata", info.getTimeZone());
-        assertTrue(info.getSupportsVEVENT());
-        assertTrue(info.getSupportsVTODO());
-    }
-
-    @Test
-    public void testFromDB() {
-        ContentValues values = new ContentValues();
-        values.put(Collections.ID, 1);
-        values.put(Collections.SERVICE_ID, 1);
-        values.put(Collections.TYPE, CollectionInfo.Type.CALENDAR.name());
-        values.put(Collections.URL, "http://example.com");
-        values.put(Collections.READ_ONLY, 1);
-        values.put(Collections.DISPLAY_NAME, "display name");
-        values.put(Collections.DESCRIPTION, "description");
-        values.put(Collections.COLOR, 0xFFFF0000);
-        values.put(Collections.TIME_ZONE, "tzdata");
-        values.put(Collections.SUPPORTS_VEVENT, 1);
-        values.put(Collections.SUPPORTS_VTODO, 1);
-        values.put(Collections.SYNC, 1);
-
-        CollectionInfo info = new CollectionInfo(values);
-        assertEquals(CollectionInfo.Type.CALENDAR, info.getType());
-        assertEquals(1, (long)info.getId());
-        assertEquals(1, (long)info.getServiceID());
-        assertEquals("http://example.com", info.getUrl());
-        assertTrue(info.getReadOnly());
-        assertEquals("display name", info.getDisplayName());
-        assertEquals("description", info.getDescription());
-        assertEquals(0xFFFF0000, (int)info.getColor());
-        assertEquals("tzdata", info.getTimeZone());
-        assertTrue(info.getSupportsVEVENT());
-        assertTrue(info.getSupportsVTODO());
-        assertTrue(info.getSelected());
-    }
-
-}

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

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

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

@@ -1,44 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import android.content.ServiceConnection
-import android.support.test.InstrumentationRegistry
-import android.support.test.InstrumentationRegistry.getTargetContext
-import at.bitfire.davdroid.App
-import junit.framework.Assert.*
-import org.junit.After
-import org.junit.Before
-import org.junit.Test
-
-class SettingsTest {
-
-    lateinit var settings: Settings.Stub
-
-    @Before
-    fun init() {
-        InstrumentationRegistry.getContext().isRestricted
-        settings = Settings.getInstance(getTargetContext())!!
-    }
-
-    @After
-    fun shutdown() {
-        settings.close()
-    }
-
-
-    @Test
-    fun testHas() {
-        assertFalse(settings.has("notExisting"))
-
-        // provided by DefaultsProvider
-        assertTrue(settings.has(App.OVERRIDE_PROXY))
-    }
-
-}

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

@@ -1,201 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.ui.setup;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.io.IOException;
-import java.net.URI;
-
-import at.bitfire.dav4android.DavResource;
-import at.bitfire.dav4android.exception.DavException;
-import at.bitfire.dav4android.exception.HttpException;
-import at.bitfire.dav4android.property.AddressbookHomeSet;
-import at.bitfire.dav4android.property.ResourceType;
-import at.bitfire.davdroid.HttpClient;
-import at.bitfire.davdroid.log.Logger;
-import at.bitfire.davdroid.model.Credentials;
-import at.bitfire.davdroid.ui.setup.DavResourceFinder.Configuration.ServiceInfo;
-import okhttp3.mockwebserver.Dispatcher;
-import okhttp3.mockwebserver.MockResponse;
-import okhttp3.mockwebserver.MockWebServer;
-import okhttp3.mockwebserver.RecordedRequest;
-
-import static android.support.test.InstrumentationRegistry.getTargetContext;
-import static junit.framework.TestCase.assertFalse;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-
-public class DavResourceFinderTest {
-
-    MockWebServer server = new MockWebServer();
-
-    DavResourceFinder finder;
-    HttpClient client;
-    LoginInfo loginInfo;
-
-    private static final String
-            PATH_NO_DAV = "/nodav",
-
-            PATH_CALDAV = "/caldav",
-            PATH_CARDDAV = "/carddav",
-            PATH_CALDAV_AND_CARDDAV = "/both-caldav-carddav",
-
-            SUBPATH_PRINCIPAL = "/principal",
-            SUBPATH_ADDRESSBOOK_HOMESET = "/addressbooks",
-            SUBPATH_ADDRESSBOOK = "/addressbooks/private-contacts";
-
-    @Before
-    public void initServerAndClient() throws Exception {
-        server.setDispatcher(new TestDispatcher());
-        server.start();
-
-        loginInfo = new LoginInfo(URI.create("/"), new Credentials("mock", "12345"));
-        finder = new DavResourceFinder(getTargetContext(), loginInfo);
-
-        client = new HttpClient.Builder()
-                .addAuthentication(null, loginInfo.credentials)
-                .build();
-    }
-
-    @After
-    public void stopServer() throws Exception {
-        server.shutdown();
-    }
-
-    @Test
-    public void testRememberIfAddressBookOrHomeset() throws IOException, HttpException, DavException {
-        ServiceInfo info;
-
-        // before dav.propfind(), no info is available
-        DavResource dav = new DavResource(client.getOkHttpClient(), server.url(PATH_CARDDAV + SUBPATH_PRINCIPAL));
-        finder.rememberIfAddressBookOrHomeset(dav, info = new ServiceInfo());
-        assertEquals(0, info.getCollections().size());
-        assertEquals(0, info.getHomeSets().size());
-
-        // recognize home set
-        dav.propfind(0, AddressbookHomeSet.NAME);
-        finder.rememberIfAddressBookOrHomeset(dav, info = new ServiceInfo());
-        assertEquals(0, info.getCollections().size());
-        assertEquals(1, info.getHomeSets().size());
-        assertEquals(server.url(PATH_CARDDAV + SUBPATH_ADDRESSBOOK_HOMESET + "/").uri(), info.getHomeSets().iterator().next());
-
-        // recognize address book
-        dav = new DavResource(client.getOkHttpClient(), server.url(PATH_CARDDAV + SUBPATH_ADDRESSBOOK));
-        dav.propfind(0, ResourceType.NAME);
-        finder.rememberIfAddressBookOrHomeset(dav, info = new ServiceInfo());
-        assertEquals(1, info.getCollections().size());
-        assertEquals(server.url(PATH_CARDDAV + SUBPATH_ADDRESSBOOK + "/").uri(), info.getCollections().keySet().iterator().next());
-        assertEquals(0, info.getHomeSets().size());
-    }
-
-    @Test
-    public void testProvidesService() throws IOException {
-        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
-    public void testGetCurrentUserPrincipal() throws IOException, HttpException, DavException {
-        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).uri(),
-                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).uri(),
-                finder.getCurrentUserPrincipal(server.url(PATH_CARDDAV), DavResourceFinder.Service.CARDDAV)
-        );
-        assertNull(finder.getCurrentUserPrincipal(server.url(PATH_CARDDAV), DavResourceFinder.Service.CALDAV));
-    }
-
-
-    // mock server
-
-    public class TestDispatcher extends Dispatcher {
-
-        @Override
-        public MockResponse dispatch(RecordedRequest rq) throws InterruptedException {
-            if (!checkAuth(rq)) {
-                MockResponse authenticate = new MockResponse().setResponseCode(401);
-                authenticate.setHeader("WWW-Authenticate", "Basic realm=\"test\"");
-                return authenticate;
-            }
-
-            String path = rq.getPath();
-
-            if ("OPTIONS".equalsIgnoreCase(rq.getMethod())) {
-                String dav = null;
-                if (path.startsWith(PATH_CALDAV))
-                    dav = "calendar-access";
-                else if (path.startsWith(PATH_CARDDAV))
-                    dav = "addressbook";
-                else if (path.startsWith(PATH_CALDAV_AND_CARDDAV))
-                    dav = "calendar-access, addressbook";
-                MockResponse response = new MockResponse().setResponseCode(200);
-                if (dav != null)
-                       response.addHeader("DAV", dav);
-                return response;
-
-            } else if ("PROPFIND".equalsIgnoreCase(rq.getMethod())) {
-                String props = null;
-                switch (path) {
-                    case PATH_CALDAV:
-                    case PATH_CARDDAV:
-                        props = "<current-user-principal><href>" + path + SUBPATH_PRINCIPAL + "</href></current-user-principal>";
-                        break;
-
-                    case PATH_CARDDAV + SUBPATH_PRINCIPAL:
-                        props = "<CARD:addressbook-home-set>" +
-                                "   <href>" + PATH_CARDDAV + SUBPATH_ADDRESSBOOK_HOMESET + "</href>" +
-                                "</CARD:addressbook-home-set>";
-                        break;
-                    case PATH_CARDDAV + SUBPATH_ADDRESSBOOK:
-                        props = "<resourcetype>" +
-                                "   <collection/>" +
-                                "   <CARD:addressbook/>" +
-                                "</resourcetype>";
-                        break;
-                }
-                Logger.log.info("Sending props: " + props);
-                return new MockResponse()
-                        .setResponseCode(207)
-                        .setBody("<multistatus xmlns='DAV:' xmlns:CARD='urn:ietf:params:xml:ns:carddav'>" +
-                                "<response>" +
-                                "   <href>" + rq.getPath() + "</href>" +
-                                "   <propstat><prop>" + props + "</prop></propstat>" +
-                                "</response>" +
-                                "</multistatus>");
-            }
-
-            return new MockResponse().setResponseCode(404);
-        }
-
-        private boolean checkAuth(RecordedRequest rq) {
-            return "Basic bW9jazoxMjM0NQ==".equals(rq.getHeader("Authorization"));
-        }
-    }
-
-}

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

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

app/src/androidTest/resources/sample.crt

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

app/src/main/AndroidManifest.xml

@@ -1,207 +0,0 @@
-<?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
--->
-<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.INTERNET"/>
-    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS"/>
-    <uses-permission android:name="android.permission.READ_SYNC_STATS"/>
-    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
-    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS"/>
-
-    <!-- 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"/>
-
-    <!--
-         for writing external log files; permission only required for SDK <= 18 because since then,
-         writing to app-private directory doesn't require extra permissions
-    -->
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="18"/>
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" android:maxSdkVersion="18"/>
-
-    <!-- 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"/>
-
-    <!-- ical4android declares task access permissions -->
-
-    <application
-        android:name=".App"
-        android:allowBackup="true"
-        android:fullBackupContent="false"
-        android:networkSecurityConfig="@xml/network_security_config"
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/AppTheme"
-        tools:ignore="UnusedAttribute">
-
-        <service android:name=".DavService"/>
-        <service android:name=".settings.Settings"/>
-
-        <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/app_name"
-            android:theme="@style/AppTheme.NoActionBar"
-            android:parentActivityName=".ui.AccountsActivity"/>
-
-        <activity
-            android:name=".ui.AppSettingsActivity"
-            android:label="@string/app_settings"
-            android:parentActivityName=".ui.AccountsActivity"/>
-
-        <activity android:name=".ui.PermissionsActivity"
-                  android:label="@string/permissions_title"
-                  android:parentActivityName=".ui.AccountsActivity"/>
-
-        <activity
-            android:name=".ui.setup.LoginActivity"
-            android:label="@string/login_title"
-            android:parentActivityName=".ui.AccountsActivity">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN"/>
-            </intent-filter>
-        </activity>
-
-        <activity
-            android:name=".ui.AccountActivity"
-            android:parentActivityName=".ui.AccountsActivity">
-        </activity>
-        <activity android:name=".ui.AccountSettingsActivity"/>
-        <activity android:name=".ui.CreateAddressBookActivity"
-            android:label="@string/create_addressbook"/>
-        <activity android:name=".ui.CreateCalendarActivity"
-                  android:label="@string/create_calendar"/>
-
-        <activity
-            android:name=".ui.DebugInfoActivity"
-            android:parentActivityName=".ui.AppSettingsActivity"
-            android:exported="true"
-            android:label="@string/debug_info_title">
-        </activity>
-        <provider
-            android:name="android.support.v4.content.FileProvider"
-            android:authorities="@string/authority_log_provider"
-            android:grantUriPermissions="true"
-            android:exported="false">
-            <meta-data
-                android:name="android.support.FILE_PROVIDER_PATHS"
-                android:resource="@xml/log_paths" />
-        </provider>
-
-        <!-- account type "DAVdroid" -->
-        <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"
-            android:process=":sync"
-            tools:ignore="ExportedService">
-            <intent-filter>
-                <action android:name="android.content.SyncAdapter"/>
-            </intent-filter>
-
-            <meta-data
-                android:name="android.content.SyncAdapter"
-                android:resource="@xml/sync_calendars"/>
-        </service>
-        <service
-            android:name=".syncadapter.TasksSyncAdapterService"
-            android:exported="true"
-            android:process=":sync"
-            tools:ignore="ExportedService">
-            <intent-filter>
-                <action android:name="android.content.SyncAdapter"/>
-            </intent-filter>
-
-            <meta-data
-                android:name="android.content.SyncAdapter"
-                android:resource="@xml/sync_tasks"/>
-        </service>
-
-        <!-- account type "DAVdroid Address book" -->
-        <service
-            android:name=".syncadapter.NullAuthenticatorService"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="android.accounts.AccountAuthenticator"/>
-            </intent-filter>
-
-            <meta-data
-                android:name="android.accounts.AccountAuthenticator"
-                android:resource="@xml/account_authenticator_address_book"/>
-        </service>
-        <provider
-            android:authorities="@string/address_books_authority"
-            android:exported="false"
-            android:label="@string/address_books_authority_title"
-            android:name=".syncadapter.AddressBookProvider"
-            android:multiprocess="false"/>
-        <service
-            android:name=".syncadapter.AddressBooksSyncAdapterService"
-            android:exported="true"
-            android:process=":sync"
-            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"
-            android:process=":sync"
-            tools:ignore="ExportedService">
-            <intent-filter>
-                <action android:name="android.content.SyncAdapter"/>
-            </intent-filter>
-
-            <meta-data
-                android:name="android.content.SyncAdapter"
-                android:resource="@xml/sync_contacts"/>
-            <meta-data
-                android:name="android.provider.CONTACTS_STRUCTURE"
-                android:resource="@xml/contacts"/>
-        </service>
-
-    </application>
-
-</manifest>

app/src/main/aidl/at/bitfire/davdroid/settings/ISettings.aidl

@@ -1,28 +0,0 @@
-package at.bitfire.davdroid.settings;
-
-import at.bitfire.davdroid.settings.ISettingsObserver;
-
-interface ISettings {
-
-    void forceReload();
-
-    boolean has(String key);
-
-    boolean getBoolean(String key, boolean defaultValue);
-    int getInt(String key, int defaultValue);
-    long getLong(String key, long defaultValue);
-    String getString(String key, String defaultValue);
-
-    boolean isWritable(String key);
-
-    boolean putBoolean(String key, boolean value);
-    boolean putInt(String key, int value);
-    boolean putLong(String key, long value);
-    boolean putString(String key, String value);
-
-    boolean remove(String key);
-
-    void registerObserver(ISettingsObserver observer);
-    void unregisterObserver(ISettingsObserver observer);
-
-}

app/src/main/aidl/at/bitfire/davdroid/settings/ISettingsObserver.aidl

@@ -1,7 +0,0 @@
-package at.bitfire.davdroid.settings;
-
-interface ISettingsObserver {
-
-    void onSettingsChanged();
-
-}

app/src/main/assets/apache2.html

@@ -1,153 +0,0 @@
-<h3>Apache License, Version 2.0, January 2004</h3>
-<p><a href="http://www.apache.org/licenses/">http://www.apache.org/licenses/</a> </p>
-<p>TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION</p>
-<p><strong><a name="definitions">1. Definitions</a></strong>.</p>
-<p>"License" shall mean the terms and conditions for use, reproduction, and
-distribution as defined by Sections 1 through 9 of this document.</p>
-<p>"Licensor" shall mean the copyright owner or entity authorized by the
-copyright owner that is granting the License.</p>
-<p>"Legal Entity" shall mean the union of the acting entity and all other
-entities that control, are controlled by, or are under common control with
-that entity. For the purposes of this definition, "control" means (i) the
-power, direct or indirect, to cause the direction or management of such
-entity, whether by contract or otherwise, or (ii) ownership of fifty
-percent (50%) or more of the outstanding shares, or (iii) beneficial
-ownership of such entity.</p>
-<p>"You" (or "Your") shall mean an individual or Legal Entity exercising
-permissions granted by this License.</p>
-<p>"Source" form shall mean the preferred form for making modifications,
-including but not limited to software source code, documentation source,
-and configuration files.</p>
-<p>"Object" form shall mean any form resulting from mechanical transformation
-or translation of a Source form, including but not limited to compiled
-object code, generated documentation, and conversions to other media types.</p>
-<p>"Work" shall mean the work of authorship, whether in Source or Object form,
-made available under the License, as indicated by a copyright notice that
-is included in or attached to the work (an example is provided in the
-Appendix below).</p>
-<p>"Derivative Works" shall mean any work, whether in Source or Object form,
-that is based on (or derived from) the Work and for which the editorial
-revisions, annotations, elaborations, or other modifications represent, as
-a whole, an original work of authorship. For the purposes of this License,
-Derivative Works shall not include works that remain separable from, or
-merely link (or bind by name) to the interfaces of, the Work and Derivative
-Works thereof.</p>
-<p>"Contribution" shall mean any work of authorship, including the original
-version of the Work and any modifications or additions to that Work or
-Derivative Works thereof, that is intentionally submitted to Licensor for
-inclusion in the Work by the copyright owner or by an individual or Legal
-Entity authorized to submit on behalf of the copyright owner. For the
-purposes of this definition, "submitted" means any form of electronic,
-verbal, or written communication sent to the Licensor or its
-representatives, including but not limited to communication on electronic
-mailing lists, source code control systems, and issue tracking systems that
-are managed by, or on behalf of, the Licensor for the purpose of discussing
-and improving the Work, but excluding communication that is conspicuously
-marked or otherwise designated in writing by the copyright owner as "Not a
-Contribution."</p>
-<p>"Contributor" shall mean Licensor and any individual or Legal Entity on
-behalf of whom a Contribution has been received by Licensor and
-subsequently incorporated within the Work.</p>
-<p><strong><a name="copyright">2. Grant of Copyright License</a></strong>. Subject to the
-terms and conditions of this License, each Contributor hereby grants to You
-a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-copyright license to reproduce, prepare Derivative Works of, publicly
-display, publicly perform, sublicense, and distribute the Work and such
-Derivative Works in Source or Object form.</p>
-<p><strong><a name="patent">3. Grant of Patent License</a></strong>. Subject to the terms
-and conditions of this License, each Contributor hereby grants to You a
-perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-(except as stated in this section) patent license to make, have made, use,
-offer to sell, sell, import, and otherwise transfer the Work, where such
-license applies only to those patent claims licensable by such Contributor
-that are necessarily infringed by their Contribution(s) alone or by
-combination of their Contribution(s) with the Work to which such
-Contribution(s) was submitted. If You institute patent litigation against
-any entity (including a cross-claim or counterclaim in a lawsuit) alleging
-that the Work or a Contribution incorporated within the Work constitutes
-direct or contributory patent infringement, then any patent licenses
-granted to You under this License for that Work shall terminate as of the
-date such litigation is filed.</p>
-<p><strong><a name="redistribution">4. Redistribution</a></strong>. You may reproduce and
-distribute copies of the Work or Derivative Works thereof in any medium,
-with or without modifications, and in Source or Object form, provided that
-You meet the following conditions:</p>
-
-<p>a. You must give any other recipients of the Work or Derivative Works a
-copy of this License; and</p>
-
-<p>b. You must cause any modified files to carry prominent notices stating
-that You changed the files; and</p>
-
-<p>c. You must retain, in the Source form of any Derivative Works that You
-distribute, all copyright, patent, trademark, and attribution notices from
-the Source form of the Work, excluding those notices that do not pertain to
-any part of the Derivative Works; and</p>
-
-<p>d. If the Work includes a "NOTICE" text file as part of its distribution,
-then any Derivative Works that You distribute must include a readable copy
-of the attribution notices contained within such NOTICE file, excluding
-those notices that do not pertain to any part of the Derivative Works, in
-at least one of the following places: within a NOTICE text file distributed
-as part of the Derivative Works; within the Source form or documentation,
-if provided along with the Derivative Works; or, within a display generated
-by the Derivative Works, if and wherever such third-party notices normally
-appear. The contents of the NOTICE file are for informational purposes only
-and do not modify the License. You may add Your own attribution notices
-within Derivative Works that You distribute, alongside or as an addendum to
-the NOTICE text from the Work, provided that such additional attribution
-notices cannot be construed as modifying the License.
-<br/>
-<br/>
-You may add Your own copyright statement to Your modifications and may
-provide additional or different license terms and conditions for use,
-reproduction, or distribution of Your modifications, or for any such
-Derivative Works as a whole, provided Your use, reproduction, and
-distribution of the Work otherwise complies with the conditions stated in
-this License.
-</p>
-
-<p><strong><a name="contributions">5. Submission of Contributions</a></strong>. Unless You
-explicitly state otherwise, any Contribution intentionally submitted for
-inclusion in the Work by You to the Licensor shall be under the terms and
-conditions of this License, without any additional terms or conditions.
-Notwithstanding the above, nothing herein shall supersede or modify the
-terms of any separate license agreement you may have executed with Licensor
-regarding such Contributions.</p>
-<p><strong><a name="trademarks">6. Trademarks</a></strong>. This License does not grant
-permission to use the trade names, trademarks, service marks, or product
-names of the Licensor, except as required for reasonable and customary use
-in describing the origin of the Work and reproducing the content of the
-NOTICE file.</p>
-<p><strong><a name="no-warranty">7. Disclaimer of Warranty</a></strong>. Unless required by
-applicable law or agreed to in writing, Licensor provides the Work (and
-each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT
-WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including,
-without limitation, any warranties or conditions of TITLE,
-NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You
-are solely responsible for determining the appropriateness of using or
-redistributing the Work and assume any risks associated with Your exercise
-of permissions under this License.</p>
-<p><strong><a name="no-liability">8. Limitation of Liability</a></strong>. In no event and
-under no legal theory, whether in tort (including negligence), contract, or
-otherwise, unless required by applicable law (such as deliberate and
-grossly negligent acts) or agreed to in writing, shall any Contributor be
-liable to You for damages, including any direct, indirect, special,
-incidental, or consequential damages of any character arising as a result
-of this License or out of the use or inability to use the Work (including
-but not limited to damages for loss of goodwill, work stoppage, computer
-failure or malfunction, or any and all other commercial damages or losses),
-even if such Contributor has been advised of the possibility of such
-damages.</p>
-<p><strong><a name="additional">9. Accepting Warranty or Additional Liability</a></strong>.
-While redistributing the Work or Derivative Works thereof, You may choose
-to offer, and charge a fee for, acceptance of support, warranty, indemnity,
-or other liability obligations and/or rights consistent with this License.
-However, in accepting such obligations, You may act only on Your own behalf
-and on Your sole responsibility, not on behalf of any other Contributor,
-and only if You agree to indemnify, defend, and hold each Contributor
-harmless for any liability incurred by, or claims asserted against, such
-Contributor by reason of your accepting any such warranty or additional
-liability.</p>
-
-<p>END OF TERMS AND CONDITIONS</p>

app/src/main/assets/bsd-3clause.html

@@ -1,28 +0,0 @@
-<h3>BSD License (3-clause)</h3>
-
-<p>Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions
-are met:</p>
-
-<p>o Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.</p>
-
-<p>o Redistributions in binary form must reproduce the above copyright
-notice, this list of conditions and the following disclaimer in the
-documentation and/or other materials provided with the distribution.</p>
-
-<p>o Neither the name of Ben Fortuna nor the names of any other contributors
-may be used to endorse or promote products derived from this software
-without specific prior written permission.</p>
-
-<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
-CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
-EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
-PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</p>

app/src/main/assets/bsd.html

@@ -1,23 +0,0 @@
-<h3>BSD License</h3>
-
-<p>Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:</p>
-
-<p>1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.</p>
-
-<p>2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.</p>
-
-<p>THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.</p>
-

app/src/main/assets/mit.html

@@ -1,7 +0,0 @@
-<h3>The MIT License (MIT)</h3>
-
-<p>Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:</p>
-
-<p>The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.</p>
-
-<p>THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.</p>

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

@@ -1,527 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.*
-import android.os.Build
-import android.os.Bundle
-import android.os.Parcel
-import android.os.RemoteException
-import android.provider.CalendarContract
-import android.provider.ContactsContract
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.davdroid.model.Credentials
-import at.bitfire.davdroid.model.ServiceDB
-import at.bitfire.davdroid.model.ServiceDB.*
-import at.bitfire.davdroid.model.ServiceDB.Collections
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.resource.LocalCalendar
-import at.bitfire.davdroid.resource.LocalTaskList
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.ical4android.AndroidCalendar
-import at.bitfire.ical4android.AndroidTaskList
-import at.bitfire.ical4android.CalendarStorageException
-import at.bitfire.ical4android.TaskProvider
-import at.bitfire.vcard4android.ContactsStorageException
-import at.bitfire.vcard4android.GroupMethod
-import okhttp3.HttpUrl
-import org.apache.commons.lang3.StringUtils
-import org.dmfs.tasks.contract.TaskContract
-import java.util.*
-import java.util.logging.Level
-
-class AccountSettings @Throws(InvalidAccountException::class) constructor(
-        val context: Context,
-        val settings: ISettings,
-        val account: Account
-) {
-
-    companion object {
-
-        val CURRENT_VERSION = 8
-        val KEY_SETTINGS_VERSION = "version"
-
-        val KEY_USERNAME = "user_name"
-        val KEY_CERTIFICATE_ALIAS = "certificate_alias"
-
-        val KEY_WIFI_ONLY = "wifi_only"               // sync on WiFi only (default: false)
-        val KEY_WIFI_ONLY_SSIDS = "wifi_only_ssids"   // restrict sync to specific WiFi SSIDs
-
-        /** Time range limitation to the past [in days]
-        value = null            default value (DEFAULT_TIME_RANGE_PAST_DAYS)
-        < 0 (-1)          no limit
-        >= 0              entries more than n days in the past won't be synchronized
-         */
-        val KEY_TIME_RANGE_PAST_DAYS = "time_range_past_days"
-        val DEFAULT_TIME_RANGE_PAST_DAYS = 90
-
-        /* Whether DAVdroid sets the local calendar color to the value from service DB at every sync
-           value = null (not existing)     true (default)
-                   "0"                     false */
-        val KEY_MANAGE_CALENDAR_COLORS = "manage_calendar_colors"
-
-        /* Whether DAVdroid populates and uses CalendarContract.Colors
-           value = null (not existing)     false (default)
-                   "1"                     true */
-        val KEY_EVENT_COLORS = "event_colors"
-
-        /** Contact group method:
-        value = null (not existing)     groups as separate VCards (default)
-        "CATEGORIES"            groups are per-contact CATEGORIES
-         */
-        val KEY_CONTACT_GROUP_METHOD = "contact_group_method"
-
-        @JvmField
-        val SYNC_INTERVAL_MANUALLY = -1L
-
-        fun initialUserData(credentials: Credentials): Bundle {
-            val bundle = Bundle(2)
-            bundle.putString(KEY_SETTINGS_VERSION, CURRENT_VERSION.toString())
-
-            when (credentials.type) {
-                Credentials.Type.UsernamePassword ->
-                    bundle.putString(KEY_USERNAME, credentials.userName)
-                Credentials.Type.ClientCertificate ->
-                    bundle.putString(KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
-            }
-
-            return bundle
-        }
-
-    }
-
-
-    val accountManager: AccountManager = AccountManager.get(context)
-
-    init {
-        synchronized(AccountSettings::class.java) {
-            val versionStr = accountManager.getUserData(account, KEY_SETTINGS_VERSION) ?: throw InvalidAccountException(account)
-            var version = 0
-            try {
-                version = Integer.parseInt(versionStr)
-            } catch (e: NumberFormatException) {
-            }
-            Logger.log.fine("Account ${account.name} has version $version, current version: $CURRENT_VERSION")
-
-            if (version < CURRENT_VERSION)
-                update(version)
-        }
-    }
-
-
-    // authentication settings
-
-    fun credentials() = Credentials(
-            accountManager.getUserData(account, KEY_USERNAME),
-            accountManager.getPassword(account),
-            accountManager.getUserData(account, KEY_CERTIFICATE_ALIAS)
-    )
-
-    fun credentials(credentials: Credentials) {
-        accountManager.setUserData(account, KEY_USERNAME, credentials.userName)
-        accountManager.setPassword(account, credentials.password)
-        accountManager.setUserData(account, KEY_CERTIFICATE_ALIAS, credentials.certificateAlias)
-    }
-
-
-    // sync. settings
-
-    fun getSyncInterval(authority: String): Long? {
-        if (ContentResolver.getIsSyncable(account, authority) <= 0)
-            return null
-
-        return if (ContentResolver.getSyncAutomatically(account, authority))
-            ContentResolver.getPeriodicSyncs(account, authority).firstOrNull()?.period ?: SYNC_INTERVAL_MANUALLY
-        else
-            SYNC_INTERVAL_MANUALLY
-    }
-
-    fun setSyncInterval(authority: String, seconds: Long) {
-        if (seconds == SYNC_INTERVAL_MANUALLY) {
-            ContentResolver.setSyncAutomatically(account, authority, false)
-        } else {
-            ContentResolver.setSyncAutomatically(account, authority, true)
-            ContentResolver.addPeriodicSync(account, authority, Bundle(), seconds)
-        }
-    }
-
-    fun getSyncWifiOnly() = if (settings.has(KEY_WIFI_ONLY))
-            settings.getBoolean(KEY_WIFI_ONLY, false)
-                else
-            accountManager.getUserData(account, KEY_WIFI_ONLY) != null
-    fun setSyncWiFiOnly(wiFiOnly: Boolean) =
-            accountManager.setUserData(account, KEY_WIFI_ONLY, if (wiFiOnly) "1" else null)
-
-    fun getSyncWifiOnlySSIDs(): List<String>? = (if (settings.has(KEY_WIFI_ONLY_SSIDS))
-                settings.getString(KEY_WIFI_ONLY_SSIDS, null)
-            else
-                accountManager.getUserData(account, KEY_WIFI_ONLY_SSIDS))?.split(',')
-    fun setSyncWifiOnlySSIDs(ssids: List<String>?) =
-            accountManager.setUserData(account, KEY_WIFI_ONLY_SSIDS, StringUtils.trimToNull(ssids?.joinToString(",")))
-
-
-    // CalDAV settings
-
-    fun getTimeRangePastDays(): Int? {
-        val strDays = accountManager.getUserData(account, KEY_TIME_RANGE_PAST_DAYS)
-        if (strDays != null) {
-            val days = Integer.valueOf(strDays)
-            return if (days < 0) null else days
-        } else
-            return DEFAULT_TIME_RANGE_PAST_DAYS
-    }
-
-    fun setTimeRangePastDays(days: Int?) =
-            accountManager.setUserData(account, KEY_TIME_RANGE_PAST_DAYS, (days ?: -1).toString())
-
-    fun getManageCalendarColors() = if (settings.has(KEY_MANAGE_CALENDAR_COLORS))
-        settings.getBoolean(KEY_MANAGE_CALENDAR_COLORS, false)
-    else
-        accountManager.getUserData(account, KEY_MANAGE_CALENDAR_COLORS) == null
-    fun setManageCalendarColors(manage: Boolean) =
-            accountManager.setUserData(account, KEY_MANAGE_CALENDAR_COLORS, if (manage) null else "0")
-
-    fun getEventColors() = if (settings.has(KEY_EVENT_COLORS))
-            settings.getBoolean(KEY_EVENT_COLORS, false)
-                else
-            accountManager.getUserData(account, KEY_EVENT_COLORS) != null
-    fun setEventColors(useColors: Boolean) =
-            accountManager.setUserData(account, KEY_EVENT_COLORS, if (useColors) "1" else null)
-
-    // CardDAV settings
-
-    fun getGroupMethod(): GroupMethod {
-        val name = settings.getString(KEY_CONTACT_GROUP_METHOD, null) ?:
-                accountManager.getUserData(account, KEY_CONTACT_GROUP_METHOD)
-        if (name != null)
-            try {
-                return GroupMethod.valueOf(name)
-            }
-            catch (e: IllegalArgumentException) {
-            }
-        return GroupMethod.GROUP_VCARDS
-    }
-
-    fun setGroupMethod(method: GroupMethod) {
-        accountManager.setUserData(account, KEY_CONTACT_GROUP_METHOD, method.name)
-    }
-
-
-    // update from previous account settings
-
-    private fun update(baseVersion: Int) {
-        for (toVersion in baseVersion+1 .. CURRENT_VERSION) {
-            val fromVersion = toVersion-1
-            Logger.log.info("Updating account ${account.name} from version $fromVersion to $toVersion")
-            try {
-                val updateProc = this::class.java.getDeclaredMethod("update_${fromVersion}_$toVersion")
-                updateProc.invoke(this)
-
-                Logger.log.info("Account version update successful")
-                accountManager.setUserData(account, KEY_SETTINGS_VERSION, toVersion.toString())
-            } catch (e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't update account settings", e)
-            }
-        }
-    }
-
-    @Suppress("unused")
-    private fun update_7_8() {
-        TaskProvider.acquire(context, TaskProvider.ProviderName.OpenTasks)?.let { provider ->
-            // ETag is now in sync_version instead of sync1
-            // UID  is now in _uid         instead of sync2
-            val cursor = 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)
-            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")
-    private fun update_6_7() {
-        // add calendar colors
-        context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { provider ->
-            try {
-                AndroidCalendar.insertColors(provider, account)
-            } finally {
-                if (Build.VERSION.SDK_INT >= 24)
-                    provider.close()
-                else
-                    provider.release()
-            }
-        }
-
-        // update allowed WiFi settings key
-        val onlySSID = accountManager.getUserData(account, "wifi_only_ssid")
-        accountManager.setUserData(account, KEY_WIFI_ONLY_SSIDS, onlySSID)
-        accountManager.setUserData(account, "wifi_only_ssid", null)
-    }
-
-    @Suppress("unused")
-    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")
-                    if (url == null)
-                        Logger.log.info("No address book URL, ignoring account")
-                    else {
-                        // create new address book
-                        val info = CollectionInfo(url)
-                        info.type = CollectionInfo.Type.ADDRESS_BOOK
-                        info.displayName = account.name
-                        Logger.log.log(Level.INFO, "Creating new address book account", url)
-                        val addressBookAccount = Account(LocalAddressBook.accountName(account, info), context.getString(R.string.account_type_address_book))
-                        if (!accountManager.addAccountExplicitly(addressBookAccount, null, LocalAddressBook.initialUserData(account, info.url)))
-                            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()
-                if (Build.VERSION.SDK_INT >= 24)
-                    provider.close()
-                else
-                    provider.release()
-            }
-        }
-
-        // update version number so that further syncs don't repeat the migration
-        accountManager.setUserData(account, KEY_SETTINGS_VERSION, "6")
-
-        // request sync of new address book account
-        ContentResolver.setIsSyncable(account, context.getString(R.string.address_books_authority), 1)
-        setSyncInterval(context.getString(R.string.address_books_authority), Constants.DEFAULT_SYNC_INTERVAL)
-    }
-
-    /* Android 7.1.1 OpenTasks fix */
-    @Suppress("unused")
-    private fun update_4_5() {
-        // call PackageChangedReceiver which then enables/disables OpenTasks sync when it's (not) available
-        PackageChangedReceiver.updateTaskSync(context)
-    }
-
-    @Suppress("unused")
-    private fun update_3_4() {
-        setGroupMethod(GroupMethod.CATEGORIES)
-    }
-
-    @Suppress("unused")
-    private fun update_2_3() {
-        // Don't show a warning for Android updates anymore
-        accountManager.setUserData(account, "last_android_version", null)
-
-        var serviceCardDAV: Long? = null
-        var serviceCalDAV: Long? = null
-
-        ServiceDB.OpenHelper(context).use { dbHelper ->
-            val db = dbHelper.writableDatabase
-            // we have to create the WebDAV Service database only from the old address book, calendar and task list URLs
-
-            // CardDAV: migrate address books
-            context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)?.let { client ->
-                try {
-                    val addrBook = LocalAddressBook(context, account, client)
-                    val url = addrBook.getURL()
-                    Logger.log.fine("Migrating address book $url")
-
-                    // insert CardDAV service
-                    val values = ContentValues(3)
-                    values.put(Services.ACCOUNT_NAME, account.name)
-                    values.put(Services.SERVICE, Services.SERVICE_CARDDAV)
-                    serviceCardDAV = db.insert(Services._TABLE, null, values)
-
-                    // insert address book
-                    values.clear()
-                    values.put(Collections.SERVICE_ID, serviceCardDAV)
-                    values.put(Collections.URL, url)
-                    values.put(Collections.SYNC, 1)
-                    db.insert(Collections._TABLE, null, values)
-
-                    // insert home set
-                    HttpUrl.parse(url)?.let {
-                        val homeSet = it.resolve("../")
-                        values.clear()
-                        values.put(HomeSets.SERVICE_ID, serviceCardDAV)
-                        values.put(HomeSets.URL, homeSet.toString())
-                        db.insert(HomeSets._TABLE, null, values)
-                    }
-                } catch (e: ContactsStorageException) {
-                    Logger.log.log(Level.SEVERE, "Couldn't migrate address book", e)
-                } finally {
-                    if (Build.VERSION.SDK_INT >= 24)
-                        client.close()
-                    else
-                        @Suppress("deprecation")
-                        client.release()
-                }
-            }
-
-            // CalDAV: migrate calendars + task lists
-            val collections = HashSet<String>()
-            val homeSets = HashSet<HttpUrl>()
-
-            context.contentResolver.acquireContentProviderClient(CalendarContract.AUTHORITY)?.let { client ->
-                try {
-                    val calendars = AndroidCalendar.find(account, client, LocalCalendar.Factory, null, null)
-                    for (calendar in calendars)
-                        calendar.name?.let { url ->
-                            Logger.log.fine("Migrating calendar $url")
-                            collections.add(url)
-                            HttpUrl.parse(url)?.resolve("../")?.let { homeSets.add(it) }
-                        }
-                } catch (e: CalendarStorageException) {
-                    Logger.log.log(Level.SEVERE, "Couldn't migrate calendars", e)
-                } finally {
-                    if (Build.VERSION.SDK_INT >= 24)
-                        client.close()
-                    else
-                        @Suppress("deprecation")
-                        client.release()
-                }
-            }
-
-            AndroidTaskList.acquireTaskProvider(context)?.use { provider ->
-                try {
-                    val taskLists = AndroidTaskList.find(account, provider, LocalTaskList.Factory, null, null)
-                    for (taskList in taskLists)
-                        taskList.syncId?.let { url ->
-                            Logger.log.fine("Migrating task list $url")
-                            collections.add(url)
-                            HttpUrl.parse(url)?.resolve("../")?.let { homeSets.add(it) }
-                        }
-                } catch (e: CalendarStorageException) {
-                    Logger.log.log(Level.SEVERE, "Couldn't migrate task lists", e)
-                }
-            }
-
-            if (!collections.isEmpty()) {
-                // insert CalDAV service
-                val values = ContentValues(3)
-                values.put(Services.ACCOUNT_NAME, account.name)
-                values.put(Services.SERVICE, Services.SERVICE_CALDAV)
-                serviceCalDAV = db.insert(Services._TABLE, null, values)
-
-                // insert collections
-                for (url in collections) {
-                    values.clear()
-                    values.put(Collections.SERVICE_ID, serviceCalDAV)
-                    values.put(Collections.URL, url)
-                    values.put(Collections.SYNC, 1)
-                    db.insert(Collections._TABLE, null, values)
-                }
-
-                // insert home sets
-                for (homeSet in homeSets) {
-                    values.clear()
-                    values.put(HomeSets.SERVICE_ID, serviceCalDAV)
-                    values.put(HomeSets.URL, homeSet.toString())
-                    db.insert(HomeSets._TABLE, null, values)
-                }
-            }
-        }
-
-        // initiate service detection (refresh) to get display names, colors etc.
-        val refresh = Intent(context, DavService::class.java)
-        refresh.action = DavService.ACTION_REFRESH_COLLECTIONS
-        serviceCardDAV?.let {
-            refresh.putExtra(DavService.EXTRA_DAV_SERVICE_ID, it)
-            context.startService(refresh)
-        }
-        serviceCalDAV?.let {
-            refresh.putExtra(DavService.EXTRA_DAV_SERVICE_ID, it)
-            context.startService(refresh)
-        }
-    }
-
-    @Suppress("unused")
-    private fun update_1_2() {
-        /* - KEY_ADDRESSBOOK_URL ("addressbook_url"),
-           - KEY_ADDRESSBOOK_CTAG ("addressbook_ctag"),
-           - KEY_ADDRESSBOOK_VCARD_VERSION ("addressbook_vcard_version") are not used anymore (now stored in ContactsContract.SyncState)
-           - KEY_LAST_ANDROID_VERSION ("last_android_version") has been added
-        */
-
-        // move previous address book info to ContactsContract.SyncState
-        val provider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY) ?:
-            throw ContactsStorageException("Couldn't access Contacts provider")
-
-        try {
-            val addr = LocalAddressBook(context, account, provider)
-
-            // until now, ContactsContract.Settings.UNGROUPED_VISIBLE was not set explicitly
-            val values = ContentValues()
-            values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, 1)
-            addr.updateSettings(values)
-
-            val url = accountManager.getUserData(account, "addressbook_url")
-            if (!url.isNullOrEmpty())
-                addr.setURL(url)
-            accountManager.setUserData(account, "addressbook_url", null)
-
-            val cTag = accountManager.getUserData (account, "addressbook_ctag")
-            if (!cTag.isNullOrEmpty())
-                addr.setCTag(cTag)
-            accountManager.setUserData(account, "addressbook_ctag", null)
-        } finally {
-            if (Build.VERSION.SDK_INT >= 24)
-                provider.close()
-            else
-                @Suppress("deprecation")
-                provider.release()
-        }
-    }
-
-}

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

@@ -1,56 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import android.app.Application
-import android.content.Context
-import android.graphics.Bitmap
-import android.graphics.drawable.BitmapDrawable
-import android.os.Build
-import android.support.v7.app.AppCompatDelegate
-import at.bitfire.davdroid.log.Logger
-
-class App: Application() {
-
-    companion object {
-
-        @JvmField val DISTRUST_SYSTEM_CERTIFICATES = "distrust_system_certs"
-        @JvmField val OVERRIDE_PROXY = "override_proxy"
-        @JvmField val OVERRIDE_PROXY_HOST = "override_proxy_host"
-        @JvmField val OVERRIDE_PROXY_PORT = "override_proxy_port"
-
-        @JvmField val OVERRIDE_PROXY_HOST_DEFAULT = "localhost"
-        @JvmField val OVERRIDE_PROXY_PORT_DEFAULT = 8118
-
-
-        @JvmStatic
-        fun getLauncherBitmap(context: Context): Bitmap? {
-            val drawableLogo = if (android.os.Build.VERSION.SDK_INT >= 21)
-                    context.getDrawable(R.mipmap.ic_launcher)
-                else
-                    @Suppress("deprecation")
-                    context.resources.getDrawable(R.mipmap.ic_launcher)
-            return if (drawableLogo is BitmapDrawable)
-                drawableLogo.bitmap
-            else
-                null
-        }
-
-    }
-
-
-    override fun onCreate() {
-        super.onCreate()
-        Logger.initialize(this)
-
-        if (Build.VERSION.SDK_INT <= 21)
-            AppCompatDelegate.setCompatVectorFromResourcesEnabled(true)
-    }
-
-}

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

@@ -1,23 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid
-
-object Constants {
-
-    // notification IDs
-    @JvmField val NOTIFICATION_EXTERNAL_FILE_LOGGING = 1
-    @JvmField val NOTIFICATION_REFRESH_COLLECTIONS = 2
-    @JvmField val NOTIFICATION_CONTACTS_SYNC = 10
-    @JvmField val NOTIFICATION_CALENDAR_SYNC = 11
-    @JvmField val NOTIFICATION_TASK_SYNC = 12
-    @JvmField val NOTIFICATION_PERMISSIONS = 20
-
-    @JvmField
-    val DEFAULT_SYNC_INTERVAL = 4 * 3600L    // 4 hours
-
-}

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

@@ -1,165 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import android.os.Build
-import at.bitfire.davdroid.log.Logger
-import java.io.IOException
-import java.net.InetAddress
-import java.net.Socket
-import java.security.GeneralSecurityException
-import java.util.*
-import javax.net.ssl.*
-
-/**
- * Custom TLS socket factory with support for
- *   - enabling/disabling algorithms depending on the Android version,
- *   - client certificate authentication
- */
-class CustomTlsSocketFactory(
-        keyManager: KeyManager?,
-        trustManager: X509TrustManager
-): SSLSocketFactory() {
-
-    private var delegate: SSLSocketFactory
-
-    companion object {
-        // Android 5.0+ (API level 21) provides reasonable default settings
-        // but it still allows SSLv3
-        // https://developer.android.com/reference/javax/net/ssl/SSLSocket.html
-        var protocols: Array<String>? = null
-        var cipherSuites: Array<String>? = null
-        init {
-            if (Build.VERSION.SDK_INT >= 23) {
-                // Since Android 6.0 (API level 23),
-                // - TLSv1.1 and TLSv1.2 is enabled by default
-                // - SSLv3 is disabled by default
-                // - all modern ciphers are activated by default
-                protocols = null
-                cipherSuites = null
-                Logger.log.fine("Using device default TLS protocols/ciphers")
-            } else {
-                (SSLSocketFactory.getDefault().createSocket() as? SSLSocket)?.use { socket ->
-                    try {
-                        /* set reasonable protocol versions */
-                        // - enable all supported protocols (enables TLSv1.1 and TLSv1.2 on Android <5.0)
-                        // - remove all SSL versions (especially SSLv3) because they're insecure now
-                        val _protocols = LinkedList<String>()
-                        for (protocol in socket.supportedProtocols.filterNot { it.contains("SSL", true) })
-                            _protocols += protocol
-                        Logger.log.info("Enabling (only) these TLS protocols: ${_protocols.joinToString(", ")}")
-                        protocols = _protocols.toTypedArray()
-
-                        /* set up reasonable cipher suites */
-                        val knownCiphers = arrayOf(
-                                // TLS 1.2
-                                "TLS_RSA_WITH_AES_256_GCM_SHA384",
-                                "TLS_RSA_WITH_AES_128_GCM_SHA256",
-                                "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256",
-                                "TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256",
-                                "TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384",
-                                "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256",
-                                "TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256",
-                                // maximum interoperability
-                                "TLS_RSA_WITH_3DES_EDE_CBC_SHA",
-                                "SSL_RSA_WITH_3DES_EDE_CBC_SHA",
-                                "TLS_RSA_WITH_AES_128_CBC_SHA",
-                                // additionally
-                                "TLS_RSA_WITH_AES_256_CBC_SHA",
-                                "TLS_ECDHE_ECDSA_WITH_3DES_EDE_CBC_SHA",
-                                "TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA",
-                                "TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA",
-                                "TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA"
-                        )
-                        val availableCiphers = socket.supportedCipherSuites
-                        Logger.log.info("Available cipher suites: ${availableCiphers.joinToString(", ")}")
-
-                        /* For maximum security, preferredCiphers should *replace* enabled ciphers (thus
-                         * disabling ciphers which are enabled by default, but have become unsecure), but for
-                         * the security level of DAVdroid and maximum compatibility, disabling of insecure
-                         * ciphers should be a server-side task */
-
-                        // for the final set of enabled ciphers, take the ciphers enabled by default, ...
-                        val _cipherSuites = LinkedList<String>()
-                        _cipherSuites.addAll(socket.enabledCipherSuites)
-                        Logger.log.fine("Cipher suites enabled by default: ${_cipherSuites.joinToString(", ")}")
-                        // ... add explicitly allowed ciphers ...
-                        _cipherSuites.addAll(knownCiphers)
-                        // ... and keep only those which are actually available
-                        _cipherSuites.retainAll(availableCiphers)
-
-                        Logger.log.info("Enabling (only) these TLS ciphers: " + _cipherSuites.joinToString(", "))
-                        cipherSuites = _cipherSuites.toTypedArray()
-                    } catch (e: IOException) {
-                        Logger.log.severe("Couldn't determine default TLS settings")
-                    }
-                }
-            }
-        }
-    }
-
-
-    init {
-        try {
-            val sslContext = SSLContext.getInstance("TLS")
-            sslContext.init(
-                    if (keyManager != null) arrayOf(keyManager) else null,
-                    arrayOf(trustManager),
-                    null)
-            delegate = sslContext.socketFactory
-        } catch (e: GeneralSecurityException) {
-            throw IllegalStateException()      // system has no TLS
-        }
-    }
-
-    override fun getDefaultCipherSuites(): Array<String>? = cipherSuites ?: delegate.defaultCipherSuites
-    override fun getSupportedCipherSuites(): Array<String>? = cipherSuites ?: delegate.supportedCipherSuites
-
-    override fun createSocket(s: Socket, host: String, port: Int, autoClose: Boolean): Socket {
-        val ssl = delegate.createSocket(s, host, port, autoClose)
-        if (ssl is SSLSocket)
-            upgradeTLS(ssl)
-        return ssl
-    }
-
-    override fun createSocket(host: String, port: Int): Socket {
-        val ssl = delegate.createSocket(host, port)
-        if (ssl is SSLSocket)
-            upgradeTLS(ssl)
-        return ssl
-    }
-
-    override fun createSocket(host: String, port: Int, localHost: InetAddress, localPort: Int): Socket {
-        val ssl = delegate.createSocket(host, port, localHost, localPort)
-        if (ssl is SSLSocket)
-            upgradeTLS(ssl)
-        return ssl
-    }
-
-    override fun createSocket(host: InetAddress, port: Int): Socket {
-        val ssl = delegate.createSocket(host, port)
-        if (ssl is SSLSocket)
-            upgradeTLS(ssl)
-        return ssl
-    }
-
-    override fun createSocket(address: InetAddress, port: Int, localAddress: InetAddress, localPort: Int): Socket {
-        val ssl = delegate.createSocket(address, port, localAddress, localPort)
-        if (ssl is SSLSocket)
-            upgradeTLS(ssl)
-        return ssl
-    }
-
-
-    private fun upgradeTLS(ssl: SSLSocket) {
-        protocols?.let { ssl.enabledProtocols = it }
-        cipherSuites?.let { ssl.enabledCipherSuites = it }
-    }
-
-}

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

@@ -1,344 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import android.accounts.Account
-import android.app.PendingIntent
-import android.app.Service
-import android.content.ContentValues
-import android.content.Intent
-import android.database.DatabaseUtils
-import android.database.sqlite.SQLiteDatabase
-import android.os.Binder
-import android.support.v4.app.NotificationCompat
-import at.bitfire.dav4android.DavResource
-import at.bitfire.dav4android.UrlUtils
-import at.bitfire.dav4android.exception.DavException
-import at.bitfire.dav4android.exception.HttpException
-import at.bitfire.dav4android.property.*
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.davdroid.model.ServiceDB.*
-import at.bitfire.davdroid.model.ServiceDB.Collections
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import okhttp3.HttpUrl
-import org.apache.commons.collections4.iterators.IteratorChain
-import org.apache.commons.collections4.iterators.SingletonIterator
-import java.io.IOException
-import java.lang.ref.WeakReference
-import java.util.*
-import java.util.logging.Level
-import kotlin.concurrent.thread
-
-class DavService: Service() {
-
-    companion object {
-        @JvmField val ACTION_REFRESH_COLLECTIONS = "refreshCollections"
-        @JvmField val EXTRA_DAV_SERVICE_ID = "davServiceID"
-    }
-
-    private val runningRefresh = HashSet<Long>()
-    private val refreshingStatusListeners = LinkedList<WeakReference<RefreshingStatusListener>>()
-
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        intent?.let {
-            val id = intent.getLongExtra(EXTRA_DAV_SERVICE_ID, -1)
-
-            when (intent.action) {
-                ACTION_REFRESH_COLLECTIONS ->
-                    if (runningRefresh.add(id)) {
-                        thread { refreshCollections(id) }
-                        refreshingStatusListeners.forEach { it.get()?.onDavRefreshStatusChanged(id, true) }
-                    }
-            }
-        }
-
-        return START_NOT_STICKY
-    }
-
-
-    /* BOUND SERVICE PART
-       for communicating with the activities
-    */
-
-    interface RefreshingStatusListener {
-        fun onDavRefreshStatusChanged(id: Long, refreshing: Boolean)
-    }
-
-    private val binder = InfoBinder()
-
-    inner class InfoBinder: Binder() {
-        fun isRefreshing(id: Long) = runningRefresh.contains(id)
-
-        fun addRefreshingStatusListener(listener: RefreshingStatusListener, callImmediate: Boolean) {
-            refreshingStatusListeners += WeakReference<RefreshingStatusListener>(listener)
-            if (callImmediate)
-                runningRefresh.forEach { id -> listener.onDavRefreshStatusChanged(id, true) }
-        }
-
-        fun removeRefreshingStatusListener(listener: RefreshingStatusListener) {
-            val iter = refreshingStatusListeners.iterator()
-            while (iter.hasNext()) {
-                val item = iter.next().get()
-                if (listener == item)
-                    iter.remove()
-            }
-        }
-    }
-
-    override fun onBind(intent: Intent?) = binder
-
-
-
-    /* ACTION RUNNABLES
-       which actually do the work
-     */
-
-    private fun refreshCollections(service: Long) {
-        OpenHelper(this@DavService).use { dbHelper ->
-            val db = dbHelper.writableDatabase
-
-            val serviceType by lazy {
-                db.query(Services._TABLE, arrayOf(Services.SERVICE), "${Services.ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                    if (cursor.moveToNext())
-                        return@lazy cursor.getString(0)
-                } ?: throw IllegalArgumentException("Service not found")
-            }
-
-            val account by lazy {
-                db.query(Services._TABLE, arrayOf(Services.ACCOUNT_NAME), "${Services.ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                    if (cursor.moveToNext())
-                        return@lazy Account(cursor.getString(0), getString(R.string.account_type))
-                }
-                throw IllegalArgumentException("Account not found")
-            }
-
-            val homeSets by lazy {
-                val homeSets = mutableSetOf<HttpUrl>()
-                db.query(HomeSets._TABLE, arrayOf(HomeSets.URL), "${HomeSets.SERVICE_ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                    while (cursor.moveToNext())
-                        HttpUrl.parse(cursor.getString(0))?.let { homeSets += it }
-                }
-                homeSets
-            }
-
-            val collections by lazy {
-                val collections = mutableMapOf<HttpUrl, CollectionInfo>()
-                db.query(Collections._TABLE, null, "${Collections.SERVICE_ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                    while (cursor.moveToNext()) {
-                        val values = ContentValues()
-                        DatabaseUtils.cursorRowToContentValues(cursor, values)
-                        values.getAsString(Collections.URL)?.let { url ->
-                            HttpUrl.parse(url)?.let { collections.put(it, CollectionInfo(values)) }
-                        }
-                    }
-                }
-                collections
-            }
-
-            fun readPrincipal(): HttpUrl? {
-                db.query(Services._TABLE, arrayOf(Services.PRINCIPAL), "${Services.ID}=?", arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                    if (cursor.moveToNext())
-                        cursor.getString(0)?.let { return HttpUrl.parse(it) }
-                }
-                return null
-            }
-
-            /**
-             * Checks if the given URL defines home sets and adds them to the home set list.
-             * @param dav               DavResource to check
-             */
-            @Throws(IOException::class, HttpException::class, DavException::class)
-            fun queryHomeSets(dav: DavResource) {
-                when (serviceType) {
-                    Services.SERVICE_CARDDAV -> {
-                        dav.propfind(0, AddressbookHomeSet.NAME, GroupMembership.NAME)
-                        for ((resource, addressbookHomeSet) in dav.findProperties(AddressbookHomeSet::class.java))
-                            for (href in addressbookHomeSet.hrefs)
-                                resource.location.resolve(href)?.let { homeSets += UrlUtils.withTrailingSlash(it) }
-                    }
-                    Services.SERVICE_CALDAV -> {
-                        dav.propfind(0, CalendarHomeSet.NAME, CalendarProxyReadFor.NAME, CalendarProxyWriteFor.NAME, GroupMembership.NAME)
-                        for ((resource, calendarHomeSet) in dav.findProperties(CalendarHomeSet::class.java))
-                            for (href in calendarHomeSet.hrefs)
-                                resource.location.resolve(href)?.let { homeSets.add(UrlUtils.withTrailingSlash(it)) }
-                    }
-                }
-            }
-
-            fun saveHomeSets() {
-                db.delete(HomeSets._TABLE, "${HomeSets.SERVICE_ID}=?", arrayOf(service.toString()))
-                for (homeSet in homeSets) {
-                    val values = ContentValues(2)
-                    values.put(HomeSets.SERVICE_ID, service)
-                    values.put(HomeSets.URL, homeSet.toString())
-                    db.insertOrThrow(HomeSets._TABLE, null, values)
-                }
-            }
-
-            fun saveCollections() {
-                db.delete(Collections._TABLE, "${HomeSets.SERVICE_ID}=?", arrayOf(service.toString()))
-                for ((_,collection) in collections) {
-                    val values = collection.toDB()
-                    Logger.log.log(Level.FINE, "Saving collection", values)
-                    values.put(Collections.SERVICE_ID, service)
-                    db.insertWithOnConflict(Collections._TABLE, null, values, SQLiteDatabase.CONFLICT_REPLACE)
-                }
-            }
-
-
-            try {
-                Logger.log.info("Refreshing $serviceType collections of service #$service")
-
-                Settings.getInstance(this)?.use { settings ->
-                    // create authenticating OkHttpClient (credentials taken from account settings)
-                    HttpClient.Builder(this, settings, AccountSettings(this, settings, account))
-                            .setForeground(true)
-                            .build().use { client ->
-                        val httpClient = client.okHttpClient
-
-                        // refresh home set list (from principal)
-                        readPrincipal()?.let { principalUrl ->
-                            Logger.log.fine("Querying principal $principalUrl for home sets")
-                            val principal = DavResource(httpClient, principalUrl)
-                            queryHomeSets(principal)
-
-                            // refresh home sets: calendar-proxy-read/write-for
-                            for ((resource, proxyRead) in principal.findProperties(CalendarProxyReadFor::class.java))
-                                for (href in proxyRead.hrefs) {
-                                    Logger.log.fine("Principal is a read-only proxy for $href, checking for home sets")
-                                    resource.location.resolve(href)?.let { queryHomeSets(DavResource(httpClient, it)) }
-                                }
-                            for ((resource, proxyWrite) in principal.findProperties(CalendarProxyWriteFor::class.java))
-                                for (href in proxyWrite.hrefs) {
-                                    Logger.log.fine("Principal is a read/write proxy for $href, checking for home sets")
-                                    resource.location.resolve(href)?.let { queryHomeSets(DavResource(httpClient, it)) }
-                                }
-
-                            // refresh home sets: direct group memberships
-                            principal.properties[GroupMembership::class.java]?.let { groupMembership ->
-                                for (href in groupMembership.hrefs) {
-                                    Logger.log.fine("Principal is member of group $href, checking for home sets")
-                                    principal.location.resolve(href)?.let { url ->
-                                        try {
-                                            queryHomeSets(DavResource(httpClient, url))
-                                        } catch(e: HttpException) {
-                                            Logger.log.log(Level.WARNING, "Couldn't query member group", e)
-                                        } catch(e: DavException) {
-                                            Logger.log.log(Level.WARNING, "Couldn't query member group", e)
-                                        }
-                                    }
-                                }
-                            }
-                        }
-
-                        // remember selected collections
-                        val selectedCollections = HashSet<HttpUrl>()
-                        collections.values
-                                .filter { it.selected }
-                                .forEach { (url,_) -> HttpUrl.parse(url)?.let { selectedCollections.add(it) } }
-
-                        // now refresh collections (taken from home sets)
-                        val itHomeSets = homeSets.iterator()
-                        while (itHomeSets.hasNext()) {
-                            val homeSetUrl = itHomeSets.next()
-                            Logger.log.fine("Listing home set $homeSetUrl")
-
-                            val homeSet = DavResource(httpClient, homeSetUrl)
-                            try {
-                                homeSet.propfind(1, *CollectionInfo.DAV_PROPERTIES)
-                                val itCollections = IteratorChain<DavResource>(homeSet.members.iterator(), homeSet.related.iterator(), SingletonIterator(homeSet))
-                                while (itCollections.hasNext()) {
-                                    val member = itCollections.next()
-                                    val info = CollectionInfo(member)
-                                    info.confirmed = true
-                                    Logger.log.log(Level.FINE, "Found collection", info)
-
-                                    if ((serviceType == Services.SERVICE_CARDDAV && info.type == CollectionInfo.Type.ADDRESS_BOOK) ||
-                                            (serviceType == Services.SERVICE_CALDAV && arrayOf(CollectionInfo.Type.CALENDAR, CollectionInfo.Type.WEBCAL).contains(info.type)))
-                                        collections[member.location] = info
-                                }
-                            } catch(e: HttpException) {
-                                if (e.status 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 {
-                                    val collection = DavResource(httpClient, url)
-                                    collection.propfind(0, *CollectionInfo.DAV_PROPERTIES)
-                                    val info = CollectionInfo(collection)
-                                    info.confirmed = true
-
-                                    // remove unusable collections
-                                    if ((serviceType == Services.SERVICE_CARDDAV && info.type != CollectionInfo.Type.ADDRESS_BOOK) ||
-                                            (serviceType == Services.SERVICE_CALDAV && !arrayOf(CollectionInfo.Type.CALENDAR, CollectionInfo.Type.WEBCAL).contains(info.type)) ||
-                                            (info.type == CollectionInfo.Type.WEBCAL && info.source == null))
-                                        itCollections.remove()
-                                } catch(e: HttpException) {
-                                    if (e.status in arrayOf(403, 404, 410))
-                                    // delete collection only if it was not accessible (40x)
-                                        itCollections.remove()
-                                    else
-                                        throw e
-                                }
-                        }
-
-                        // restore selections
-                        for (url in selectedCollections)
-                            collections[url]?.let { it.selected = true }
-                    }
-
-                }
-
-                db.beginTransactionNonExclusive()
-                try {
-                    saveHomeSets()
-                    saveCollections()
-                    db.setTransactionSuccessful()
-                } finally {
-                    db.endTransaction()
-                }
-
-            } catch(e: InvalidAccountException) {
-                Logger.log.log(Level.SEVERE, "Invalid account", e)
-            } catch(e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't refresh collection list", e)
-
-                val debugIntent = Intent(this@DavService, DebugInfoActivity::class.java)
-                debugIntent.putExtra(DebugInfoActivity.KEY_THROWABLE, e)
-                debugIntent.putExtra(DebugInfoActivity.KEY_ACCOUNT, account)
-
-                val nm = NotificationUtils.createChannels(this)
-                val notify = NotificationCompat.Builder(this, NotificationUtils.CHANNEL_SYNC_PROBLEMS)
-                        .setSmallIcon(R.drawable.ic_sync_error_notification)
-                        .setLargeIcon(App.getLauncherBitmap(this))
-                        .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))
-                        .build()
-                nm.notify(Constants.NOTIFICATION_REFRESH_COLLECTIONS, notify)
-            } finally {
-                runningRefresh.remove(service)
-                refreshingStatusListeners.forEach { it.get()?.onDavRefreshStatusChanged(service, false) }
-            }
-        }
-
-    }
-
-}

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

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

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

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

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

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

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

@@ -1,63 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid
-
-import 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!
-     */
-    val storage = MultiKeyMap.multiKeyMap(HashedMap<MultiKey<out String>, Cookie>())!!
-
-    override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
-        synchronized(storage) {
-            for (cookie in cookies)
-                storage.put(cookie.name(), cookie.domain(), cookie.path(), cookie)
-        }
-    }
-
-    override fun loadForRequest(url: HttpUrl): List<Cookie> {
-        val cookies = LinkedList<Cookie>()
-
-        synchronized(storage) {
-            val iter = storage.mapIterator()
-            while (iter.hasNext()) {
-                iter.next()
-                val cookie = iter.value
-
-                // remove expired cookies
-                if (cookie.expiresAt() <= System.currentTimeMillis()) {
-                    iter.remove()
-                    continue
-                }
-
-                // add applicable cookies
-                if (cookie.matches(url))
-                    cookies += cookie
-            }
-        }
-
-        return cookies
-    }
-
-}

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

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

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

@@ -1,50 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.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 val MAX_LINE_LENGTH = 3000
-
-    init {
-        formatter = PlainTextFormatter.LOGCAT
-        level = Level.ALL
-    }
-
-    override fun publish(r: LogRecord) {
-        val text = formatter.format(r)
-        val level = r.level.intValue()
-
-        val end = text.length
-        var pos = 0
-        while (pos < end) {
-            val line = text.substring(pos, NumberUtils.min(pos + MAX_LINE_LENGTH, end))
-            when {
-                level >= Level.SEVERE.intValue()  -> Log.e(r.loggerName, line)
-                level >= Level.WARNING.intValue() -> Log.w(r.loggerName, line)
-                level >= Level.CONFIG.intValue()  -> Log.i(r.loggerName, line)
-                level >= Level.FINER.intValue()   -> Log.d(r.loggerName, line)
-                else                              -> Log.v(r.loggerName, line)
-            }
-            pos += MAX_LINE_LENGTH
-        }
-    }
-
-    override fun flush() {}
-    override fun close() {}
-
-}

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

@@ -1,109 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.log
-
-import android.app.PendingIntent
-import android.content.Context
-import android.content.Intent
-import android.content.SharedPreferences
-import android.os.Process
-import android.preference.PreferenceManager
-import android.support.v4.app.NotificationCompat
-import android.util.Log
-import at.bitfire.davdroid.App
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.ui.AppSettingsActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import org.apache.commons.lang3.time.DateFormatUtils
-import java.io.File
-import java.io.IOException
-import java.util.logging.FileHandler
-import java.util.logging.Level
-
-object Logger {
-
-    val LOG_TO_EXTERNAL_STORAGE = "log_to_external_storage"
-
-    @JvmField
-    val log = java.util.logging.Logger.getLogger("davdroid")!!
-
-
-    lateinit private var preferences: SharedPreferences
-
-    fun initialize(context: Context) {
-        preferences = PreferenceManager.getDefaultSharedPreferences(context)
-        preferences.registerOnSharedPreferenceChangeListener { _, s ->
-            if (s == LOG_TO_EXTERNAL_STORAGE)
-                reinitialize(context.applicationContext)
-        }
-
-        reinitialize(context.applicationContext)
-    }
-
-    private fun reinitialize(context: Context) {
-        val logToFile = preferences.getBoolean(LOG_TO_EXTERNAL_STORAGE, false)
-        val logVerbose = logToFile || Log.isLoggable(log.name, Log.DEBUG)
-
-        log.info("Verbose logging: $logVerbose; to file: $logToFile")
-
-        // set logging level according to preferences
-        val rootLogger = java.util.logging.Logger.getLogger("")
-        rootLogger.level = if (logVerbose) Level.ALL else Level.INFO
-
-        // remove all handlers and add our own logcat handler
-        rootLogger.useParentHandlers = false
-        rootLogger.handlers.forEach { rootLogger.removeHandler(it) }
-        rootLogger.addHandler(LogcatHandler)
-
-        val nm = NotificationUtils.createChannels(context)
-        // log to external file according to preferences
-        if (logToFile) {
-            val builder = NotificationCompat.Builder(context, NotificationUtils.CHANNEL_DEBUG)
-            builder .setSmallIcon(R.drawable.ic_sd_storage_notification)
-                    .setLargeIcon(App.getLauncherBitmap(context))
-                    .setContentTitle(context.getString(R.string.logging_davdroid_file_logging))
-                    .setLocalOnly(true)
-
-            val dir = context.getExternalFilesDir(null)
-            if (dir != null)
-                try {
-                    val fileName = File(dir, "davdroid-${Process.myPid()}-${DateFormatUtils.format(System.currentTimeMillis(), "yyyyMMdd-HHmmss")}.txt").toString()
-                    log.info("Logging to $fileName")
-
-                    val fileHandler = FileHandler(fileName)
-                    fileHandler.formatter = PlainTextFormatter.DEFAULT
-                    rootLogger.addHandler(fileHandler)
-
-                    val prefIntent = Intent(context, AppSettingsActivity::class.java)
-                    prefIntent.putExtra(AppSettingsActivity.EXTRA_SCROLL_TO, LOG_TO_EXTERNAL_STORAGE)
-
-                    builder .setContentText(dir.path)
-                            .setCategory(NotificationCompat.CATEGORY_STATUS)
-                            .setPriority(NotificationCompat.PRIORITY_HIGH)
-                            .setContentIntent(PendingIntent.getActivity(context, 0, prefIntent, PendingIntent.FLAG_UPDATE_CURRENT))
-                            .setStyle(NotificationCompat.BigTextStyle()
-                                    .bigText(context.getString(R.string.logging_to_external_storage, dir.path)))
-                            .setOngoing(true)
-
-                } catch(e: IOException) {
-                    log.log(Level.SEVERE, "Couldn't create external log file", e)
-
-                    builder .setContentText(context.getString(R.string.logging_couldnt_create_file, e.localizedMessage))
-                            .setCategory(NotificationCompat.CATEGORY_ERROR)
-                }
-            else
-                builder.setContentText(context.getString(R.string.logging_no_external_storage))
-
-            nm.notify(Constants.NOTIFICATION_EXTERNAL_FILE_LOGGING, builder.build())
-        } else
-            nm.cancel(Constants.NOTIFICATION_EXTERNAL_FILE_LOGGING)
-    }
-
-}

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

@@ -1,61 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.log
-
-import org.apache.commons.lang3.StringUtils
-import org.apache.commons.lang3.exception.ExceptionUtils
-import org.apache.commons.lang3.time.DateFormatUtils
-import java.util.logging.Formatter
-import java.util.logging.LogRecord
-
-class PlainTextFormatter private constructor(
-        private val logcat: Boolean
-): Formatter() {
-
-    companion object {
-        @JvmField val LOGCAT = PlainTextFormatter(true)
-        @JvmField val DEFAULT = PlainTextFormatter(false)
-
-        val MAX_MESSAGE_LENGTH = 20000
-    }
-
-    override fun format(r: LogRecord): String {
-        val builder = StringBuilder()
-
-        if (!logcat)
-            builder .append(DateFormatUtils.format(r.millis, "yyyy-MM-dd HH:mm:ss"))
-                    .append(" ").append(r.threadID).append(" ")
-
-        val className = shortClassName(r.sourceClassName)
-        if (className != r.loggerName)
-            builder.append("[").append(className).append("] ")
-
-        builder.append(StringUtils.abbreviate(r.message, MAX_MESSAGE_LENGTH))
-
-        r.thrown?.let {
-            builder .append("\nEXCEPTION ")
-                    .append(ExceptionUtils.getStackTrace(it))
-        }
-
-        r.parameters?.let {
-            for ((idx, param) in it.withIndex())
-                builder.append("\n\tPARAMETER #").append(idx).append(" = ").append(param)
-        }
-
-        if (!logcat)
-            builder.append("\n")
-
-        return builder.toString()
-    }
-
-    private fun shortClassName(className: String) = className
-            .replace(Regex("^at\\.bitfire\\.(dav|cert4an|dav4an|ical4an|vcard4an)droid\\."), "")
-            .replace(Regex("\\$.*$"), "")
-
-}

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

@@ -1,31 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.log
-
-import java.util.logging.Handler
-import java.util.logging.LogRecord
-
-class StringHandler: Handler() {
-
-    val builder = StringBuilder()
-
-    init {
-        formatter = PlainTextFormatter.DEFAULT
-    }
-
-    override fun publish(record: LogRecord) {
-        builder.append(formatter.format(record))
-    }
-
-    override fun flush() {}
-    override fun close() {}
-
-    override fun toString() = builder.toString()
-
-}

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

@@ -1,163 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.model
-
-import android.content.ContentValues
-import at.bitfire.dav4android.DavResource
-import at.bitfire.dav4android.property.*
-import at.bitfire.davdroid.model.ServiceDB.Collections
-import java.io.Serializable
-
-data class CollectionInfo @JvmOverloads constructor(
-        val url: String,
-
-        var id: Long? = null,
-        var serviceID: Long? = null,
-
-        var type: Type? = null,
-
-        var readOnly: Boolean = false,
-        var forceReadOnly: Boolean = false,
-        var displayName: String? = null,
-        var description: String? = null,
-        var color: Int? = null,
-
-        var timeZone: String? = null,
-        var supportsVEVENT: Boolean = false,
-        var supportsVTODO: Boolean = false,
-        var selected: Boolean = false,
-
-        // subscriptions
-        var source: String? = null,
-
-        // non-persistent properties
-        var confirmed: Boolean = false
-): Serializable {
-
-    enum class Type {
-        ADDRESS_BOOK,
-        CALENDAR,
-        WEBCAL          // iCalendar subscription
-    }
-
-    companion object {
-
-        @JvmField
-        val DAV_PROPERTIES = arrayOf(
-            ResourceType.NAME,
-            CurrentUserPrivilegeSet.NAME,
-            DisplayName.NAME,
-            AddressbookDescription.NAME, SupportedAddressData.NAME,
-            CalendarDescription.NAME, CalendarColor.NAME, SupportedCalendarComponentSet.NAME,
-            Source.NAME
-        )
-
-    }
-
-
-    constructor(dav: DavResource): this(dav.location.toString()) {
-        dav.properties[ResourceType::class.java]?.let { type ->
-            when {
-                type.types.contains(ResourceType.ADDRESSBOOK) -> this.type = Type.ADDRESS_BOOK
-                type.types.contains(ResourceType.CALENDAR)    -> this.type = Type.CALENDAR
-                type.types.contains(ResourceType.SUBSCRIBED)  -> this.type = Type.WEBCAL
-            }
-        }
-
-        dav.properties[CurrentUserPrivilegeSet::class.java]?.let { privilegeSet ->
-            readOnly = !privilegeSet.mayWriteContent
-        }
-
-        dav.properties[DisplayName::class.java]?.let {
-            if (!it.displayName.isNullOrEmpty())
-                displayName = it.displayName
-        }
-
-        when (type) {
-            Type.ADDRESS_BOOK -> {
-                dav.properties[AddressbookDescription::class.java]?.let { description = it.description }
-            }
-            Type.CALENDAR, Type.WEBCAL -> {
-                dav.properties[CalendarDescription::class.java]?.let { description = it.description }
-                dav.properties[CalendarColor::class.java]?.let { color = it.color }
-                dav.properties[CalendarTimezone::class.java]?.let { timeZone = it.vTimeZone }
-
-                if (type == Type.CALENDAR) {
-                    supportsVEVENT = true
-                    supportsVTODO = true
-                    dav.properties[SupportedCalendarComponentSet::class.java]?.let {
-                        supportsVEVENT = it.supportsEvents
-                        supportsVTODO = it.supportsTasks
-                    }
-                } else { // Type.WEBCAL
-                    dav.properties[Source::class.java]?.let { source = it.hrefs.firstOrNull() }
-                    supportsVEVENT = true
-                }
-            }
-        }
-    }
-
-
-    constructor(values: ContentValues): this(values.getAsString(Collections.URL)) {
-        id = values.getAsLong(Collections.ID)
-        serviceID = values.getAsLong(Collections.SERVICE_ID)
-        type = try {
-            Type.valueOf(values.getAsString(Collections.TYPE))
-        } catch (e: Exception) {
-            null
-        }
-
-        readOnly = values.getAsInteger(Collections.READ_ONLY) != 0
-        forceReadOnly = values.getAsInteger(Collections.FORCE_READ_ONLY) != 0
-        displayName = values.getAsString(Collections.DISPLAY_NAME)
-        description = values.getAsString(Collections.DESCRIPTION)
-
-        color = values.getAsInteger(Collections.COLOR)
-
-        timeZone = values.getAsString(Collections.TIME_ZONE)
-        supportsVEVENT = getAsBooleanOrNull(values, Collections.SUPPORTS_VEVENT) ?: false
-        supportsVTODO = getAsBooleanOrNull(values, Collections.SUPPORTS_VTODO) ?: false
-
-        source = values.getAsString(Collections.SOURCE)
-
-        selected = values.getAsInteger(Collections.SYNC) != 0
-    }
-
-    fun toDB(): ContentValues {
-        val values = ContentValues()
-        // Collections.SERVICE_ID is never changed
-        type?.let { values.put(Collections.TYPE, it.name) }
-
-        values.put(Collections.URL, url)
-        values.put(Collections.READ_ONLY, if (readOnly) 1 else 0)
-        values.put(Collections.FORCE_READ_ONLY, if (forceReadOnly) 1 else 0)
-        values.put(Collections.DISPLAY_NAME, displayName)
-        values.put(Collections.DESCRIPTION, description)
-        values.put(Collections.COLOR, color)
-
-        values.put(Collections.TIME_ZONE, timeZone)
-        values.put(Collections.SUPPORTS_VEVENT, if (supportsVEVENT) 1 else 0)
-        values.put(Collections.SUPPORTS_VTODO, if (supportsVTODO) 1 else 0)
-
-        values.put(Collections.SOURCE, source)
-
-        values.put(Collections.SYNC, if (selected) 1 else 0)
-        return values
-    }
-
-
-    private fun getAsBooleanOrNull(values: ContentValues, field: String): Boolean? {
-        val i = values.getAsInteger(field)
-        return if (i == null)
-            null
-        else
-            (i != 0)
-    }
-
-}

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

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

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

@@ -1,231 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.model
-
-import android.content.ContentValues
-import android.content.Context
-import android.database.sqlite.SQLiteDatabase
-import android.database.sqlite.SQLiteException
-import android.database.sqlite.SQLiteOpenHelper
-import android.preference.PreferenceManager
-import at.bitfire.davdroid.App
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.ui.StartupDialogFragment
-import java.io.Closeable
-import java.util.logging.Level
-
-class ServiceDB {
-
-    /*object Settings {
-        @JvmField val _TABLE = "settings"
-        @JvmField val NAME = "setting"
-        @JvmField val VALUE = "value"
-    }*/
-
-    object Services {
-        @JvmField val _TABLE = "services"
-        @JvmField val ID = "_id"
-        @JvmField val ACCOUNT_NAME = "accountName"
-        @JvmField val SERVICE = "service"
-        @JvmField val PRINCIPAL = "principal"
-
-        // allowed values for SERVICE column
-        @JvmField val SERVICE_CALDAV = "caldav"
-        @JvmField val SERVICE_CARDDAV = "carddav"
-    }
-
-    object HomeSets {
-        @JvmField val _TABLE = "homesets"
-        @JvmField val ID = "_id"
-        @JvmField val SERVICE_ID = "serviceID"
-        @JvmField val URL = "url"
-    }
-
-    object Collections {
-        @JvmField val _TABLE = "collections"
-        @JvmField val ID = "_id"
-        @JvmField val TYPE = "type"
-        @JvmField val SERVICE_ID = "serviceID"
-        @JvmField val URL = "url"
-        @JvmField val READ_ONLY = "readOnly"
-        @JvmField val FORCE_READ_ONLY = "forceReadOnly"
-        @JvmField val DISPLAY_NAME = "displayName"
-        @JvmField val DESCRIPTION = "description"
-        @JvmField val COLOR = "color"
-        @JvmField val TIME_ZONE = "timezone"
-        @JvmField val SUPPORTS_VEVENT = "supportsVEVENT"
-        @JvmField val SUPPORTS_VTODO = "supportsVTODO"
-        @JvmField val SOURCE = "source"
-        @JvmField val SYNC = "sync"
-    }
-
-    companion object {
-
-        @JvmStatic
-        fun onRenameAccount(db: SQLiteDatabase, oldName: String, newName: String) {
-            val values = ContentValues(1)
-            values.put(Services.ACCOUNT_NAME, newName)
-            db.updateWithOnConflict(Services._TABLE, values, Services.ACCOUNT_NAME + "=?", arrayOf(oldName), SQLiteDatabase.CONFLICT_REPLACE)
-        }
-
-    }
-
-
-    class OpenHelper(
-            val context: Context
-    ): SQLiteOpenHelper(context, DATABASE_NAME, null, DATABASE_VERSION), Closeable {
-
-        companion object {
-            val DATABASE_NAME = "services.db"
-            val DATABASE_VERSION = 4
-        }
-
-        override fun onConfigure(db: SQLiteDatabase) {
-            setWriteAheadLoggingEnabled(true)
-            db.setForeignKeyConstraintsEnabled(true)
-        }
-
-        override fun onCreate(db: SQLiteDatabase) {
-            Logger.log.info("Creating database " + db.path)
-
-            db.execSQL("CREATE TABLE ${Services._TABLE}(" +
-                    "${Services.ID} INTEGER PRIMARY KEY AUTOINCREMENT," +
-                    "${Services.ACCOUNT_NAME} TEXT NOT NULL," +
-                    "${Services.SERVICE} TEXT NOT NULL," +
-                    "${Services.PRINCIPAL} TEXT NULL)")
-            db.execSQL("CREATE UNIQUE INDEX services_account ON ${Services._TABLE} (${Services.ACCOUNT_NAME},${Services.SERVICE})")
-
-            db.execSQL("CREATE TABLE ${HomeSets._TABLE}(" +
-                    "${HomeSets.ID} INTEGER PRIMARY KEY AUTOINCREMENT," +
-                    "${HomeSets.SERVICE_ID} INTEGER NOT NULL REFERENCES ${Services._TABLE} ON DELETE CASCADE," +
-                    "${HomeSets.URL} TEXT NOT NULL)")
-            db.execSQL("CREATE UNIQUE INDEX homesets_service_url ON ${HomeSets._TABLE}(${HomeSets.SERVICE_ID},${HomeSets.URL})")
-
-            db.execSQL("CREATE TABLE ${Collections._TABLE}(" +
-                    "${Collections.ID} INTEGER PRIMARY KEY AUTOINCREMENT," +
-                    "${Collections.SERVICE_ID} INTEGER NOT NULL REFERENCES ${Services._TABLE} ON DELETE CASCADE," +
-                    "${Collections.TYPE} TEXT NOT NULL," +
-                    "${Collections.URL} TEXT NOT NULL," +
-                    "${Collections.READ_ONLY} INTEGER DEFAULT 0 NOT NULL," +
-                    "${Collections.FORCE_READ_ONLY} INTEGER DEFAULT 0 NOT NULL," +
-                    "${Collections.DISPLAY_NAME} TEXT NULL," +
-                    "${Collections.DESCRIPTION} TEXT NULL," +
-                    "${Collections.COLOR} INTEGER NULL," +
-                    "${Collections.TIME_ZONE} TEXT NULL," +
-                    "${Collections.SUPPORTS_VEVENT} INTEGER NULL," +
-                    "${Collections.SUPPORTS_VTODO} INTEGER NULL," +
-                    "${Collections.SOURCE} TEXT NULL," +
-                    "${Collections.SYNC} INTEGER DEFAULT 0 NOT NULL)")
-            db.execSQL("CREATE UNIQUE INDEX collections_service_url ON ${Collections._TABLE}(${Collections.SERVICE_ID},${Collections.URL})")
-        }
-
-        override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
-            for (upgradeFrom in oldVersion until newVersion) {
-                val upgradeTo = upgradeFrom + 1
-                Logger.log.info("Upgrading database from version $upgradeFrom to $upgradeTo")
-                try {
-                    val upgradeProc = this::class.java.getDeclaredMethod("upgrade_${upgradeFrom}_$upgradeTo", SQLiteDatabase::class.java)
-                    upgradeProc.invoke(this, db)
-                } catch(e: Exception) {
-                    Logger.log.log(Level.SEVERE, "Couldn't upgrade database", e)
-                }
-            }
-        }
-
-        @Suppress("unused")
-        private fun upgrade_3_4(db: SQLiteDatabase) {
-            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.FORCE_READ_ONLY} INTEGER DEFAULT 0 NOT NULL")
-        }
-
-        @Suppress("unused")
-        private fun upgrade_2_3(db: SQLiteDatabase) {
-            val edit = PreferenceManager.getDefaultSharedPreferences(context).edit()
-            try {
-                db.query("settings", arrayOf("setting", "value"), null, null, null, null, null).use { cursor ->
-                    while (cursor.moveToNext()) {
-                        when (cursor.getString(0)) {
-                            "distrustSystemCerts" -> edit.putBoolean(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()
-            }
-        }
-
-        @Suppress("unused")
-        private fun upgrade_1_2(db: SQLiteDatabase) {
-            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.TYPE} TEXT NOT NULL DEFAULT ''")
-            db.execSQL("ALTER TABLE ${Collections._TABLE} ADD COLUMN ${Collections.SOURCE} TEXT NULL")
-            db.execSQL("UPDATE ${Collections._TABLE} SET ${Collections.TYPE}=(" +
-                    "SELECT CASE ${Services.SERVICE} WHEN ? THEN ? ELSE ? END " +
-                    "FROM ${Services._TABLE} WHERE ${Services.ID}=${Collections._TABLE}.${Collections.SERVICE_ID}" +
-                    ")",
-                    arrayOf(Services.SERVICE_CALDAV, CollectionInfo.Type.CALENDAR, CollectionInfo.Type.ADDRESS_BOOK))
-        }
-
-
-        fun dump(sb: StringBuilder) {
-            val db = readableDatabase
-            db.beginTransactionNonExclusive()
-
-            // iterate through all tables
-            db.query("sqlite_master", arrayOf("name"), "type='table'", null, null, null, null).use { cursorTables ->
-                while (cursorTables.moveToNext()) {
-                    val table = cursorTables.getString(0)
-                    sb.append(table).append("\n")
-                    db.query(table, null, null, null, null, null, null).use { cursor ->
-                        // print columns
-                        val cols = cursor.columnCount
-                        sb.append("\t| ")
-                        for (i in 0 until cols)
-                            sb  .append(" ")
-                                .append(cursor.getColumnName(i))
-                                .append(" |")
-                        sb.append("\n")
-
-                        // print rows
-                        while (cursor.moveToNext()) {
-                            sb.append("\t| ")
-                            for (i in 0 until cols) {
-                                sb.append(" ")
-                                try {
-                                    val value = cursor.getString(i)
-                                    if (value != null)
-                                        sb.append(value
-                                                .replace("\r", "<CR>")
-                                                .replace("\n", "<LF>"))
-                                    else
-                                        sb.append("<null>")
-
-                                } catch (e: SQLiteException) {
-                                    sb.append("<unprintable>")
-                                }
-                                sb.append(" |")
-                            }
-                            sb.append("\n")
-                        }
-                        sb.append("----------\n")
-                    }
-                }
-                db.endTransaction()
-            }
-        }
-    }
-
-}

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

@@ -1,28 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.model
-
-import android.provider.ContactsContract.RawContacts
-
-object UnknownProperties {
-
-    @JvmField
-    val CONTENT_ITEM_TYPE = "x.davdroid/unknown-properties"
-
-
-    @JvmField
-    val MIMETYPE = RawContacts.Data.MIMETYPE
-
-    @JvmField
-    val RAW_CONTACT_ID = RawContacts.Data.RAW_CONTACT_ID
-
-    @JvmField
-    val UNKNOWN_PROPERTIES = RawContacts.Data.DATA1
-
-}

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

@@ -1,366 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.annotation.TargetApi
-import android.content.*
-import android.os.Build
-import android.os.Bundle
-import android.os.RemoteException
-import android.provider.ContactsContract
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
-import android.provider.ContactsContract.Groups
-import android.provider.ContactsContract.RawContacts
-import android.util.Base64
-import at.bitfire.davdroid.DavUtils
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.vcard4android.*
-import java.io.ByteArrayOutputStream
-import java.io.FileNotFoundException
-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, DAVdroid creates a "DAVdroid
- * address book" account for every CardDAV address book. These accounts are bound to a
- * DAVdroid main account.
- */
-class LocalAddressBook(
-        private val context: Context,
-        account: Account,
-        provider: ContentProviderClient?
-): AndroidAddressBook<LocalContact, LocalGroup>(account, provider, LocalContact.Factory, LocalGroup.Factory), LocalCollection<LocalResource> {
-
-    companion object {
-
-        val USER_DATA_MAIN_ACCOUNT_TYPE = "real_account_type"
-        val USER_DATA_MAIN_ACCOUNT_NAME = "real_account_name"
-        val USER_DATA_URL = "url"
-        val USER_DATA_READ_ONLY = "read_only"
-        val USER_DATA_CTAG = "ctag"
-
-        @JvmStatic
-        @Throws(ContactsStorageException::class)
-        fun create(context: Context, provider: ContentProviderClient, mainAccount: Account, info: CollectionInfo): LocalAddressBook {
-            val accountManager = AccountManager.get(context)
-
-            val account = Account(accountName(mainAccount, info), context.getString(R.string.account_type_address_book))
-            if (!accountManager.addAccountExplicitly(account, null, initialUserData(mainAccount, info.url)))
-                throw ContactsStorageException("Couldn't create address book account")
-
-            val addressBook = LocalAddressBook(context, account, provider)
-            ContentResolver.setSyncAutomatically(account, ContactsContract.AUTHORITY, true)
-
-            // set up Contacts Provider Settings
-            val values = ContentValues(2)
-            values.put(ContactsContract.Settings.SHOULD_SYNC, 1)
-            values.put(ContactsContract.Settings.UNGROUPED_VISIBLE, 1)
-            addressBook.updateSettings(values)
-
-            return addressBook
-        }
-
-        @JvmStatic
-        @Throws(ContactsStorageException::class)
-        fun find(context: Context, provider: ContentProviderClient, mainAccount: Account?): List<LocalAddressBook> {
-            val accountManager = AccountManager.get(context)
-
-            val result = LinkedList<LocalAddressBook>()
-            accountManager.getAccountsByType(context.getString(R.string.account_type_address_book))
-                    .map { LocalAddressBook(context, it, provider) }
-                    .filter { mainAccount == null || it.getMainAccount() == mainAccount }
-                    .forEach { result += it }
-
-            return result
-        }
-
-        @JvmStatic
-        fun accountName(mainAccount: Account, info: CollectionInfo): String {
-            val baos = ByteArrayOutputStream()
-            baos.write(info.url.hashCode())
-            val hash = Base64.encodeToString(baos.toByteArray(), Base64.NO_WRAP or Base64.NO_PADDING)
-
-            val sb = StringBuilder(if (info.displayName.isNullOrEmpty()) DavUtils.lastSegmentOfUrl(info.url) else info.displayName)
-            sb      .append(" (")
-                    .append(mainAccount.name)
-                    .append(" ")
-                    .append(hash)
-                    .append(")")
-            return sb.toString()
-        }
-
-        @JvmStatic
-        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
-        }
-
-    }
-
-    /**
-     * Whether contact groups (LocalGroup resources) are included in query results for
-     * {@link #getAll()}, {@link #getDeleted()}, {@link #getDirty()} and
-     * {@link #getWithoutFileName()}.
-     */
-    var includeGroups = true
-
-
-    /* operations on the collection (address book) itself */
-
-    @Throws(ContactsStorageException::class)
-    fun update(info: CollectionInfo) {
-        val newAccountName = accountName(getMainAccount(), info)
-
-        @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-        if (account.name != newAccountName && Build.VERSION.SDK_INT >= 21) {
-            val accountManager = AccountManager.get(context)
-            val future = accountManager.renameAccount(account, newAccountName, {
-                try {
-                    // update raw contacts to new account name
-                    provider?.let { provider ->
-                        val values = ContentValues(1)
-                        values.put(RawContacts.ACCOUNT_NAME, newAccountName)
-                        provider.update(syncAdapterURI(RawContacts.CONTENT_URI), values, "${RawContacts.ACCOUNT_NAME}=?", arrayOf(account.name))
-                    }
-                } catch(e: RemoteException) {
-                    Logger.log.log(Level.WARNING, "Couldn't re-assign contacts to new account name", e)
-                }
-            }, null)
-            account = future.result
-        }
-
-        Constants.log.info("Address book read-only? = ${info.readOnly}")
-        setReadOnly(info.readOnly || info.forceReadOnly)
-
-        // make sure it will still be synchronized when contacts are updated
-        ContentResolver.setSyncAutomatically(account, ContactsContract.AUTHORITY, true)
-    }
-
-    @Throws(ContactsStorageException::class)
-    fun delete() {
-        val accountManager = AccountManager.get(context)
-        try {
-            if (Build.VERSION.SDK_INT >= 22)
-                accountManager.removeAccount(account, null, null, null)
-            else
-                @Suppress("deprecation")
-                accountManager.removeAccount(account, null, null)
-        } catch(e: Exception) {
-            throw ContactsStorageException("Couldn't remove address book", e)
-        }
-    }
-
-
-    /* operations on members (contacts/groups) */
-
-    @Throws(ContactsStorageException::class, FileNotFoundException::class)
-    fun findContactByUID(uid: String): LocalContact {
-        val contacts = queryContacts("${AndroidContact.COLUMN_UID}=?", arrayOf(uid))
-        if (contacts.isEmpty())
-            throw FileNotFoundException()
-        return contacts.first()
-    }
-
-    @Throws(ContactsStorageException::class)
-    override fun getAll(): List<LocalResource> {
-        val all = LinkedList<LocalResource>()
-        all.addAll(queryContacts(null, null))
-        if (includeGroups)
-            all.addAll(queryGroups(null, null))
-        return all
-    }
-
-    /**
-     * Returns an array of local contacts/groups which have been deleted locally. (DELETED != 0).
-     */
-    @Throws(ContactsStorageException::class)
-    override fun getDeleted(): List<LocalResource> {
-        val deleted = LinkedList<LocalResource>()
-        deleted.addAll(getDeletedContacts())
-        if (includeGroups)
-            deleted.addAll(getDeletedGroups())
-        return deleted
-    }
-
-    /**
-     * 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(ContactsStorageException::class)
-    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 getDirtyContacts())
-            try {
-                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++
-                }
-            } catch(e: FileNotFoundException) {
-                throw ContactsStorageException("Couldn't calculate hash code", e)
-            }
-
-        if (includeGroups)
-            reallyDirty += getDirtyGroups().size
-
-        return reallyDirty
-    }
-
-    /**
-     * Returns an array of local contacts/groups which have been changed locally (DIRTY != 0).
-     */
-    @Throws(ContactsStorageException::class)
-    override fun getDirty(): List<LocalResource> {
-        val dirty = LinkedList<LocalResource>()
-        dirty.addAll(getDirtyContacts())
-        if (includeGroups)
-            dirty.addAll(getDirtyGroups())
-        return dirty
-    }
-
-    /**
-     * Returns an array of local contacts which don't have a file name yet.
-     */
-    @Throws(ContactsStorageException::class)
-    override fun getWithoutFileName(): List<LocalResource> {
-        val nameless = LinkedList<LocalResource>()
-        nameless.addAll(queryContacts("${AndroidContact.COLUMN_FILENAME} IS NULL", null))
-        if (includeGroups)
-            nameless.addAll(queryGroups("${AndroidGroup.COLUMN_FILENAME} IS NULL", null))
-        return nameless
-    }
-
-    @Throws(ContactsStorageException::class)
-    fun getDeletedContacts() = queryContacts("${RawContacts.DELETED} != 0", null)
-
-    @Throws(ContactsStorageException::class)
-    fun getDirtyContacts() = queryContacts("${RawContacts.DIRTY} != 0", null)
-
-    @Throws(ContactsStorageException::class)
-    fun getDeletedGroups() = queryGroups("${Groups.DELETED} != 0", null)
-
-    @Throws(ContactsStorageException::class)
-    fun getDirtyGroups() = queryGroups("${Groups.DIRTY} != 0", null)
-
-    @Throws(ContactsStorageException::class)
-    fun getByGroupMembership(groupID: Long): List<LocalContact> {
-        try {
-            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 { id -> LocalContact(this, id, null, null) }
-        } catch (e: RemoteException) {
-            throw ContactsStorageException("Couldn't query contacts", e)
-        }
-    }
-
-
-    /* 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 ContactsStorageException on contact provider errors
-     */
-    @Throws(ContactsStorageException::class)
-    fun findOrCreateGroup(title: String): Long {
-        try {
-            provider!!.query(syncAdapterURI(Groups.CONTENT_URI), arrayOf(Groups._ID),
-                    "${Groups.TITLE}=?", arrayOf(title), null)?.use { cursor ->
-                if (cursor.moveToNext())
-                    return cursor.getLong(0)
-            }
-
-            val values = ContentValues(1)
-            values.put(Groups.TITLE, title)
-            val uri = provider.insert(syncAdapterURI(Groups.CONTENT_URI), values)
-            return ContentUris.parseId(uri)
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Couldn't find local contact group", e)
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    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()
-        }
-    }
-
-
-    // SETTINGS
-
-    @Throws(ContactsStorageException::class)
-    fun getMainAccount(): Account {
-        val accountManager = AccountManager.get(context)
-        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 ContactsStorageException("Address book doesn't exist anymore")
-    }
-
-    fun setMainAccount(mainAccount: Account) {
-        val accountManager = AccountManager.get(context)
-        accountManager.setUserData(account, USER_DATA_MAIN_ACCOUNT_NAME, mainAccount.name)
-        accountManager.setUserData(account, USER_DATA_MAIN_ACCOUNT_TYPE, mainAccount.type)
-    }
-
-    @Throws(ContactsStorageException::class)
-    fun getURL() =
-            AccountManager.get(context).getUserData(account, USER_DATA_URL) ?: throw ContactsStorageException("Address book has no URL")
-
-    fun setURL(url: String) =
-            AccountManager.get(context).setUserData(account, USER_DATA_URL, url)
-
-    fun getReadOnly() =
-            AccountManager.get(context).getUserData(account, USER_DATA_READ_ONLY) != null
-
-    fun setReadOnly(readOnly: Boolean) =
-            AccountManager.get(context).setUserData(account, USER_DATA_READ_ONLY, if (readOnly) "1" else null)
-
-    override fun getCTag(): String? =
-            AccountManager.get(context).getUserData(account, USER_DATA_CTAG)
-
-    override fun setCTag(cTag: String?) =
-            AccountManager.get(context).setUserData(account, USER_DATA_CTAG, cTag)
-
-}

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

@@ -1,236 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentProviderOperation
-import android.content.ContentUris
-import android.content.ContentValues
-import android.net.Uri
-import android.os.RemoteException
-import android.provider.CalendarContract
-import android.provider.CalendarContract.*
-import at.bitfire.davdroid.DavUtils
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.ical4android.*
-import java.io.FileNotFoundException
-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 {
-
-        val defaultColor = 0xFF8bc34a.toInt()     // light green 500
-
-        val COLUMN_CTAG = Calendars.CAL_SYNC1
-
-        val BASE_INFO_COLUMNS = arrayOf(
-            Events._ID,
-            Events._SYNC_ID,
-            LocalEvent.COLUMN_ETAG
-        )
-
-
-        @Throws(CalendarStorageException::class)
-        fun create(account: Account, provider: ContentProviderClient, info: CollectionInfo): Uri {
-            val values = valuesFromCollectionInfo(info, true)
-
-            // ACCOUNT_NAME and ACCOUNT_TYPE are required (see docs)! If it's missing, other apps will crash.
-            values.put(Calendars.ACCOUNT_NAME, account.name)
-            values.put(Calendars.ACCOUNT_TYPE, account.type)
-            values.put(Calendars.OWNER_ACCOUNT, account.name)
-
-            // flag as visible & synchronizable at creation, might be changed by user at any time
-            values.put(Calendars.VISIBLE, 1)
-            values.put(Calendars.SYNC_EVENTS, 1)
-            return create(account, provider, values)
-        }
-
-        private fun valuesFromCollectionInfo(info: CollectionInfo, withColor: Boolean): ContentValues {
-            val values = ContentValues()
-            values.put(Calendars.NAME, info.url)
-            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 ?: defaultColor)
-
-            if (info.readOnly || info.forceReadOnly)
-                values.put(Calendars.CALENDAR_ACCESS_LEVEL, Calendars.CAL_ACCESS_READ)
-            else {
-                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)
-            }
-
-            info.timeZone?.let { tzData ->
-                try {
-                    val timeZone = DateUtils.parseVTimeZone(tzData)
-                    timeZone.timeZoneId?.let { tzId ->
-                        values.put(Calendars.CALENDAR_TIME_ZONE, DateUtils.findAndroidTimezoneID(tzId.value))
-                    }
-                } catch(e: IllegalArgumentException) {
-                    Logger.log.log(Level.WARNING, "Couldn't parse calendar default time zone", e)
-                }
-            }
-            values.put(Calendars.ALLOWED_REMINDERS, "${Reminders.METHOD_ALERT},${Reminders.METHOD_EMAIL}")
-            values.put(Calendars.ALLOWED_AVAILABILITY, "${Reminders.AVAILABILITY_TENTATIVE},${Reminders.AVAILABILITY_FREE},${Reminders.AVAILABILITY_BUSY}")
-            values.put(Calendars.ALLOWED_ATTENDEE_TYPES, "${CalendarContract.Attendees.TYPE_OPTIONAL},${CalendarContract.Attendees.TYPE_REQUIRED},${CalendarContract.Attendees.TYPE_RESOURCE}")
-            return values
-        }
-
-    }
-
-
-    override fun eventBaseInfoColumns() = BASE_INFO_COLUMNS
-
-
-    @Throws(CalendarStorageException::class)
-    fun update(info: CollectionInfo, updateColor: Boolean) =
-            update(valuesFromCollectionInfo(info, updateColor))
-
-    @Throws(CalendarStorageException::class)
-    override fun getAll(): List<LocalEvent> =
-            queryEvents("${Events.ORIGINAL_ID} IS NULL", null)
-
-    @Throws(CalendarStorageException::class)
-    override fun getDeleted() =
-            queryEvents("${Events.DELETED}!=0 AND ${Events.ORIGINAL_ID} IS NULL", null)
-
-    @Throws(CalendarStorageException::class)
-    override fun getWithoutFileName() =
-            queryEvents("${Events._SYNC_ID} IS NULL AND ${Events.ORIGINAL_ID} IS NULL", null)
-
-    @Throws(FileNotFoundException::class, CalendarStorageException::class)
-    override fun getDirty(): List<LocalEvent> {
-        val dirty = LinkedList<LocalEvent>()
-
-        // get dirty events which are required to have an increased SEQUENCE value
-        for (localEvent in queryEvents("${Events.DIRTY}!=0 AND ${Events.ORIGINAL_ID} IS NULL", null)) {
-            val event = localEvent.event!!
-            val sequence = event.sequence
-            if (event.sequence == null)      // sequence has not been assigned yet (i.e. this event was just locally created)
-                event.sequence = 0
-            else if (localEvent.weAreOrganizer)
-                event.sequence = sequence!! + 1
-            dirty += localEvent
-        }
-
-        return dirty
-    }
-
-    @Throws(CalendarStorageException::class)
-    override fun getCTag(): String? =
-        try {
-            provider.query(calendarSyncURI(), arrayOf(COLUMN_CTAG), null, null, null)?.use { cursor ->
-                if (cursor.moveToNext())
-                    return cursor.getString(0)
-            }
-            null
-        } catch (e: RemoteException) {
-            throw CalendarStorageException("Couldn't read local (last known) CTag", e)
-        }
-
-    @Throws(CalendarStorageException::class)
-    override fun setCTag(cTag: String?) {
-        try {
-            val values = ContentValues(1)
-            values.put(COLUMN_CTAG, cTag)
-            provider.update(calendarSyncURI(), values, null, null)
-        } catch (e: RemoteException) {
-            throw CalendarStorageException("Couldn't write local (last known) CTag", e)
-        }
-    }
-
-    @Throws(CalendarStorageException::class)
-    fun processDirtyExceptions() {
-        try {
-            // 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.DELETED}!=0 AND ${Events.ORIGINAL_ID} IS NOT NULL", null, null)?.use { cursor ->
-                while (cursor.moveToNext()) {
-                    Logger.log.fine("Found deleted exception, removing; then re-scheduling original event")
-                    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 ->
-                        val originalSequence = if (cursor2.isNull(0)) 0 else cursor2.getInt(0)
-
-                        // re-schedule original event and set it to DIRTY
-                        batch.enqueue(BatchOperation.Operation(
-                                ContentProviderOperation.newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, originalID)))
-                                        .withValue(LocalEvent.COLUMN_SEQUENCE, originalSequence + 1)
-                                        .withValue(Events.DIRTY, 1)
-                        ))
-                    }
-
-                    // remove exception
-                    batch.enqueue(BatchOperation.Operation(
-                            ContentProviderOperation.newDelete(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, id)))
-                    ))
-                    batch.commit()
-                }
-            }
-
-            // process dirty exceptions
-            Logger.log.info("Processing dirty exceptions")
-            provider.query(
-                    syncAdapterURI(Events.CONTENT_URI),
-                    arrayOf(Events._ID, Events.ORIGINAL_ID, LocalEvent.COLUMN_SEQUENCE),
-                    "${Events.DIRTY}!=0 AND ${Events.ORIGINAL_ID} IS NOT NULL", null, null)?.use { cursor ->
-                while (cursor.moveToNext()) {
-                    Logger.log.fine("Found dirty exception, increasing SEQUENCE to re-schedule")
-                    val id = cursor.getLong(0)             // can't be null (by definition)
-                    val originalID = cursor.getLong(1)     // can't be null (by query)
-                    val sequence = if (cursor.isNull(2)) 0 else cursor.getInt(2)
-
-                    val batch = BatchOperation(provider)
-                    // original event to DIRTY
-                    batch.enqueue(BatchOperation.Operation (
-                            ContentProviderOperation.newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, originalID)))
-                                    .withValue(Events.DIRTY, 1)
-                    ))
-                    // increase SEQUENCE and set DIRTY to 0
-                    batch.enqueue(BatchOperation.Operation (
-                            ContentProviderOperation.newUpdate(syncAdapterURI(ContentUris.withAppendedId(Events.CONTENT_URI, id)))
-                                    .withValue(LocalEvent.COLUMN_SEQUENCE, sequence + 1)
-                                    .withValue(Events.DIRTY, 0)
-                    ))
-                    batch.commit()
-                }
-            }
-        } catch (e: RemoteException) {
-            throw CalendarStorageException("Couldn't process locally modified exception", e)
-        }
-    }
-
-
-    object Factory: AndroidCalendarFactory<LocalCalendar> {
-
-        override fun newInstance(account: Account, provider: ContentProviderClient, id: Long) =
-            LocalCalendar(account, provider, id)
-
-    }
-
-}

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

@@ -1,35 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import at.bitfire.ical4android.CalendarStorageException
-import at.bitfire.vcard4android.ContactsStorageException
-import java.io.FileNotFoundException
-
-interface LocalCollection<out T: LocalResource> {
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun getDeleted(): List<T>
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun getWithoutFileName(): List<T>
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class, FileNotFoundException::class)
-    fun getDirty(): List<T>
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun getAll(): List<T>
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun getCTag(): String?
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun setCTag(cTag: String?)
-
-}

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

@@ -1,284 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import android.content.ContentProviderOperation
-import android.content.ContentValues
-import android.os.Build
-import android.os.RemoteException
-import android.provider.ContactsContract
-import android.provider.ContactsContract.CommonDataKinds.GroupMembership
-import android.provider.ContactsContract.RawContacts.Data
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.UnknownProperties
-import at.bitfire.vcard4android.*
-import ezvcard.Ezvcard
-import java.io.FileNotFoundException
-import java.util.*
-
-class LocalContact: AndroidContact, LocalResource {
-
-    companion object {
-
-        init {
-            Contact.productID = "+//IDN bitfire.at//DAVdroid/" + BuildConfig.VERSION_NAME + " ez-vcard/" + Ezvcard.VERSION
-        }
-
-        val COLUMN_HASHCODE = ContactsContract.RawContacts.SYNC3
-
-    }
-
-    private val cachedGroupMemberships = HashSet<Long>()
-    private val groupMemberships = HashSet<Long>()
-
-
-    constructor(addressBook: AndroidAddressBook<LocalContact,*>, id: Long, fileName: String?, eTag: String?):
-            super(addressBook, id, fileName, eTag)
-
-    constructor(addressBook: AndroidAddressBook<LocalContact,*>, contact: Contact, fileName: String?, eTag: String?):
-            super(addressBook, contact, fileName, eTag)
-
-
-    @Throws(ContactsStorageException::class)
-    fun resetDeleted() {
-        val values = ContentValues(1)
-        values.put(ContactsContract.RawContacts.DELETED, 0)
-        try {
-            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Couldn't clear deleted flag", e)
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    fun resetDirty() {
-        val values = ContentValues(1)
-        values.put(ContactsContract.RawContacts.DIRTY, 0)
-        try {
-            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Couldn't clear dirty flag", e)
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    override fun clearDirty(eTag: String?) {
-        try {
-            val values = ContentValues(3)
-            values.put(COLUMN_ETAG, eTag)
-            values.put(ContactsContract.RawContacts.DIRTY, 0)
-
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-                // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
-                val hashCode = dataHashCode()
-                values.put(COLUMN_HASHCODE, hashCode)
-                Logger.log.finer("Clearing dirty flag with eTag = $eTag, contact hash = $hashCode")
-            }
-
-            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-
-            this.eTag = eTag
-        } catch(e: Exception) {
-            throw ContactsStorageException("Couldn't clear dirty flag", e)
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    override fun prepareForUpload() {
-        try {
-            val uid = UUID.randomUUID().toString()
-            val newFileName = uid + ".vcf"
-
-            val values = ContentValues(2)
-            values.put(COLUMN_FILENAME, newFileName)
-            values.put(COLUMN_UID, uid)
-            addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-
-            fileName = newFileName
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Couldn't update UID", e)
-        }
-    }
-
-
-    @Throws(ContactsStorageException::class)
-    override fun populateData(mimeType: String, row: ContentValues) {
-        when (mimeType) {
-            CachedGroupMembership.CONTENT_ITEM_TYPE ->
-                cachedGroupMemberships.add(row.getAsLong(CachedGroupMembership.GROUP_ID))
-            GroupMembership.CONTENT_ITEM_TYPE ->
-                groupMemberships.add(row.getAsLong(GroupMembership.GROUP_ROW_ID))
-            UnknownProperties.CONTENT_ITEM_TYPE ->
-                try {
-                    contact!!.unknownProperties = row.getAsString(UnknownProperties.UNKNOWN_PROPERTIES)
-                } catch(e: FileNotFoundException) {
-                    throw ContactsStorageException("Couldn't fetch data rows", e)
-                }
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    override fun insertDataRows(batch: BatchOperation) {
-        super.insertDataRows(batch)
-
-        try {
-            contact!!.unknownProperties?.let { unknownProperties ->
-                val op: BatchOperation.Operation
-                val builder = ContentProviderOperation.newInsert(dataSyncURI())
-                if (id == null)
-                    op = BatchOperation.Operation(builder, UnknownProperties.RAW_CONTACT_ID, 0)
-                else {
-                    op = BatchOperation.Operation(builder)
-                    builder.withValue(UnknownProperties.RAW_CONTACT_ID, id)
-                }
-                builder .withValue(UnknownProperties.MIMETYPE, UnknownProperties.CONTENT_ITEM_TYPE)
-                        .withValue(UnknownProperties.UNKNOWN_PROPERTIES, unknownProperties)
-                batch.enqueue(op)
-            }
-        } catch(e: FileNotFoundException) {
-            throw ContactsStorageException("Couldn't insert data rows", e)
-        }
-
-    }
-
-
-    /**
-     * 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)
-     */
-    @Throws(FileNotFoundException::class, ContactsStorageException::class)
-    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
-    }
-
-    @Throws(ContactsStorageException::class)
-    fun updateHashCode(batch: BatchOperation?) {
-        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N || Build.VERSION.SDK_INT >= Build.VERSION_CODES.O)
-            throw IllegalStateException("updateHashCode() should not be called on Android != 7")
-
-        val values = ContentValues(1)
-        try {
-            val hashCode = dataHashCode()
-            Logger.log.fine("Storing contact hash = $hashCode")
-            values.put(COLUMN_HASHCODE, hashCode)
-
-            if (batch == null)
-                addressBook.provider!!.update(rawContactSyncURI(), values, null, null)
-            else {
-                val builder = ContentProviderOperation
-                        .newUpdate(rawContactSyncURI())
-                        .withValues(values)
-                batch.enqueue(BatchOperation.Operation(builder))
-            }
-        } catch(e: Exception) {
-            throw ContactsStorageException("Couldn't store contact checksum", e)
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    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")
-
-        try {
-            addressBook.provider!!.query(rawContactSyncURI(), arrayOf(COLUMN_HASHCODE), null, null, null)?.use { c ->
-                if (c.moveToNext() && !c.isNull(0))
-                    return c.getInt(0)
-            }
-            return 0
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Could't read last hash code", e)
-        }
-    }
-
-
-    fun addToGroup(batch: BatchOperation, groupID: Long) {
-        batch.enqueue(BatchOperation.Operation(
-                ContentProviderOperation.newInsert(dataSyncURI())
-                        .withValue(GroupMembership.MIMETYPE, GroupMembership.CONTENT_ITEM_TYPE)
-                        .withValue(GroupMembership.RAW_CONTACT_ID, id)
-                        .withValue(GroupMembership.GROUP_ROW_ID, groupID)
-        ))
-        groupMemberships.add(groupID)
-
-        batch.enqueue(BatchOperation.Operation(
-                ContentProviderOperation.newInsert(dataSyncURI())
-                        .withValue(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
-                        .withValue(CachedGroupMembership.RAW_CONTACT_ID, id)
-                        .withValue(CachedGroupMembership.GROUP_ID, groupID)
-                        .withYieldAllowed(true)
-        ))
-        cachedGroupMemberships.add(groupID)
-    }
-
-    fun removeGroupMemberships(batch: BatchOperation) {
-        batch.enqueue(BatchOperation.Operation(
-                ContentProviderOperation.newDelete(dataSyncURI())
-                        .withSelection(
-                                Data.RAW_CONTACT_ID + "=? AND " + Data.MIMETYPE + " IN (?,?)",
-                                arrayOf(id.toString(), GroupMembership.CONTENT_ITEM_TYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
-                        )
-                        .withYieldAllowed(true)
-        ))
-        groupMemberships.clear()
-        cachedGroupMemberships.clear()
-    }
-
-    /**
-     * Returns the IDs of all groups the contact was member of (cached memberships).
-     * Cached memberships are kept in sync with memberships by DAVdroid 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 ContactsStorageException   on contact provider errors
-     * @throws FileNotFoundException      if the current contact can't be found
-     */
-    @Throws(FileNotFoundException::class, ContactsStorageException::class)
-    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 ContactsStorageException   on contact provider errors
-     * @throws FileNotFoundException      if the current contact can't be found
-     */
-    @Throws(FileNotFoundException::class, ContactsStorageException::class)
-    fun getGroupMemberships(): Set<Long> {
-        contact
-        return groupMemberships
-    }
-
-
-    // factory
-
-    object Factory: AndroidContactFactory<LocalContact> {
-
-        override fun newInstance(addressBook: AndroidAddressBook<LocalContact, *>, id: Long, fileName: String?, eTag: String?) =
-                LocalContact(addressBook, id, fileName, eTag)
-
-        override fun newInstance(addressBook: AndroidAddressBook<LocalContact, *>, contact: Contact, fileName: String?, eTag: String?) =
-                LocalContact(addressBook, contact, fileName, eTag)
-
-    }
-
-}

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

@@ -1,141 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import android.content.ContentProviderOperation
-import android.content.ContentValues
-import android.provider.CalendarContract
-import android.provider.CalendarContract.Events
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.ical4android.*
-import net.fortuna.ical4j.model.property.ProdId
-import java.io.FileNotFoundException
-import java.util.*
-
-class LocalEvent: AndroidEvent, LocalResource {
-
-    companion object {
-        init {
-            iCalendar.prodId = ProdId("+//IDN bitfire.at//DAVdroid/" + BuildConfig.VERSION_NAME + " ical4j/2.x")
-        }
-
-        val COLUMN_ETAG = CalendarContract.Events.SYNC_DATA1
-        val COLUMN_SEQUENCE = CalendarContract.Events.SYNC_DATA3
-    }
-
-    override var fileName: String? = null
-    override var eTag: String? = null
-
-    var weAreOrganizer = true
-
-
-    constructor(calendar: AndroidCalendar<*>, event: Event, fileName: String?, eTag: String?): super(calendar, event) {
-        this.fileName = fileName
-        this.eTag = eTag
-    }
-
-    private constructor(calendar: AndroidCalendar<*>, id: Long, baseInfo: ContentValues?): super(calendar, id, baseInfo) {
-        baseInfo?.let {
-            fileName = it.getAsString(Events._SYNC_ID)
-            eTag = it.getAsString(COLUMN_ETAG)
-        }
-    }
-
-
-    /* process LocalEvent-specific fields */
-
-    @Throws(FileNotFoundException::class, CalendarStorageException::class)
-    override fun populateEvent(row: ContentValues) {
-        super.populateEvent(row)
-        val event = requireNotNull(event)
-
-        fileName = row.getAsString(Events._SYNC_ID)
-        eTag = row.getAsString(COLUMN_ETAG)
-        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
-    }
-
-    @Throws(FileNotFoundException::class, CalendarStorageException::class)
-    override fun buildEvent(recurrence: Event?, builder: ContentProviderOperation.Builder) {
-        super.buildEvent(recurrence, builder)
-        val event = requireNotNull(event)
-
-        val buildException = recurrence != null
-        val eventToBuild = recurrence ?: event
-
-        builder .withValue(Events.UID_2445, event.uid)
-                .withValue(COLUMN_SEQUENCE, eventToBuild.sequence)
-                .withValue(CalendarContract.Events.DIRTY, 0)
-                .withValue(CalendarContract.Events.DELETED, 0)
-
-        if (buildException)
-            builder .withValue(Events.ORIGINAL_SYNC_ID, fileName)
-        else
-            builder .withValue(Events._SYNC_ID, fileName)
-                    .withValue(COLUMN_ETAG, eTag)
-    }
-
-
-    /* custom queries */
-
-    @Throws(CalendarStorageException::class)
-    override fun prepareForUpload() {
-        try {
-            var uid: String? = null
-            calendar.provider.query(eventSyncURI(), arrayOf(Events.UID_2445), null, null, null)?.use { cursor ->
-                if (cursor.moveToNext())
-                    uid = cursor.getString(0)
-            }
-            if (uid == null)
-                uid = UUID.randomUUID().toString()
-
-            val newFileName = "$uid.ics"
-
-            val values = ContentValues(2)
-            values.put(Events._SYNC_ID, newFileName)
-            values.put(Events.UID_2445, uid)
-            calendar.provider.update(eventSyncURI(), values, null, null)
-
-            fileName = newFileName
-            event!!.uid = uid
-
-        } catch(e: Exception) {
-            throw CalendarStorageException("Couldn't update UID", e)
-        }
-    }
-
-    @Throws(CalendarStorageException::class)
-    override fun clearDirty(eTag: String?) {
-        try {
-            val values = ContentValues(2)
-            values.put(CalendarContract.Events.DIRTY, 0)
-            values.put(COLUMN_ETAG, eTag)
-            values.put(COLUMN_SEQUENCE, event!!.sequence)
-            calendar.provider.update(eventSyncURI(), values, null, null)
-
-            this.eTag = eTag
-        } catch (e: Exception) {
-            throw CalendarStorageException("Couldn't update UID", e)
-        }
-    }
-
-
-    object Factory: AndroidEventFactory<LocalEvent> {
-
-        override fun newInstance(calendar: AndroidCalendar<*>, id: Long, baseInfo: ContentValues?) =
-                LocalEvent(calendar, id, baseInfo)
-
-        override fun newInstance(calendar: AndroidCalendar<*>, event: Event) =
-                LocalEvent(calendar, event, null, null)
-
-    }
-}

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

@@ -1,255 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import android.content.ContentProviderOperation
-import android.content.ContentUris
-import android.content.ContentValues
-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.dav4android.Constants
-import at.bitfire.vcard4android.*
-import java.io.FileNotFoundException
-import java.util.*
-import java.util.logging.Level
-
-class LocalGroup: AndroidGroup, LocalResource {
-
-    companion object {
-
-        /** marshaled list of member UIDs, as sent by server */
-        val COLUMN_PENDING_MEMBERS = Groups.SYNC3
-
-        /**
-         * Processes all groups with non-null {@link #COLUMN_PENDING_MEMBERS}: the pending memberships
-         * are (if possible) applied, keeping cached memberships in sync.
-         * @param addressBook    address book to take groups from
-         * @throws ContactsStorageException on contact provider errors
-         */
-        @JvmStatic
-        @Throws(ContactsStorageException::class)
-        fun applyPendingMemberships(addressBook: LocalAddressBook) {
-            try {
-                addressBook.provider!!.query(
-                        addressBook.syncAdapterURI(Groups.CONTENT_URI),
-                        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.add(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")
-                            try {
-                                val member = addressBook.findContactByUID(uid)
-                                member.addToGroup(batch, id)
-                                changeContactIDs.add(member.id!!)
-                            } catch(e: FileNotFoundException) {
-                                Constants.log.log(Level.WARNING, "Group member not found: $uid", e)
-                            }
-                        }
-
-                        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 { LocalContact(addressBook, it, null, null) }
-                                    .forEach { it.updateHashCode(batch) }
-
-                        // remove pending memberships
-                        batch.enqueue(BatchOperation.Operation(
-                                ContentProviderOperation.newUpdate(addressBook.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, id)))
-                                        .withValue(COLUMN_PENDING_MEMBERS, null)
-                                        .withYieldAllowed(true)
-                                ))
-
-                        batch.commit()
-                    }
-                }
-            } catch(e: RemoteException) {
-                throw ContactsStorageException("Couldn't get pending memberships", e)
-            }
-        }
-
-    }
-
-
-    constructor(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, id: Long, fileName: String?, eTag: String?):
-        super(addressBook, id, fileName, eTag)
-
-    constructor(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, contact: Contact, fileName: String?, eTag: String?):
-        super(addressBook, contact, fileName, eTag)
-
-
-    @Throws(ContactsStorageException::class)
-    fun resetDeleted() {
-        val uri = ContentUris.withAppendedId(addressBook.syncAdapterURI(ContactsContract.Groups.CONTENT_URI), requireNotNull(id))
-
-        val values = ContentValues(1)
-        values.put(ContactsContract.Groups.DELETED, 0)
-        try {
-            addressBook.provider!!.update(uri, values, null, null)
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Couldn't clear deleted flag", e)
-        }
-    }
-
-    @Throws(ContactsStorageException::class)
-    override fun clearDirty(eTag: String?) {
-        val id = requireNotNull(id)
-
-        val values = ContentValues(2)
-        values.put(Groups.DIRTY, 0)
-        values.put(COLUMN_ETAG, eTag)
-        this.eTag = eTag
-        update(values)
-
-        // update cached group memberships
-        val batch = BatchOperation(addressBook.provider!!)
-
-        // delete cached group memberships
-        batch.enqueue(BatchOperation.Operation(
-                ContentProviderOperation.newDelete(addressBook.syncAdapterURI(ContactsContract.Data.CONTENT_URI))
-                        .withSelection(
-                                CachedGroupMembership.MIMETYPE + "=? AND " + CachedGroupMembership.GROUP_ID + "=?",
-                                arrayOf(CachedGroupMembership.CONTENT_ITEM_TYPE, id.toString())
-                        )
-        ))
-
-        // insert updated cached group memberships
-        for (member in getMembers())
-            batch.enqueue(BatchOperation.Operation(
-                    ContentProviderOperation.newInsert(addressBook.syncAdapterURI(ContactsContract.Data.CONTENT_URI))
-                            .withValue(CachedGroupMembership.MIMETYPE, CachedGroupMembership.CONTENT_ITEM_TYPE)
-                            .withValue(CachedGroupMembership.RAW_CONTACT_ID, member)
-                            .withValue(CachedGroupMembership.GROUP_ID, id)
-                            .withYieldAllowed(true)
-            ))
-
-        batch.commit()
-    }
-
-    @Throws(ContactsStorageException::class)
-    override fun prepareForUpload() {
-        val uid = UUID.randomUUID().toString()
-        val newFileName = "$uid.vcf"
-
-        val values = ContentValues(2)
-        values.put(COLUMN_FILENAME, newFileName)
-        values.put(COLUMN_UID, uid)
-        update(values)
-
-        fileName = newFileName
-    }
-
-    @Throws(FileNotFoundException::class, ContactsStorageException::class)
-    override fun contentValues(): ContentValues  {
-        val values = super.contentValues()
-
-        val members = Parcel.obtain()
-        try {
-            members.writeStringList(contact!!.members)
-            values.put(COLUMN_PENDING_MEMBERS, members.marshall())
-        } finally {
-            members.recycle()
-        }
-        return values
-    }
-
-
-    /**
-     * Marks all members of the current group as dirty.
-     */
-    @Throws(ContactsStorageException::class)
-    fun markMembersDirty() {
-        val batch = BatchOperation(addressBook.provider!!)
-
-        for (member in getMembers())
-            batch.enqueue(BatchOperation.Operation(
-                    ContentProviderOperation.newUpdate(addressBook.syncAdapterURI(ContentUris.withAppendedId(RawContacts.CONTENT_URI, member)))
-                            .withValue(RawContacts.DIRTY, 1)
-                            .withYieldAllowed(true)
-            ))
-
-        batch.commit()
-    }
-
-
-    // helpers
-
-    /**
-     * Lists all members of this group.
-     * @return list of all members' raw contact IDs
-     * @throws ContactsStorageException on contact provider errorst
-     */
-    @Throws(ContactsStorageException::class)
-    internal fun getMembers(): List<Long> {
-        val id = requireNotNull(id)
-        val members = LinkedList<Long>()
-        try {
-            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.add(cursor.getLong(0))
-            }
-        } catch(e: RemoteException) {
-            throw ContactsStorageException("Couldn't list group members", e)
-        }
-        return members
-    }
-
-
-    // factory
-
-    object Factory: AndroidGroupFactory<LocalGroup> {
-
-        override fun newInstance(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, id: Long, fileName: String?, eTag: String?) =
-                LocalGroup(addressBook, id, fileName, eTag)
-
-        override fun newInstance(addressBook: AndroidAddressBook<out AndroidContact, LocalGroup>, contact: Contact, fileName: String?, eTag: String?) =
-                LocalGroup(addressBook, contact, fileName, eTag)
-
-    }
-
-}

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

@@ -1,30 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import at.bitfire.ical4android.CalendarStorageException
-import at.bitfire.vcard4android.ContactsStorageException
-
-interface LocalResource {
-
-    val id: Long?
-
-    var fileName: String?
-    var eTag: String?
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun delete(): Int
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun prepareForUpload()
-
-    @Throws(CalendarStorageException::class, ContactsStorageException::class)
-    fun clearDirty(eTag: String?)
-
-}

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

@@ -1,114 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import android.content.ContentProviderOperation
-import android.content.ContentValues
-import android.provider.CalendarContract.Events
-import at.bitfire.ical4android.*
-import org.dmfs.tasks.contract.TaskContract.Tasks
-import java.io.FileNotFoundException
-import java.text.ParseException
-import java.util.*
-
-class LocalTask: AndroidTask, LocalResource {
-
-    companion object {
-        val COLUMN_ETAG = Tasks.SYNC_VERSION
-        val COLUMN_SEQUENCE = Tasks.SYNC3
-    }
-
-    override var fileName: String? = null
-    override var eTag: String? = null
-
-    constructor(taskList: AndroidTaskList<*>, task: Task, fileName: String?, eTag: String?): super(taskList, task) {
-        this.fileName = fileName
-        this.eTag = eTag
-    }
-
-    private constructor(taskList: AndroidTaskList<*>, id: Long, baseInfo: ContentValues?): super(taskList, id) {
-        baseInfo?.let {
-            fileName = it.getAsString(Events._SYNC_ID)
-            eTag = it.getAsString(COLUMN_ETAG)
-        }
-    }
-
-
-    /* process LocalTask-specific fields */
-
-    @Throws(ParseException::class)
-    override fun populateTask(values: ContentValues) {
-        super.populateTask(values)
-
-        fileName = values.getAsString(Events._SYNC_ID)
-        eTag = values.getAsString(COLUMN_ETAG)
-
-        val task = requireNotNull(task)
-        task.sequence = values.getAsInteger(COLUMN_SEQUENCE)
-    }
-
-    @Throws(FileNotFoundException::class, CalendarStorageException::class)
-    override fun buildTask(builder: ContentProviderOperation.Builder, update: Boolean) {
-        super.buildTask(builder, update)
-        val task = requireNotNull(task)
-
-        builder .withValue(Tasks._SYNC_ID, fileName)
-                .withValue(COLUMN_SEQUENCE, task.sequence)
-                .withValue(COLUMN_ETAG, eTag)
-    }
-
-
-    /* custom queries */
-
-    @Throws(CalendarStorageException::class)
-    override fun prepareForUpload() {
-        try {
-            val uid = UUID.randomUUID().toString()
-            val newFileName = uid + ".ics"
-
-            val values = ContentValues(2)
-            values.put(Tasks._SYNC_ID, newFileName)
-            values.put(Tasks._UID, uid)
-            taskList.provider.client.update(taskSyncURI(), values, null, null)
-
-            fileName = newFileName
-
-            task!!.uid = uid
-        } catch (e: Exception) {
-            throw CalendarStorageException("Couldn't update UID", e)
-        }
-    }
-
-    @Throws(CalendarStorageException::class)
-    override fun clearDirty(eTag: String?) {
-        try {
-            val values = ContentValues(2)
-            values.put(Tasks._DIRTY, 0)
-            values.put(COLUMN_ETAG, eTag)
-
-            values.put(COLUMN_SEQUENCE, task!!.sequence)
-            taskList.provider.client.update(taskSyncURI(), values, null, null)
-
-            this.eTag = eTag
-        } catch (e: Exception) {
-            throw CalendarStorageException("Couldn't update _DIRTY/ETag/SEQUENCE", e)
-        }
-    }
-
-
-    object Factory: AndroidTaskFactory<LocalTask> {
-
-        override fun newInstance(calendar: AndroidTaskList<*>, id: Long, baseInfo: ContentValues?) =
-                LocalTask(calendar, id, baseInfo)
-
-        override fun newInstance(calendar: AndroidTaskList<*>, task: Task) =
-                LocalTask(calendar, task, null, null)
-
-    }
-}

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

@@ -1,164 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.resource
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.ContentResolver
-import android.content.ContentValues
-import android.content.Context
-import android.net.Uri
-import android.os.Build
-import at.bitfire.davdroid.DavUtils
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.ical4android.AndroidTaskList
-import at.bitfire.ical4android.AndroidTaskListFactory
-import at.bitfire.ical4android.CalendarStorageException
-import at.bitfire.ical4android.TaskProvider
-import org.dmfs.tasks.contract.TaskContract.TaskLists
-import org.dmfs.tasks.contract.TaskContract.Tasks
-import java.io.FileNotFoundException
-
-class LocalTaskList private constructor(
-        account: Account,
-        provider: TaskProvider,
-        id: Long
-): AndroidTaskList<LocalTask>(account, provider, LocalTask.Factory, id), LocalCollection<LocalTask> {
-
-    companion object {
-
-        val defaultColor = 0xFFC3EA6E.toInt()     // "DAVdroid green"
-
-        val COLUMN_CTAG = TaskLists.SYNC_VERSION
-
-        val BASE_INFO_COLUMNS = arrayOf(
-            Tasks._ID,
-            Tasks._SYNC_ID,
-            LocalTask.COLUMN_ETAG
-        )
-
-        @JvmStatic
-        fun tasksProviderAvailable(context: Context): Boolean {
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
-                return context.packageManager.resolveContentProvider(TaskProvider.ProviderName.OpenTasks.authority, 0) != null
-            else {
-                val provider = TaskProvider.acquire(context, TaskProvider.ProviderName.OpenTasks)
-                provider?.use { return true }
-                return false
-            }
-        }
-
-        @JvmStatic
-        @Throws(CalendarStorageException::class)
-        fun create(account: Account, provider: TaskProvider, info: CollectionInfo): Uri {
-            val values = valuesFromCollectionInfo(info, true)
-            values.put(TaskLists.OWNER, account.name)
-            values.put(TaskLists.SYNC_ENABLED, 1)
-            values.put(TaskLists.VISIBLE, 1)
-            return create(account, provider, values)
-        }
-
-        @JvmStatic
-        @Throws(Exception::class)
-        fun onRenameAccount(resolver: ContentResolver, oldName: String, newName: String) {
-            var client: ContentProviderClient? = null
-            try {
-                client = resolver.acquireContentProviderClient(TaskProvider.ProviderName.OpenTasks.authority)
-                client?.use {
-                    val values = ContentValues(1)
-                    values.put(Tasks.ACCOUNT_NAME, newName)
-                    it.update(Tasks.getContentUri(TaskProvider.ProviderName.OpenTasks.authority), values, "${Tasks.ACCOUNT_NAME}=?", arrayOf(oldName))
-                }
-            } finally {
-                if (Build.VERSION.SDK_INT >= 24)
-                    client?.close()
-                else
-                    client?.release()
-            }
-        }
-
-        private fun valuesFromCollectionInfo(info: CollectionInfo, withColor: Boolean): ContentValues {
-            val values = ContentValues(3)
-            values.put(TaskLists._SYNC_ID, info.url)
-            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 ?: defaultColor)
-
-            return values
-        }
-
-    }
-
-
-    override fun taskBaseInfoColumns() = BASE_INFO_COLUMNS
-
-
-    @Throws(CalendarStorageException::class)
-    fun update(info: CollectionInfo, updateColor: Boolean) {
-        update(valuesFromCollectionInfo(info, updateColor))
-    }
-
-
-    @Throws(CalendarStorageException::class)
-    override fun getAll() = queryTasks(null, null)
-
-    @Throws(CalendarStorageException::class)
-    override fun getDeleted() = queryTasks("${Tasks._DELETED}!=0", null)
-
-    @Throws(CalendarStorageException::class)
-    override fun getWithoutFileName() = queryTasks("${Tasks._SYNC_ID} IS NULL", null)
-
-    @Throws(FileNotFoundException::class, CalendarStorageException::class)
-    override fun getDirty(): List<LocalTask> {
-        val tasks = queryTasks("${Tasks._DIRTY}!=0", null)
-        for (localTask in tasks) {
-            val task = requireNotNull(localTask.task)
-            val sequence = task.sequence
-            if (sequence == null)    // sequence has not been assigned yet (i.e. this task was just locally created)
-                task.sequence = 0
-            else
-                task.sequence = sequence + 1
-        }
-        return tasks
-    }
-
-
-    @Throws(CalendarStorageException::class)
-    override fun getCTag(): String? =
-        try {
-            provider.client.query(taskListSyncUri(), arrayOf(COLUMN_CTAG), null, null, null)?.use { cursor ->
-                if (cursor.moveToNext())
-                    return cursor.getString(0)
-            }
-            null
-        } catch(e: Exception) {
-            throw CalendarStorageException("Couldn't read local (last known) CTag", e)
-        }
-
-    @Throws(CalendarStorageException::class)
-    override fun setCTag(cTag: String?) {
-        try {
-            val values = ContentValues(1)
-            values.put(COLUMN_CTAG, cTag)
-            provider.client.update(taskListSyncUri(), values, null, null)
-        } catch (e: Exception) {
-            throw CalendarStorageException("Couldn't write local (last known) CTag", e)
-        }
-    }
-
-
-    object Factory: AndroidTaskListFactory<LocalTaskList> {
-
-        override fun newInstance(account: Account, provider: TaskProvider, id: Long) =
-                LocalTaskList(account, provider, id)
-
-    }
-
-}

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

@@ -1,74 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import at.bitfire.davdroid.App
-
-open class DefaultsProvider(
-        private val allowOverride: Boolean = true
-): Provider {
-
-    open val booleanDefaults = mapOf(
-            Pair(App.DISTRUST_SYSTEM_CERTIFICATES, false),
-            Pair(App.OVERRIDE_PROXY, false)
-    )
-
-    open val intDefaults = mapOf(
-            Pair(App.OVERRIDE_PROXY_PORT, App.OVERRIDE_PROXY_PORT_DEFAULT)
-    )
-
-    open val longDefaults = mapOf<String, Long>()
-
-    open val stringDefaults = mapOf(
-            Pair(App.OVERRIDE_PROXY_HOST, App.OVERRIDE_PROXY_HOST_DEFAULT)
-    )
-
-
-    override fun close() {
-    }
-
-    override fun forceReload() {
-    }
-
-
-    private fun hasKey(key: String) =
-            booleanDefaults.containsKey(key) ||
-            intDefaults.containsKey(key) ||
-            longDefaults.containsKey(key) ||
-            stringDefaults.containsKey(key)
-
-    override fun has(key: String): Pair<Boolean, Boolean> {
-        val has = hasKey(key)
-        return Pair(has, allowOverride || !has)
-    }
-
-
-    override fun getBoolean(key: String) =
-            Pair(booleanDefaults[key], allowOverride || !booleanDefaults.containsKey(key))
-
-    override fun getInt(key: String) =
-            Pair(intDefaults[key], allowOverride || !intDefaults.containsKey(key))
-
-    override fun getLong(key: String) =
-            Pair(longDefaults[key], allowOverride || !longDefaults.containsKey(key))
-
-    override fun getString(key: String) =
-            Pair(stringDefaults[key], allowOverride || !stringDefaults.containsKey(key))
-
-
-    override fun isWritable(key: String) = Pair(false, allowOverride || !hasKey(key))
-
-    override fun putBoolean(key: String, value: Boolean?) = false
-    override fun putInt(key: String, value: Int?) = false
-    override fun putLong(key: String, value: Long?) = false
-    override fun putString(key: String, value: String?) = false
-
-    override fun remove(key: String) = false
-
-}

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

@@ -1,38 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import java.io.Closeable
-
-interface Provider: Closeable {
-
-    fun forceReload()
-
-    fun has(key: String): Pair<Boolean, Boolean>
-
-    fun getBoolean(key: String): Pair<Boolean?, Boolean>
-    fun getInt(key: String): Pair<Int?, Boolean>
-    fun getLong(key: String): Pair<Long?, Boolean>
-    fun getString(key: String): Pair<String?, Boolean>
-
-    fun isWritable(key: String): Pair<Boolean, Boolean>
-
-    fun putBoolean(key: String, value: Boolean?): Boolean
-    fun putInt(key: String, value: Int?): Boolean
-    fun putLong(key: String, value: Long?): Boolean
-    fun putString(key: String, value: String?): Boolean
-
-    fun remove(key: String): Boolean
-
-
-    interface Observer {
-        fun onReload()
-    }
-
-}

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

@@ -1,276 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import android.annotation.TargetApi
-import android.app.Service
-import android.content.ComponentName
-import android.content.Context
-import android.content.Intent
-import android.content.ServiceConnection
-import android.os.Build
-import android.os.Handler
-import android.os.IBinder
-import android.os.Looper
-import at.bitfire.davdroid.log.Logger
-import java.io.Closeable
-import java.lang.ref.WeakReference
-import java.util.*
-import java.util.logging.Level
-
-class Settings: Service(), Provider.Observer {
-
-    private val providers = LinkedList<Provider>()
-    private val observers = LinkedList<WeakReference<ISettingsObserver>>()
-
-    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
-    override fun onCreate() {
-        Logger.log.info("Initializing Settings service")
-
-        // always add a defaults provider first
-        providers.add(DefaultsProvider())
-
-        // always add a provider for local preferences
-        providers.add(SharedPreferencesProvider(this))
-    }
-
-    override fun onDestroy() {
-        Logger.log.info("Shutting down Settings service")
-        providers.forEach { it.close() }
-        providers.clear()
-    }
-
-    override fun onTrimMemory(level: Int) {
-        stopSelf()
-    }
-
-
-    fun forceReload() {
-        providers.forEach { it.forceReload() }
-    }
-
-    override fun onReload() {
-        observers.forEach {
-            Handler(Looper.getMainLooper()).post {
-                it.get()?.onSettingsChanged()
-            }
-        }
-    }
-
-
-    private fun has(key: String): Boolean {
-        Logger.log.fine("Looking for setting $key")
-        var result = false
-        for (provider in providers)
-            try {
-                val (value, further) = provider.has(key)
-                Logger.log.finer("${provider::class.java.simpleName}: has $key = $value, continue: $further")
-                if (value) {
-                    result = true
-                    break
-                }
-                if (!further)
-                    break
-            } catch(e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't look up setting in $provider", e)
-            }
-        Logger.log.fine("Looking for setting $key -> $result")
-        return result
-    }
-
-    private fun<T> getValue(key: String, reader: (Provider) -> Pair<T?, Boolean>): T? {
-        Logger.log.fine("Looking up setting $key")
-        var result: T? = null
-        for (provider in providers)
-            try {
-                val (value, further) = reader(provider)
-                Logger.log.finer("${provider::class.java.simpleName}: value = $value, continue: $further")
-                value?.let { result = it }
-                if (!further)
-                    break
-            } catch(e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't read setting from $provider", e)
-            }
-        Logger.log.fine("Looked up setting $key -> $result")
-        return result
-    }
-
-    fun getBoolean(key: String) =
-            getValue(key, { provider -> provider.getBoolean(key) })
-
-    fun getInt(key: String) =
-            getValue(key, { provider -> provider.getInt(key) })
-
-    fun getLong(key: String) =
-            getValue(key, { provider -> provider.getLong(key) })
-
-    fun getString(key: String) =
-            getValue(key, { provider -> provider.getString(key) })
-
-
-    fun isWritable(key: String): Boolean {
-        for (provider in providers) {
-            val (value, further) = provider.isWritable(key)
-            if (value)
-                return true
-            if (!further)
-                return false
-        }
-        return false
-    }
-
-    private fun<T> putValue(key: String, value: T?, writer: (Provider) -> Boolean): Boolean {
-        Logger.log.fine("Trying to write setting $key = $value")
-        for (provider in providers) {
-            val (writable, further) = provider.isWritable(key)
-            Logger.log.finer("${provider::class.java.simpleName}: writable = $writable, continue: $further")
-            if (writable)
-                return try {
-                    writer(provider)
-                } catch (e: Exception) {
-                    Logger.log.log(Level.SEVERE, "Couldn't write setting to $provider", e)
-                    false
-                }
-            if (!further)
-                return false
-        }
-        return false
-    }
-
-    fun putBoolean(key: String, value: Boolean?) =
-            putValue(key, value, { provider -> provider.putBoolean(key, value) })
-
-    fun putInt(key: String, value: Int?) =
-            putValue(key, value, { provider -> provider.putInt(key, value) })
-
-    fun putLong(key: String, value: Long?) =
-            putValue(key, value, { provider -> provider.putLong(key, value) })
-
-    fun putString(key: String, value: String?) =
-            putValue(key, value, { provider -> provider.putString(key, value) })
-
-    fun remove(key: String): Boolean {
-        var deleted = false
-        providers.forEach { deleted = deleted || it.remove(key) }
-        return deleted
-    }
-
-
-    val binder = object: ISettings.Stub() {
-
-        override fun forceReload() =
-               this@Settings.forceReload()
-
-        override fun has(key: String) =
-                this@Settings.has(key)
-
-        override fun getBoolean(key: String, defaultValue: Boolean) =
-                this@Settings.getBoolean(key) ?: defaultValue
-
-        override fun getInt(key: String, defaultValue: Int) =
-                this@Settings.getInt(key) ?: defaultValue
-
-        override fun getLong(key: String, defaultValue: Long) =
-                this@Settings.getLong(key) ?: defaultValue
-
-        override fun getString(key: String, defaultValue: String?) =
-                this@Settings.getString(key) ?: defaultValue
-
-        override fun isWritable(key: String) =
-                this@Settings.isWritable(key)
-
-        override fun remove(key: String) =
-                this@Settings.remove(key)
-
-        override fun putBoolean(key: String, value: Boolean) =
-                this@Settings.putBoolean(key, value)
-
-        override fun putString(key: String, value: String?) =
-                this@Settings.putString(key, value)
-
-        override fun putInt(key: String, value: Int) =
-                this@Settings.putInt(key, value)
-
-        override fun putLong(key: String, value: Long) =
-                this@Settings.putLong(key, value)
-
-        override fun registerObserver(observer: ISettingsObserver) {
-            observers += WeakReference(observer)
-        }
-
-        override fun unregisterObserver(observer: ISettingsObserver) {
-            observers.removeAll { it.get() == observer }
-        }
-
-    }
-
-    override fun onBind(intent: Intent?) = binder
-
-
-    class Stub(
-            delegate: ISettings,
-            private val context: Context,
-            private val serviceConn: ServiceConnection
-    ): ISettings by delegate, Closeable {
-
-        override fun close() {
-            try {
-                context.unbindService(serviceConn)
-            } catch(e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't unbind Settings service", e)
-            }
-        }
-
-    }
-
-    companion object {
-
-        fun getInstance(context: Context): Stub? {
-            if (Looper.getMainLooper().thread == Thread.currentThread())
-                throw IllegalStateException("Must not be called from main thread")
-
-            var service: ISettings? = null
-            val serviceLock = Object()
-            val serviceConn = object: ServiceConnection {
-                override fun onServiceConnected(name: ComponentName, binder: IBinder) {
-                    synchronized(serviceLock) {
-                        service = ISettings.Stub.asInterface(binder)
-                        serviceLock.notify()
-                    }
-                }
-                override fun onServiceDisconnected(name: ComponentName) {
-                    service = null
-                }
-            }
-
-            if (!context.bindService(Intent(context, Settings::class.java), serviceConn, Context.BIND_AUTO_CREATE or Context.BIND_IMPORTANT))
-                return null
-
-            synchronized(serviceLock) {
-                if (service == null)
-                    try {
-                        serviceLock.wait()
-                    } catch(e: InterruptedException) {
-                    }
-
-                if (service == null) {
-                    try {
-                        context.unbindService(serviceConn)
-                    } catch (e: IllegalArgumentException) {
-                    }
-                    return null
-                }
-            }
-
-            return Stub(service!!, context, serviceConn)
-        }
-
-    }
-
-}

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

@@ -1,120 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.settings
-
-import android.content.Context
-import android.content.Context.MODE_PRIVATE
-import android.content.SharedPreferences
-import android.preference.PreferenceManager
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.ServiceDB
-
-class SharedPreferencesProvider(
-        context: Context
-): Provider {
-
-    companion object {
-        private val META_VERSION = "version"
-        private 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()
-        }
-    }
-
-    override fun close() {
-    }
-
-    override fun forceReload() {
-    }
-
-
-    override fun has(key: String) =
-            Pair(preferences.contains(key), true)
-
-    private fun<T> getValue(key: String, reader: (SharedPreferences) -> T): Pair<T?, Boolean> {
-        if (preferences.contains(key))
-            return Pair(
-                    try { reader(preferences) } catch(e: ClassCastException) { null },
-                    true)
-
-        return Pair(null, true)
-    }
-
-    override fun getBoolean(key: String): Pair<Boolean?, Boolean> =
-            getValue(key, { preferences -> preferences.getBoolean(key, /* will never be used: */ false) })
-
-    override fun getInt(key: String): Pair<Int?, Boolean> =
-            getValue(key, { preferences -> preferences.getInt(key, /* will never be used: */ -1) })
-
-    override fun getLong(key: String): Pair<Long?, Boolean> =
-            getValue(key, { preferences -> preferences.getLong(key, /* will never be used: */ -1) })
-
-    override fun getString(key: String): Pair<String?, Boolean> =
-            getValue(key, { preferences -> preferences.getString(key, /* will never be used: */ null) })
-
-
-    override fun isWritable(key: String) =
-            Pair(true, true)
-
-    private fun<T> putValue(key: String, value: T?, writer: (SharedPreferences.Editor, T) -> Unit): Boolean {
-        if (value == null)
-            return remove(key)
-        else {
-            Logger.log.fine("Writing setting $key = $value")
-            val edit = preferences.edit()
-            writer(edit, value)
-            edit.apply()
-            return true
-        }
-    }
-
-    override fun putBoolean(key: String, value: Boolean?) =
-            putValue(key, value, { editor, v -> editor.putBoolean(key, v) })
-
-    override fun putInt(key: String, value: Int?) =
-            putValue(key, value, { editor, v -> editor.putInt(key, v) })
-
-    override fun putLong(key: String, value: Long?) =
-            putValue(key, value, { editor, v -> editor.putLong(key, v) })
-
-    override fun putString(key: String, value: String?) =
-            putValue(key, value, { editor, v -> editor.putString(key, v) })
-
-    override fun remove(key: String): Boolean {
-        Logger.log.fine("Removing setting $key")
-        preferences.edit()
-                .remove(key)
-                .apply()
-        return true
-    }
-
-
-    private fun firstCall(context: Context) {
-        // remove possible artifacts from DAVdroid <1.9
-        val edit = preferences.edit()
-        edit.remove("override_proxy")
-        edit.remove("proxy_host")
-        edit.remove("proxy_port")
-        edit.remove("log_to_external_storage")
-        edit.apply()
-
-        // open ServiceDB to upgrade it and possibly migrate settings
-        ServiceDB.OpenHelper(context).use { it.readableDatabase }
-    }
-
-}

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

@@ -1,117 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.*
-import android.app.Service
-import android.content.Context
-import android.content.Intent
-import android.database.DatabaseUtils
-import android.os.Bundle
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.ServiceDB
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.ui.setup.LoginActivity
-import at.bitfire.vcard4android.ContactsStorageException
-import java.util.*
-import java.util.logging.Level
-
-
-/**
- * Account authenticator for the main DAVdroid account type.
- *
- * Gets started when a DAVdroid account is removed, too, so it also watches for account removals
- * and contains the corresponding cleanup code.
- */
-class AccountAuthenticatorService: Service(), OnAccountsUpdateListener {
-
-    companion object {
-
-        fun cleanupAccounts(context: Context) {
-            Logger.log.info("Cleaning up orphaned accounts")
-
-            ServiceDB.OpenHelper(context).use { dbHelper ->
-                val db = dbHelper.writableDatabase
-
-                val sqlAccountNames = LinkedList<String>()
-                val accountNames = HashSet<String>()
-                val accountManager = AccountManager.get(context)
-                for (account in accountManager.getAccountsByType(context.getString(R.string.account_type))) {
-                    sqlAccountNames.add(DatabaseUtils.sqlEscapeString(account.name))
-                    accountNames += account.name
-                }
-
-                // delete orphaned address book accounts
-                accountManager.getAccountsByType(context.getString(R.string.account_type_address_book))
-                        .map { LocalAddressBook(context, it, null) }
-                        .forEach {
-                            try {
-                                if (!accountNames.contains(it.getMainAccount().name))
-                                    it.delete()
-                            } catch(e: ContactsStorageException) {
-                                Logger.log.log(Level.SEVERE, "Couldn't get address book main account", e)
-                            }
-                        }
-
-                // delete orphaned services in DB
-                if (sqlAccountNames.isEmpty())
-                    db.delete(ServiceDB.Services._TABLE, null, null)
-                else
-                    db.delete(ServiceDB.Services._TABLE, "${ServiceDB.Services.ACCOUNT_NAME} NOT IN (${sqlAccountNames.joinToString(",")})", null)
-            }
-        }
-
-    }
-
-
-    private lateinit var accountManager: AccountManager
-    private lateinit var accountAuthenticator: AccountAuthenticator
-
-    override fun onCreate() {
-        accountManager = AccountManager.get(this)
-        accountManager.addOnAccountsUpdatedListener(this, null, true)
-
-        accountAuthenticator = AccountAuthenticator(this)
-    }
-
-    override fun onDestroy() {
-        super.onDestroy()
-        accountManager.removeOnAccountsUpdatedListener(this)
-    }
-
-    override fun onBind(intent: Intent?) =
-            accountAuthenticator.iBinder.takeIf { intent?.action == android.accounts.AccountManager.ACTION_AUTHENTICATOR_INTENT }
-
-
-    override fun onAccountsUpdated(accounts: Array<out Account>?) {
-        cleanupAccounts(this)
-    }
-
-
-    private class AccountAuthenticator(
-            val context: Context
-    ): AbstractAccountAuthenticator(context) {
-
-        override fun addAccount(response: AccountAuthenticatorResponse?, accountType: String?, authTokenType: String?, requiredFeatures: Array<String>?, options: Bundle?): Bundle {
-            val intent = Intent(context, LoginActivity::class.java)
-            intent.putExtra(AccountManager.KEY_ACCOUNT_AUTHENTICATOR_RESPONSE, response)
-            val bundle = Bundle(1)
-            bundle.putParcelable(AccountManager.KEY_INTENT, intent)
-            return bundle
-        }
-
-        override fun editProperties(response: AccountAuthenticatorResponse?, accountType: String?)  = null
-        override fun getAuthTokenLabel(p0: String?) = null
-        override fun confirmCredentials(p0: AccountAuthenticatorResponse?, p1: Account?, p2: Bundle?) = null
-        override fun updateCredentials(p0: AccountAuthenticatorResponse?, p1: Account?, p2: String?, p3: Bundle?) = null
-        override fun getAuthToken(p0: AccountAuthenticatorResponse?, p1: Account?, p2: String?, p3: Bundle?) = null
-        override fun hasFeatures(p0: AccountAuthenticatorResponse?, p1: Account?, p2: Array<out String>?) = null
-
-    }
-}

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

@@ -1,24 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.content.ContentProvider
-import android.content.ContentValues
-import android.net.Uri
-
-class AddressBookProvider: ContentProvider() {
-
-    override fun onCreate() = false
-    override fun insert(p0: Uri?, p1: ContentValues?) = null
-    override fun query(p0: Uri?, p1: Array<out String>?, p2: String?, p3: Array<out String>?, p4: String?) = null
-    override fun update(p0: Uri?, p1: ContentValues?, p2: String?, p3: Array<out String>?) = 0
-    override fun delete(p0: Uri?, p1: String?, p2: Array<out String>?) = 0
-    override fun getType(p0: Uri?) = null
-
-}

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

@@ -1,135 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.accounts.AccountManager
-import android.content.*
-import android.database.DatabaseUtils
-import android.os.Bundle
-import android.provider.ContactsContract
-import at.bitfire.davdroid.AccountSettings
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.davdroid.model.ServiceDB
-import at.bitfire.davdroid.model.ServiceDB.Collections
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.vcard4android.ContactsStorageException
-import java.util.logging.Level
-
-class AddressBooksSyncAdapterService: SyncAdapterService() {
-
-    override fun syncAdapter() = AddressBooksSyncAdapter(this)
-
-
-	protected class AddressBooksSyncAdapter(
-            context: Context
-    ): SyncAdapter(context) {
-
-        override fun sync(settings: ISettings, account: Account, extras: Bundle, authority: String, addressBooksProvider: ContentProviderClient, syncResult: SyncResult) {
-            val contactsProvider = context.contentResolver.acquireContentProviderClient(ContactsContract.AUTHORITY)
-            if (contactsProvider == null) {
-                Logger.log.severe("Couldn't access contacts provider")
-                syncResult.databaseError = true
-                return
-            }
-
-            try {
-                val accountSettings = AccountSettings(context, settings, account)
-
-                /* don't run sync if
-                   - sync conditions (e.g. "sync only in WiFi") are not met AND
-                   - this is is an automatic sync (i.e. manual syncs are run regardless of sync conditions)
-                 */
-                if (!extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL) && !checkSyncConditions(accountSettings))
-                    return
-
-                updateLocalAddressBooks(contactsProvider, account)
-
-                val accountManager = AccountManager.get(context)
-                for (addressBookAccount in accountManager.getAccountsByType(context.getString(R.string.account_type_address_book))) {
-                    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(provider: ContentProviderClient, account: Account) {
-            ServiceDB.OpenHelper(context).use { dbHelper ->
-                val db = dbHelper.readableDatabase
-
-                fun getService() =
-                        db.query(ServiceDB.Services._TABLE, arrayOf(ServiceDB.Services.ID),
-                            "${ServiceDB.Services.ACCOUNT_NAME}=? AND ${ServiceDB.Services.SERVICE}=?",
-                            arrayOf(account.name, ServiceDB.Services.SERVICE_CARDDAV), null, null, null)?.use { c ->
-                            if (c.moveToNext())
-                                c.getLong(0)
-                            else
-                                null
-                        }
-
-                fun remoteAddressBooks(service: Long?): MutableMap<String, CollectionInfo> {
-                    val collections = mutableMapOf<String, CollectionInfo>()
-                    service?.let {
-                        db.query(Collections._TABLE, null,
-                            Collections.SERVICE_ID + "=? AND " + Collections.SYNC, arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                            while (cursor.moveToNext()) {
-                                val values = ContentValues(cursor.columnCount)
-                                DatabaseUtils.cursorRowToContentValues(cursor, values)
-                                val info = CollectionInfo(values)
-                                collections[info.url] = info
-                            }
-                        }
-                    }
-                    return collections
-                }
-
-                // enumerate remote and local address books
-                val service = getService()
-                val remote = remoteAddressBooks(service)
-
-                // delete/update local address books
-                for (addressBook in LocalAddressBook.find(context, provider, account)) {
-                    val url = addressBook.getURL()
-                    val info = remote[url]
-                    if (info == null) {
-                        Logger.log.log(Level.INFO, "Deleting obsolete local address book", url)
-                        addressBook.delete()
-                    } else {
-                        // remote CollectionInfo found for this local collection, update data
-                        try {
-                            Logger.log.log(Level.FINE, "Updating local address book $url", info)
-                            addressBook.update(info)
-                        } catch(e: ContactsStorageException) {
-                            Logger.log.log(Level.WARNING, "Couldn't rename address book account", e)
-                        }
-                        // we already have a local address book for this remote collection, don't take into consideration anymore
-                        remote -= url
-                    }
-                }
-
-                // create new local address books
-                for ((_, info) in remote) {
-                    Logger.log.log(Level.INFO, "Adding local address book", info)
-                    LocalAddressBook.create(context, provider, account, info)
-                }
-            }
-        }
-
-    }
-
-}

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

@@ -1,210 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.content.ContentProviderClient
-import android.content.Context
-import android.content.SyncResult
-import android.os.Bundle
-import at.bitfire.dav4android.DavCalendar
-import at.bitfire.dav4android.exception.DavException
-import at.bitfire.dav4android.property.CalendarData
-import at.bitfire.dav4android.property.GetCTag
-import at.bitfire.dav4android.property.GetETag
-import at.bitfire.davdroid.AccountSettings
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalCalendar
-import at.bitfire.davdroid.resource.LocalEvent
-import at.bitfire.davdroid.resource.LocalResource
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.ical4android.Event
-import at.bitfire.ical4android.InvalidCalendarException
-import okhttp3.HttpUrl
-import okhttp3.RequestBody
-import org.apache.commons.collections4.ListUtils
-import java.io.ByteArrayOutputStream
-import java.io.Reader
-import java.io.StringReader
-import java.util.*
-import java.util.logging.Level
-
-/**
- * Synchronization manager for CalDAV collections; handles events ({@code VEVENT}).
- */
-class CalendarSyncManager(
-        context: Context,
-        settings: ISettings,
-        account: Account,
-        accountSettings: AccountSettings,
-        extras: Bundle,
-        authority: String,
-        syncResult: SyncResult,
-        val provider: ContentProviderClient,
-        val localCalendar: LocalCalendar
-): SyncManager(context, settings, account, accountSettings, extras, authority, syncResult, "calendar/${localCalendar.id}") {
-
-    companion object {
-        private val MAX_MULTIGET = 20
-    }
-
-    init {
-        localCollection = localCalendar
-    }
-
-    override fun notificationId() = Constants.NOTIFICATION_CALENDAR_SYNC
-
-    override fun getSyncErrorTitle() = context.getString(R.string.sync_error_calendar, account.name)!!
-
-
-    override fun prepare(): Boolean {
-        collectionURL = HttpUrl.parse(localCalendar.name ?: return false) ?: return false
-        davCollection = DavCalendar(httpClient.okHttpClient, collectionURL)
-        return true
-    }
-
-    override fun queryCapabilities() {
-        davCollection.propfind(0, GetCTag.NAME)
-    }
-
-    override fun prepareDirty() {
-        super.prepareDirty()
-        localCalendar.processDirtyExceptions()
-    }
-
-    override fun prepareUpload(resource: LocalResource): RequestBody {
-        if (resource is LocalEvent) {
-            val event = requireNotNull(resource.event)
-            Logger.log.log(Level.FINE, "Preparing upload of event ${resource.fileName}", event)
-
-            val os = ByteArrayOutputStream()
-            event.write(os)
-
-            return RequestBody.create(
-                    DavCalendar.MIME_ICALENDAR,
-                    os.toByteArray()
-            )
-        } else
-            throw IllegalArgumentException("resource must be a LocalEvent")
-    }
-
-    override fun listRemote() {
-        // 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
-        }
-
-        // fetch list of remote VEVENTs and build hash table to index file name
-        val calendar = davCalendar()
-        currentDavResource = calendar
-        calendar.calendarQuery("VEVENT", limitStart, null)
-
-        remoteResources = HashMap(davCollection.members.size)
-        for (iCal in davCollection.members) {
-            val fileName = iCal.fileName()
-            Logger.log.fine("Found remote VEVENT: $fileName")
-            remoteResources[fileName] = iCal
-        }
-
-        currentDavResource = null
-    }
-
-    override fun downloadRemote() {
-        Logger.log.info("Downloading ${toDownload.size} events ($MAX_MULTIGET at once)")
-
-        // download new/updated iCalendars from server
-        for (bunch in ListUtils.partition(toDownload.toList(), MAX_MULTIGET)) {
-            abortIfCancelled()
-            Logger.log.info("Downloading ${bunch.joinToString(", ")}")
-
-            if (bunch.size == 1) {
-                // only one contact, use GET
-                val remote = bunch.first()
-                currentDavResource = remote
-
-                val body = remote.get("text/calendar")
-
-                // CalDAV servers MUST return ETag on GET [https://tools.ietf.org/html/rfc4791#section-5.3.4]
-                val eTag = remote.properties[GetETag::class.java]
-                if (eTag == null || eTag.eTag.isNullOrEmpty())
-                    throw DavException("Received CalDAV GET response without ETag for ${remote.location}")
-
-                body.charStream()?.use { reader ->
-                    processVEvent(remote.fileName(), eTag.eTag!!, reader)
-                }
-
-            } else {
-                // multiple contacts, use multi-get
-                val calendar = davCalendar()
-                currentDavResource = calendar
-                calendar.multiget(bunch.map { it.location })
-
-                // process multiget results
-                for (remote in davCollection.members) {
-                    currentDavResource = remote
-
-                    val eTag = remote.properties[GetETag::class.java]?.eTag
-                            ?: throw DavException("Received multi-get response without ETag")
-
-                    val calendarData = remote.properties[CalendarData::class.java]
-                    val iCalendar = calendarData?.iCalendar
-                            ?: throw DavException("Received multi-get response without event data")
-
-                    processVEvent(remote.fileName(), eTag, StringReader(iCalendar))
-                }
-            }
-
-            currentDavResource = null
-        }
-    }
-
-
-    // helpers
-
-    private fun davCalendar() = davCollection as DavCalendar
-
-    private fun processVEvent(fileName: String, eTag: String, reader: Reader) {
-        val events: List<Event>
-        try {
-            events = Event.fromReader(reader)
-        } catch (e: InvalidCalendarException) {
-            Logger.log.log(Level.SEVERE, "Received invalid iCalendar, ignoring", e)
-            return
-        }
-
-        if (events.size == 1) {
-            val newData = events.first()
-
-            // delete local event, if it exists
-            val localEvent = localResources[fileName] as LocalEvent?
-            currentLocalResource = localEvent
-            if (localEvent != null) {
-                Logger.log.info("Updating $fileName in local calendar")
-                localEvent.eTag = eTag
-                localEvent.update(newData)
-                syncResult.stats.numUpdates++
-            } else {
-                Logger.log.info("Adding $fileName to local calendar")
-                val newEvent = LocalEvent(localCalendar, newData, fileName, eTag)
-                currentLocalResource = newEvent
-                newEvent.add()
-                syncResult.stats.numInserts++
-            }
-        } else
-            Logger.log.severe("Received VCALENDAR with not exactly one VEVENT with UID, but without RECURRENCE-ID; ignoring $fileName")
-
-        currentLocalResource = null
-    }
-
-}

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

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

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

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

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

@@ -1,508 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.content.*
-import android.os.Build
-import android.os.Bundle
-import android.os.RemoteException
-import android.provider.ContactsContract.Groups
-import android.support.v4.app.NotificationCompat
-import at.bitfire.dav4android.DavAddressBook
-import at.bitfire.dav4android.exception.DavException
-import at.bitfire.dav4android.property.*
-import at.bitfire.davdroid.*
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalAddressBook
-import at.bitfire.davdroid.resource.LocalContact
-import at.bitfire.davdroid.resource.LocalGroup
-import at.bitfire.davdroid.resource.LocalResource
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.vcard4android.BatchOperation
-import at.bitfire.vcard4android.Contact
-import at.bitfire.vcard4android.ContactsStorageException
-import at.bitfire.vcard4android.GroupMethod
-import ezvcard.VCardVersion
-import okhttp3.HttpUrl
-import okhttp3.Request
-import okhttp3.RequestBody
-import org.apache.commons.collections4.ListUtils
-import java.io.*
-import java.util.*
-import java.util.logging.Level
-
-/**
- * Synchronization manager for CardDAV collections; handles contacts and groups.
- *
- * Group handling differs according to the {@link #groupMethod}. There are two basic methods to
- * handle/manage groups:
- *
- *     1. CATEGORIES: groups memberships are attached to each contact and represented as
- *     "category". When a group is dirty or has been deleted, all its members have to be set to
- *     dirty, too (because they have to be uploaded without the respective category). This
- *     is done in [prepareDirty]. Empty groups can be deleted without further processing,
- *     which is done in [postProcess] because groups may become empty after downloading
- *     updated remote contacts.
- *
- *     2. Groups as separate VCards: individual and group contacts (with a list of member UIDs) are
- *     distinguished. When a local group is dirty, its members don't need to be set to dirty.
- *
- *         * However, when a contact is dirty, it has
- *         to be checked whether its group memberships have changed. In this case, the respective
- *         groups have to be set to dirty. For instance, if contact A is in group G and H, and then
- *         group membership of G is removed, the contact will be set to dirty because of the changed
- *         [android.provider.ContactsContract.CommonDataKinds.GroupMembership]. DAVdroid will
- *         then have to check whether the group memberships have actually changed, and if so,
- *         all affected groups have to be set to dirty. To detect changes in group memberships,
- *         DAVdroid always mirrors all [android.provider.ContactsContract.CommonDataKinds.GroupMembership]
- *         data rows in respective [at.bitfire.vcard4android.CachedGroupMembership] rows.
- *         If the cached group memberships are not the same as the current group member ships, the
- *         difference set (in our example G, because its in the cached memberships, but not in the
- *         actual ones) is marked as dirty. This is done in [prepareDirty].
- *
- *         * When downloading remote contacts, groups (+ member information) may be received
- *         by the actual members. Thus, the member lists have to be cached until all VCards
- *         are received. This is done by caching the member UIDs of each group in
- *         [LocalGroup.COLUMN_PENDING_MEMBERS]. In [postProcess],
- *         these "pending memberships" are assigned to the actual contacts and then cleaned up.
- */
-class ContactsSyncManager(
-        context: Context,
-        settings: ISettings,
-        account: Account,
-        accountSettings: AccountSettings,
-        extras: Bundle,
-        authority: String,
-        syncResult: SyncResult,
-        val provider: ContentProviderClient,
-        private val localAddressBook: LocalAddressBook
-): SyncManager(context, settings, account, accountSettings, extras, authority, syncResult, "addressBook") {
-
-    companion object {
-        private val MAX_MULTIGET = 10
-    }
-
-    private val readOnly = localAddressBook.getReadOnly()
-    private var numDiscarded = 0
-
-    private var hasVCard4 = false
-    private val groupMethod = accountSettings.getGroupMethod()
-
-
-    init {
-        localCollection = localAddressBook
-    }
-
-    override fun notificationId() = Constants.NOTIFICATION_CONTACTS_SYNC
-
-    override fun getSyncErrorTitle() = context.getString(R.string.sync_error_contacts, account.name)!!
-
-
-    override fun prepare(): Boolean {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
-            // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
-            val reallyDirty = localAddressBook.verifyDirty()
-            val deleted = localAddressBook.getDeleted().size
-            if (extras.containsKey(ContentResolver.SYNC_EXTRAS_UPLOAD) && reallyDirty == 0 && deleted == 0) {
-                Logger.log.info("This sync was called to up-sync dirty/deleted contacts, but no contacts have been changed")
-                return false
-            }
-        }
-
-        collectionURL = HttpUrl.parse(localAddressBook.getURL()) ?: return false
-        davCollection = DavAddressBook(httpClient.okHttpClient, collectionURL)
-
-        return true
-    }
-
-    override fun queryCapabilities() {
-        // prepare remote address book
-        davCollection.propfind(0, SupportedAddressData.NAME, GetCTag.NAME)
-
-        val properties = davCollection.properties
-        properties[SupportedAddressData::class.java]?.let {
-            hasVCard4 = it.hasVCard4()
-        }
-        Logger.log.info("Server advertises VCard/4 support: $hasVCard4")
-
-        Logger.log.info("Contact group method: $groupMethod")
-        // in case of GROUP_VCARDs, treat groups as contacts in the local address book
-        localAddressBook.includeGroups = groupMethod == GroupMethod.GROUP_VCARDS
-    }
-
-    override fun processLocallyDeleted() {
-        if (readOnly) {
-            for (group in localAddressBook.getDeletedGroups()) {
-                Logger.log.warning("Restoring locally deleted group (read-only address book!)")
-                group.resetDeleted()
-                numDiscarded++
-            }
-
-            for (contact in localAddressBook.getDeletedContacts()) {
-                Logger.log.warning("Restoring locally deleted contact (read-only address book!)")
-                contact.resetDeleted()
-                numDiscarded++
-            }
-
-            if (numDiscarded > 0)
-                notifyDiscardedChange()
-        } else
-            // mirror deletions to remote collection (DELETE)
-            super.processLocallyDeleted()
-    }
-
-    override fun prepareDirty() {
-        // generate UID/file name for newly created contacts
-        super.prepareDirty()
-
-        if (readOnly) {
-            for (group in localAddressBook.getDirtyGroups()) {
-                Logger.log.warning("Resetting locally modified group to ETag=null (read-only address book!)")
-                group.clearDirty(null)
-                numDiscarded++
-            }
-
-            for (contact in localAddressBook.getDirtyContacts()) {
-                Logger.log.warning("Resetting locally modified contact to ETag=null (read-only address book!)")
-                contact.clearDirty(null)
-                numDiscarded++
-            }
-
-            if (numDiscarded > 0)
-                notifyDiscardedChange()
-
-        } else {
-            if (groupMethod == GroupMethod.CATEGORIES) {
-                /* groups memberships are represented as contact CATEGORIES */
-
-                // groups with DELETED=1: set all members to dirty, then remove group
-                for (group in localAddressBook.getDeletedGroups()) {
-                    Logger.log.fine("Finally removing group $group")
-                    // useless because Android deletes group memberships as soon as a group is set to DELETED:
-                    // group.markMembersDirty()
-                    group.delete()
-                }
-
-                // groups with DIRTY=1: mark all memberships as dirty, then clean DIRTY flag of group
-                for (group in localAddressBook.getDirtyGroups()) {
-                    Logger.log.fine("Marking members of modified group $group as dirty")
-                    group.markMembersDirty()
-                    group.clearDirty(null)
-                }
-            } else {
-                /* groups as separate VCards: there are group contacts and individual contacts */
-
-                // mark groups with changed members as dirty
-                val batch = BatchOperation(localAddressBook.provider!!)
-                for (contact in localAddressBook.getDirtyContacts())
-                    try {
-                        Logger.log.fine("Looking for changed group memberships of contact ${contact.fileName}")
-                        val cachedGroups = contact.getCachedGroupMemberships()
-                        val currentGroups = contact.getGroupMemberships()
-                        for (groupID in cachedGroups disjunct currentGroups) {
-                            Logger.log.fine("Marking group as dirty: $groupID")
-                            batch.enqueue(BatchOperation.Operation(
-                                    ContentProviderOperation.newUpdate(localAddressBook.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, groupID)))
-                                    .withValue(Groups.DIRTY, 1)
-                                    .withYieldAllowed(true)
-                            ))
-                        }
-                    } catch(e: FileNotFoundException) {
-                    }
-                batch.commit()
-            }
-        }
-    }
-
-    private fun notifyDiscardedChange() {
-        val notification = NotificationCompat.Builder(context, NotificationUtils.CHANNEL_SYNC_STATUS)
-                .setSmallIcon(R.drawable.ic_delete_notification)
-                .setLargeIcon(App.getLauncherBitmap(context))
-                .setContentTitle(context.getString(R.string.sync_contacts_read_only_address_book))
-                .setContentText(context.resources.getQuantityString(R.plurals.sync_contacts_local_contact_changes_discarded, numDiscarded, numDiscarded))
-                .setSubText(account.name)
-                .setCategory(NotificationCompat.CATEGORY_ERROR)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .setLocalOnly(true)
-                .setAutoCancel(true)
-                .build()
-        notificationManager.notify("discarded_${account.name}", 0, notification)
-    }
-
-    override fun prepareUpload(resource: LocalResource): RequestBody {
-        val contact: Contact
-        if (resource is LocalContact) {
-            contact = resource.contact!!
-
-            if (groupMethod == GroupMethod.CATEGORIES) {
-                // add groups as CATEGORIES
-                for (groupID in resource.getGroupMemberships()) {
-                    try {
-                        provider.query(
-                                localAddressBook.syncAdapterURI(ContentUris.withAppendedId(Groups.CONTENT_URI, groupID)),
-                                arrayOf(Groups.TITLE), null, null, null
-                        )?.use { cursor ->
-                            if (cursor.moveToNext()) {
-                                val title = cursor.getString(0)
-                                if (!title.isNullOrEmpty())
-                                    contact.categories.add(title)
-                            }
-                        }
-                    } catch(e: RemoteException) {
-                        throw ContactsStorageException("Couldn't find group for adding CATEGORIES", e)
-                    }
-                }
-            }
-        } else if (resource is LocalGroup)
-            contact = resource.contact!!
-        else
-            throw IllegalArgumentException("resource must be a LocalContact or a LocalGroup")
-
-        Logger.log.log(Level.FINE, "Preparing upload of VCard ${resource.fileName}", contact)
-
-        val os = ByteArrayOutputStream()
-        contact.write(if (hasVCard4) VCardVersion.V4_0 else VCardVersion.V3_0, groupMethod, os)
-
-        return RequestBody.create(
-                if (hasVCard4) DavAddressBook.MIME_VCARD4 else DavAddressBook.MIME_VCARD3_UTF8,
-                os.toByteArray()
-        )
-    }
-
-    override fun listRemote() {
-        val addressBook = davAddressBook()
-        currentDavResource = addressBook
-
-        // fetch list of remote VCards and build hash table to index file name
-        addressBook.propfind(1, ResourceType.NAME, GetETag.NAME)
-
-        remoteResources = HashMap(davCollection.members.size)
-        for (vCard in davCollection.members) {
-            // ignore member collections
-            var ignore = false
-            vCard.properties[ResourceType::class.java]?.let { type ->
-                if (type.types.contains(ResourceType.COLLECTION))
-                    ignore = true
-            }
-            if (ignore)
-                continue
-
-            val fileName = vCard.fileName()
-            Logger.log.fine("Found remote VCard: $fileName")
-            remoteResources[fileName] = vCard
-        }
-
-        currentDavResource = null
-    }
-
-    override fun downloadRemote() {
-        Logger.log.info("Downloading ${toDownload.size} contacts ($MAX_MULTIGET at once)")
-
-        // prepare downloader which may be used to download external resource like contact photos
-        val downloader = ResourceDownloader(collectionURL)
-
-        // download new/updated VCards from server
-        for (bunch in ListUtils.partition(toDownload.toList(), MAX_MULTIGET)) {
-            abortIfCancelled()
-            Logger.log.info("Downloading ${bunch.joinToString(", ")}")
-
-            if (bunch.size == 1) {
-                // only one contact, use GET
-                val remote = bunch.first()
-                currentDavResource = remote
-
-                val body = remote.get("text/vcard;version=4.0, text/vcard;charset=utf-8;q=0.8, text/vcard;q=0.5")
-
-                // CardDAV servers MUST return ETag on GET [https://tools.ietf.org/html/rfc6352#section-6.3.2.3]
-                val eTag = remote.properties[GetETag::class.java]
-                if (eTag == null || eTag.eTag.isNullOrEmpty())
-                    throw DavException("Received CardDAV GET response without ETag for ${remote.location}")
-
-                body.charStream().use { reader ->
-                    processVCard(remote.fileName(), eTag.eTag!!, reader, downloader)
-                }
-
-            } else {
-                // multiple contacts, use multi-get
-                val addressBook = davAddressBook()
-                currentDavResource = addressBook
-                addressBook.multiget(bunch.map { it.location }, hasVCard4)
-
-                // process multi-get results
-                for (remote in davCollection.members) {
-                    currentDavResource = remote
-
-                    val eTag = remote.properties[GetETag::class.java]?.eTag
-                            ?: throw DavException("Received multi-get response without ETag")
-
-                    val addressData = remote.properties[AddressData::class.java]
-                    val vCard = addressData?.vCard
-                            ?: throw DavException("Received multi-get response without address data")
-
-                    processVCard(remote.fileName(), eTag, StringReader(vCard), downloader)
-                }
-            }
-
-            currentDavResource = null
-        }
-    }
-
-    override fun postProcess() {
-        if (groupMethod == GroupMethod.CATEGORIES) {
-            /* VCard3 group handling: groups memberships are represented as contact CATEGORIES */
-
-            // remove empty groups
-            Logger.log.info("Removing empty groups")
-            localAddressBook.removeEmptyGroups()
-
-        } else {
-            /* VCard4 group handling: there are group contacts and individual contacts */
-            Logger.log.info("Assigning memberships of downloaded contact groups")
-            LocalGroup.applyPendingMemberships(localAddressBook)
-        }
-    }
-
-
-    // helpers
-
-    private fun davAddressBook() = davCollection as DavAddressBook
-
-    private fun processVCard(fileName: String, eTag: String, reader: Reader, downloader: Contact.Downloader) {
-        Logger.log.info("Processing CardDAV resource $fileName")
-        val contacts = Contact.fromReader(reader, downloader)
-        if (contacts.isEmpty()) {
-            Logger.log.warning("Received VCard without data, ignoring")
-            return
-        } else if (contacts.size > 1)
-            Logger.log.warning("Received multiple VCards, using first one")
-
-        val newData = contacts.first()
-
-        if (groupMethod == GroupMethod.CATEGORIES && newData.group) {
-            Logger.log.warning("Received group VCard although group method is CATEGORIES. Saving as regular contact")
-            newData.group = false
-        }
-
-        // update local contact, if it exists
-        var local = localResources[fileName]
-        currentLocalResource = local
-        if (local != null) {
-            Logger.log.log(Level.INFO, "Updating $fileName in local address book", newData)
-
-            if (local is LocalGroup && newData.group) {
-                // update group
-                local.eTag = eTag
-                local.updateFromServer(newData)
-                syncResult.stats.numUpdates++
-
-            } else if (local is LocalContact && !newData.group) {
-                // update contact
-                local.eTag = eTag
-                local.update(newData)
-                syncResult.stats.numUpdates++
-
-            } else {
-                // group has become an individual contact or vice versa
-                local.delete()
-                local = null
-            }
-        }
-
-        if (local == null) {
-            if (newData.group) {
-                Logger.log.log(Level.INFO, "Creating local group", newData)
-                val group = LocalGroup(localAddressBook, newData, fileName, eTag)
-                currentLocalResource = group
-                group.create()
-
-                local = group
-            } else {
-                Logger.log.log(Level.INFO, "Creating local contact", newData)
-                val contact = LocalContact(localAddressBook, newData, fileName, eTag)
-                currentLocalResource = contact
-                contact.create()
-
-                local = contact
-            }
-            syncResult.stats.numInserts++
-        }
-
-        if (groupMethod == GroupMethod.CATEGORIES && local is LocalContact) {
-            // VCard3: update group memberships from CATEGORIES
-            currentLocalResource = local
-
-            val batch = BatchOperation(provider)
-            Logger.log.log(Level.FINE, "Removing contact group memberships")
-            local.removeGroupMemberships(batch)
-
-            for (category in local.contact!!.categories) {
-                val groupID = localAddressBook.findOrCreateGroup(category)
-                Logger.log.log(Level.FINE, "Adding membership in group $category ($groupID)")
-                local.addToGroup(batch, groupID)
-            }
-
-            batch.commit()
-        }
-
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && Build.VERSION.SDK_INT < Build.VERSION_CODES.O && local is LocalContact)
-            // workaround for Android 7 which sets DIRTY flag when only meta-data is changed
-            local.updateHashCode(null)
-
-        currentLocalResource = null
-    }
-
-
-    // downloader helper class
-
-    private inner class ResourceDownloader(
-            val baseUrl: HttpUrl
-    ): Contact.Downloader {
-
-        override fun download(url: String, accepts: String): ByteArray? {
-            val httpUrl = HttpUrl.parse(url)
-            if (httpUrl == null) {
-                Logger.log.log(Level.SEVERE, "Invalid external resource URL", url)
-                return null
-            }
-
-            val host = httpUrl.host()
-            if (host == null) {
-                Logger.log.log(Level.SEVERE, "External resource URL doesn't specify a host name", url)
-                return null
-            }
-
-            // authenticate only against a certain host, and only upon request
-            val builder = HttpClient.Builder(context, baseUrl.host(), accountSettings.credentials())
-
-            // allow redirects
-            builder.followRedirects(true)
-
-            val client = builder.build()
-            try {
-                val response = client.okHttpClient.newCall(Request.Builder()
-                        .get()
-                        .url(httpUrl)
-                        .build()).execute()
-
-                if (response.isSuccessful)
-                    return response.body()?.bytes()
-                else
-                    Logger.log.warning("Couldn't download external resource")
-            } catch(e: IOException) {
-                Logger.log.log(Level.SEVERE, "Couldn't download external resource", e)
-            } finally {
-                client.close()
-            }
-            return null
-        }
-    }
-
-}

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

@@ -1,120 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.app.PendingIntent
-import android.app.Service
-import android.content.*
-import android.net.ConnectivityManager
-import android.net.wifi.WifiManager
-import android.os.Bundle
-import android.support.v4.app.NotificationCompat
-import at.bitfire.davdroid.AccountSettings
-import at.bitfire.davdroid.App
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.davdroid.settings.Settings
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.davdroid.ui.PermissionsActivity
-import java.util.*
-import java.util.logging.Level
-
-abstract class SyncAdapterService: Service() {
-
-    companion object {
-        val runningSyncs = Collections.synchronizedSet(mutableSetOf<Pair<String, Account>>())!!
-    }
-
-    abstract protected fun syncAdapter(): AbstractThreadedSyncAdapter
-
-    override fun onBind(intent: Intent?) = syncAdapter().syncAdapterBinder!!
-
-
-    abstract class SyncAdapter(
-            context: Context
-    ): AbstractThreadedSyncAdapter(context, false) {
-
-        abstract fun sync(settings: ISettings, account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult)
-
-        override fun onPerformSync(account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
-            Logger.log.log(Level.INFO, "$authority sync of $account has been initiated", extras.keySet().joinToString(", "))
-
-            // prevent multiple syncs of the same authority to be run for the same account
-            val currentSync = Pair(authority, account)
-            if (!runningSyncs.add(currentSync)) {
-                Logger.log.warning("There's already another $authority sync running for $account, aborting")
-                return
-            }
-
-            try {
-                // required for dav4android (ServiceLoader)
-                Thread.currentThread().contextClassLoader = context.classLoader
-
-                // load app settings
-                Settings.getInstance(context).use { settings ->
-                    if (settings == null) {
-                        syncResult.databaseError = true
-                        Logger.log.severe("Couldn't connect to Settings service, aborting sync")
-                        return
-                    }
-
-                    sync(settings, account, extras, authority, provider, syncResult)
-                }
-                Logger.log.info("Sync for $authority complete")
-            } finally {
-                runningSyncs -= currentSync
-            }
-        }
-
-        override fun onSecurityException(account: Account, extras: Bundle, authority: String, syncResult: SyncResult) {
-            Logger.log.log(Level.WARNING, "Security exception when opening content provider for $authority")
-            syncResult.databaseError = true
-
-            val intent = Intent(context, PermissionsActivity::class.java)
-            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-
-            val notify = NotificationCompat.Builder(context, NotificationUtils.CHANNEL_SYNC_PROBLEMS)
-                    .setSmallIcon(R.drawable.ic_sync_error_notification)
-                    .setLargeIcon(App.getLauncherBitmap(context))
-                    .setContentTitle(context.getString(R.string.sync_error_permissions))
-                    .setContentText(context.getString(R.string.sync_error_permissions_text))
-                    .setContentIntent(PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT))
-                    .setCategory(NotificationCompat.CATEGORY_ERROR)
-                    .build()
-            val nm = NotificationUtils.createChannels(context)
-            nm.notify(Constants.NOTIFICATION_PERMISSIONS, notify)
-        }
-
-        protected fun checkSyncConditions(settings: AccountSettings): Boolean {
-            if (settings.getSyncWifiOnly()) {
-                val connectivityManager = context.getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
-                val network = connectivityManager.activeNetworkInfo
-                if (network == null || network.type != ConnectivityManager.TYPE_WIFI || !network.isConnected) {
-                    Logger.log.info("Not on connected WiFi, stopping")
-                    return false
-                }
-
-                settings.getSyncWifiOnlySSIDs()?.let { onlySSIDs ->
-                    val wifi = context.applicationContext.getSystemService(WIFI_SERVICE) as WifiManager
-                    val info = wifi.connectionInfo
-                    if (info == null || !onlySSIDs.contains(info.ssid.trim('"'))) {
-                        Logger.log.info("Connected to wrong WiFi network (${info.ssid}), ignoring")
-                        return false
-                    }
-                }
-            }
-            return true
-        }
-
-    }
-
-}

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

@@ -1,494 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.app.PendingIntent
-import android.content.ContentResolver
-import android.content.Context
-import android.content.Intent
-import android.content.SyncResult
-import android.net.Uri
-import android.os.Bundle
-import android.support.v4.app.NotificationCompat
-import at.bitfire.dav4android.DavResource
-import at.bitfire.dav4android.exception.*
-import at.bitfire.dav4android.property.GetCTag
-import at.bitfire.dav4android.property.GetETag
-import at.bitfire.davdroid.*
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalCollection
-import at.bitfire.davdroid.resource.LocalResource
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.davdroid.ui.AccountSettingsActivity
-import at.bitfire.davdroid.ui.DebugInfoActivity
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.ical4android.CalendarStorageException
-import at.bitfire.vcard4android.ContactsStorageException
-import okhttp3.HttpUrl
-import okhttp3.RequestBody
-import java.io.Closeable
-import java.io.IOException
-import java.io.InterruptedIOException
-import java.security.cert.CertificateException
-import java.util.*
-import java.util.logging.Level
-import javax.net.ssl.SSLHandshakeException
-
-abstract class SyncManager(
-        val context: Context,
-        val settings: ISettings,
-        val account: Account,
-        val accountSettings: AccountSettings,
-        val extras: Bundle,
-        val authority: String,
-        val syncResult: SyncResult,
-        val uniqueCollectionId: String
-): Closeable {
-
-    companion object {
-
-        val SYNC_PHASE_PREPARE = 0
-        val SYNC_PHASE_QUERY_CAPABILITIES = 1
-        val SYNC_PHASE_PROCESS_LOCALLY_DELETED = 2
-        val SYNC_PHASE_PREPARE_DIRTY = 3
-        val SYNC_PHASE_UPLOAD_DIRTY = 4
-        val SYNC_PHASE_CHECK_SYNC_STATE = 5
-        val SYNC_PHASE_LIST_LOCAL = 6
-        val SYNC_PHASE_LIST_REMOTE = 7
-        val SYNC_PHASE_COMPARE_LOCAL_REMOTE = 8
-        val SYNC_PHASE_DOWNLOAD_REMOTE = 9
-        val SYNC_PHASE_POST_PROCESSING = 10
-        val SYNC_PHASE_SAVE_SYNC_STATE = 11
-
-        infix fun <T> Set<T>.disjunct(other: Set<T>) = (this - other) union (other - this)
-
-    }
-
-    protected val notificationManager = NotificationUtils.createChannels(context)
-
-    protected lateinit var localCollection: LocalCollection<*>
-
-    protected val httpClient = HttpClient.Builder(context, settings, accountSettings).build()
-    protected lateinit var collectionURL: HttpUrl
-    protected lateinit var davCollection: DavResource
-
-
-    /** current sync phase */
-    private var syncPhase: Int = SYNC_PHASE_PREPARE
-
-    /** state information for debug info (local resource) */
-    protected var currentLocalResource: LocalResource? = null
-
-    /** state information for debug info (remote resource) */
-    protected var currentDavResource: DavResource? = null
-
-
-    /** remote CTag at the time of {@link #listRemote()} */
-    protected var remoteCTag: String? = null
-
-    /** sync-able resources in the local collection, as enumerated by {@link #listLocal()} */
-    protected lateinit var localResources: MutableMap<String, LocalResource>
-
-    /** sync-able resources in the remote collection, as enumerated by {@link #listRemote()} */
-    protected lateinit var remoteResources: MutableMap<String, DavResource>
-
-    /** resources which have changed on the server, as determined by {@link #compareLocalRemote()} */
-    protected val toDownload = mutableSetOf<DavResource>()
-
-
-    protected abstract fun notificationId(): Int
-    protected abstract fun getSyncErrorTitle(): String
-
-    @Suppress("UNUSED_VALUE")
-    fun performSync() {
-        // dismiss previous error notifications
-        notificationManager.cancel(uniqueCollectionId, notificationId())
-
-        try {
-            Logger.log.info("Preparing synchronization")
-            if (!prepare()) {
-                Logger.log.info("No reason to synchronize, aborting")
-                return
-            }
-
-            abortIfCancelled()
-            syncPhase = SYNC_PHASE_QUERY_CAPABILITIES
-            Logger.log.info("Querying capabilities")
-            queryCapabilities()
-
-            syncPhase = SYNC_PHASE_PROCESS_LOCALLY_DELETED
-            Logger.log.info("Processing locally deleted entries")
-            processLocallyDeleted()
-
-            abortIfCancelled()
-            syncPhase = SYNC_PHASE_PREPARE_DIRTY
-            Logger.log.info("Locally preparing dirty entries")
-            prepareDirty()
-
-            syncPhase = SYNC_PHASE_UPLOAD_DIRTY
-            Logger.log.info("Uploading dirty entries")
-            uploadDirty()
-
-            syncPhase = SYNC_PHASE_CHECK_SYNC_STATE
-            Logger.log.info("Checking sync state")
-            if (checkSyncState()) {
-                syncPhase = SYNC_PHASE_LIST_LOCAL
-                Logger.log.info("Listing local resources")
-                listLocal()
-
-                abortIfCancelled()
-                syncPhase = SYNC_PHASE_LIST_REMOTE
-                Logger.log.info("Listing remote resources")
-                listRemote()
-
-                abortIfCancelled()
-                syncPhase = SYNC_PHASE_COMPARE_LOCAL_REMOTE
-                Logger.log.info("Comparing local/remote entries")
-                compareLocalRemote()
-
-                syncPhase = SYNC_PHASE_DOWNLOAD_REMOTE
-                Logger.log.info("Downloading remote entries")
-                downloadRemote()
-
-                syncPhase = SYNC_PHASE_POST_PROCESSING
-                Logger.log.info("Post-processing")
-                postProcess()
-
-                syncPhase = SYNC_PHASE_SAVE_SYNC_STATE
-                Logger.log.info("Saving sync state")
-                saveSyncState()
-            } else
-                Logger.log.info("Remote collection didn't change, skipping remote sync")
-
-        } catch (e: InterruptedException) {
-            // re-throw to SyncAdapterService
-            throw e
-        } catch (e: InterruptedIOException) {
-            throw e
-
-        } catch (e: SSLHandshakeException) {
-            Logger.log.log(Level.WARNING, "SSL handshake failed", e)
-
-            // when a certificate is rejected by cert4android, the cause will be a CertificateException
-            if (!BuildConfig.customCerts || e.cause !is CertificateException)
-                notifyException(e)
-        } catch (e: IOException) {
-            Logger.log.log(Level.WARNING, "I/O exception during sync, trying again later", e)
-            syncResult.stats.numIoExceptions++
-        } catch (e: ServiceUnavailableException) {
-            Logger.log.log(Level.WARNING, "Got 503 Service unavailable, trying again later", e)
-            syncResult.stats.numIoExceptions++
-            e.retryAfter?.let { retryAfter ->
-                // how many seconds to wait? getTime() returns ms, so divide by 1000
-                syncResult.delayUntil = (retryAfter.time - Date().time) / 1000
-            }
-        } catch (e: Throwable) {
-            notifyException(e)
-        }
-    }
-
-    private fun notifyException(e: Throwable) {
-        val messageString: Int
-
-        when (e) {
-            is UnauthorizedException -> {
-                Logger.log.log(Level.SEVERE, "Not authorized anymore", e)
-                messageString = R.string.sync_error_unauthorized
-                syncResult.stats.numAuthExceptions++
-            }
-            is HttpException, is DavException -> {
-                Logger.log.log(Level.SEVERE, "HTTP/DAV Exception during sync", e)
-                messageString = R.string.sync_error_http_dav
-                syncResult.stats.numParseExceptions++
-            }
-            is CalendarStorageException, is ContactsStorageException -> {
-                Logger.log.log(Level.SEVERE, "Couldn't access local storage", e)
-                messageString = R.string.sync_error_local_storage
-                syncResult.databaseError = true
-            }
-            else -> {
-                Logger.log.log(Level.SEVERE, "Unknown sync error", e)
-                messageString = R.string.sync_error
-                syncResult.stats.numParseExceptions++
-            }
-        }
-
-        val detailsIntent: Intent
-        if (e is UnauthorizedException) {
-            detailsIntent = Intent(context, AccountSettingsActivity::class.java)
-            detailsIntent.putExtra(AccountSettingsActivity.EXTRA_ACCOUNT, account)
-        } else {
-            detailsIntent = Intent(context, DebugInfoActivity::class.java)
-            detailsIntent.putExtra(DebugInfoActivity.KEY_THROWABLE, e)
-            detailsIntent.putExtra(DebugInfoActivity.KEY_ACCOUNT, account)
-            detailsIntent.putExtra(DebugInfoActivity.KEY_AUTHORITY, authority)
-            detailsIntent.putExtra(DebugInfoActivity.KEY_PHASE, syncPhase)
-            currentLocalResource?.let { detailsIntent.putExtra(DebugInfoActivity.KEY_LOCAL_RESOURCE, it.toString()) }
-            currentDavResource?.let { detailsIntent.putExtra(DebugInfoActivity.KEY_REMOTE_RESOURCE, it.toString()) }
-        }
-
-        // to make the PendingIntent unique
-        detailsIntent.data = Uri.parse("uri://${javaClass.name}/$uniqueCollectionId")
-
-        val builder = NotificationCompat.Builder(context, NotificationUtils.CHANNEL_SYNC_PROBLEMS)
-        builder .setSmallIcon(R.drawable.ic_sync_error_notification)
-                .setLargeIcon(App.getLauncherBitmap(context))
-                .setContentTitle(getSyncErrorTitle())
-                .setContentIntent(PendingIntent.getActivity(context, 0, detailsIntent, PendingIntent.FLAG_CANCEL_CURRENT))
-                .setCategory(NotificationCompat.CATEGORY_ERROR)
-
-        try {
-            val phases = context.resources.getStringArray(R.array.sync_error_phases)
-            val message = context.getString(messageString, phases[syncPhase])
-            builder.setContentText(message)
-        } catch (ex: IndexOutOfBoundsException) {
-            // should never happen
-        }
-
-        notificationManager.notify(uniqueCollectionId, notificationId(), builder.build())
-    }
-
-    /**
-     * Throws an [InterruptedException] if the current thread has been interrupted,
-     * most probably because synchronization was cancelled by the user.
-     * @throws InterruptedException (which will be catched by [performSync])
-     * */
-    protected fun abortIfCancelled() {
-        if (Thread.interrupted())
-            throw InterruptedException("Sync was cancelled")
-    }
-
-    override fun close() {
-        httpClient.close()
-    }
-
-
-    /** Prepares synchronization (for instance, allocates necessary resources).
-     * @return whether actual synchronization is required / can be made. true = synchronization
-     *         shall be continued, false = synchronization can be skipped */
-    abstract protected fun prepare(): Boolean
-
-    abstract protected fun queryCapabilities()
-
-    /**
-     * Process locally deleted entries (DELETE them on the server as well).
-     * Checks Thread.interrupted() before each request to allow quick sync cancellation.
-     */
-    protected open fun processLocallyDeleted() {
-        // Remove locally deleted entries from server (if they have a name, i.e. if they were uploaded before),
-        // but only if they don't have changed on the server. Then finally remove them from the local address book.
-        val localList = localCollection.getDeleted()
-        for (local in localList) {
-            if (Thread.interrupted())
-                return
-
-            currentLocalResource = local
-
-            val fileName = local.fileName
-            if (fileName != null) {
-                Logger.log.info("$fileName has been deleted locally -> deleting from server")
-
-                val remote = DavResource(httpClient.okHttpClient, collectionURL.newBuilder().addPathSegment(fileName).build())
-                currentDavResource = remote
-                try {
-                    remote.delete(local.eTag)
-                } catch (e: HttpException) {
-                    Logger.log.warning("Couldn't delete $fileName from server; ignoring (may be downloaded again)")
-                }
-            } else
-                Logger.log.info("Removing local record #${local.id} which has been deleted locally and was never uploaded")
-            local.delete()
-            syncResult.stats.numDeletes++
-
-            currentLocalResource = null
-            currentDavResource = null
-        }
-    }
-
-    protected open fun prepareDirty() {
-        // assign file names and UIDs to new contacts so that we can use the file name as an index
-        Logger.log.info("Looking for contacts/groups without file name")
-        for (local in localCollection.getWithoutFileName()) {
-            currentLocalResource = local
-
-            Logger.log.fine("Found local record #${local.id} without file name; generating file name/UID if necessary")
-            local.prepareForUpload()
-
-            currentLocalResource = null
-        }
-    }
-
-    abstract protected fun prepareUpload(resource: LocalResource): RequestBody
-
-    /**
-     * Uploads dirty records to the server, using a PUT request for each record.
-     * Checks Thread.interrupted() before each request to allow quick sync cancellation.
-     */
-    protected open fun uploadDirty() {
-        // upload dirty contacts
-        for (local in localCollection.getDirty()) {
-            if (Thread.interrupted())
-                return
-
-            currentLocalResource = local
-            val fileName = local.fileName
-
-            val remote = DavResource(httpClient.okHttpClient, collectionURL.newBuilder().addPathSegment(fileName).build())
-            currentDavResource = remote
-
-            // generate entity to upload (VCard, iCal, whatever)
-            val body = prepareUpload(local)
-
-            try {
-                if (local.eTag == null) {
-                    Logger.log.info("Uploading new record $fileName")
-                    remote.put(body, null, true)
-                } else {
-                    Logger.log.info("Uploading locally modified record $fileName")
-                    remote.put(body, local.eTag, false)
-                }
-            } catch(e: ConflictException) {
-                // we can't interact with the user to resolve the conflict, so we treat 409 like 412
-                Logger.log.log(Level.INFO, "Edit conflict, ignoring", e)
-            } catch(e: PreconditionFailedException) {
-                Logger.log.log(Level.INFO, "Resource has been modified on the server before upload, ignoring", e)
-            }
-
-            val newETag = remote.properties[GetETag::class.java]
-            val eTag: String?
-            if (newETag != null) {
-                eTag = newETag.eTag
-                Logger.log.fine("Received new ETag=$eTag after uploading")
-            } else {
-                Logger.log.fine("Didn't receive new ETag after uploading, setting to null")
-                eTag = null
-            }
-
-            local.clearDirty(eTag)
-
-            currentLocalResource = null
-            currentDavResource = null
-        }
-    }
-
-    /**
-     * Checks the current sync state (e.g. CTag) and whether synchronization from remote is required.
-     * @return <ul>
-     *      <li><code>true</code>   if the remote collection has changed, i.e. synchronization from remote is required</li>
-     *      <li><code>false</code>  if the remote collection hasn't changed</li>
-     * </ul>
-     */
-    protected open fun checkSyncState(): Boolean {
-        // check CTag (ignore on manual sync)
-        davCollection.properties[GetCTag::class.java]?.let { remoteCTag = it.cTag }
-
-        val localCTag = if (extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL)) {
-            Logger.log.info("Manual sync, ignoring CTag")
-            null
-        } else
-            localCollection.getCTag()
-
-        return if (remoteCTag != null && remoteCTag == localCTag) {
-            Logger.log.info("Remote collection didn't change (CTag=$remoteCTag), no need to query children")
-            false
-        } else
-            true
-    }
-
-    /**
-     * Lists all local resources which should be taken into account for synchronization into {@link #localResources}.
-     */
-    protected open fun listLocal() {
-        // fetch list of local contacts and build hash table to index file name
-        val localList = localCollection.getAll()
-        val resources = HashMap<String, LocalResource>(localList.size)
-        for (resource in localList) {
-            Logger.log.fine("Found local resource: ${resource.fileName}")
-            resource.fileName?.let { resources[it] = resource }
-        }
-        localResources = resources
-        Logger.log.info("Found ${localResources.size} local resources")
-    }
-
-    /**
-     * Lists all members of the remote collection which should be taken into account for synchronization into {@link #remoteResources}.
-     */
-    abstract protected fun listRemote()
-
-    /**
-     * Compares {@link #localResources} and {@link #remoteResources} by file name and ETag:
-     * <ul>
-     *     <li>Local resources which are not available in the remote collection (anymore) will be removed.</li>
-     *     <li>Resources whose remote ETag has changed will be added into {@link #toDownload}</li>
-     * </ul>
-     */
-    protected open fun compareLocalRemote() {
-        /* check which contacts
-           1. are not present anymore remotely -> delete immediately on local side
-           2. updated remotely -> add to downloadNames
-           3. added remotely  -> add to downloadNames
-         */
-        toDownload.clear()
-        for ((name,local) in localResources) {
-            val remote = remoteResources[name]
-            currentDavResource = remote
-
-            if (remote == null) {
-                Logger.log.info("$name is not on server anymore, deleting")
-                currentLocalResource = local
-                local.delete()
-                syncResult.stats.numDeletes++
-            } else {
-                // contact is still on server, check whether it has been updated remotely
-                val localETag = local.eTag
-                val getETag = remote.properties[GetETag::class.java]
-                val remoteETag = getETag?.eTag ?: throw DavException("Server didn't provide ETag")
-                if (remoteETag == localETag) {
-                    Logger.log.fine("$name has not been changed on server (ETag still $remoteETag)")
-                    syncResult.stats.numSkippedEntries++
-                } else {
-                    Logger.log.info("$name has been changed on server (current ETag=$remoteETag, last known ETag=$localETag)")
-                    toDownload.add(remote)
-                }
-
-                // remote entry has been seen, remove from list
-                remoteResources.remove(name)
-
-                currentDavResource = null
-                currentLocalResource = null
-            }
-        }
-
-        // add all unseen (= remotely added) remote contacts
-        if (remoteResources.isNotEmpty()) {
-            Logger.log.info("New resources have been found on the server: ${remoteResources.keys.joinToString(", ")}")
-            toDownload.addAll(remoteResources.values)
-        }
-    }
-
-    /**
-     * Downloads the remote resources in {@link #toDownload} and stores them locally.
-     * Must check Thread.interrupted() periodically to allow quick sync cancellation.
-     */
-    abstract protected fun downloadRemote()
-
-    /**
-     * For post-processing of entries, for instance assigning groups.
-     */
-    protected open fun postProcess() {}
-
-    protected open fun saveSyncState() {
-        /* Save sync state (CTag). It doesn't matter if it has changed during the sync process
-           (for instance, because another client has uploaded changes), because this will simply
-           cause all remote entries to be listed at the next sync. */
-        Logger.log.info("Saving CTag=$remoteCTag")
-        localCollection.setCTag(remoteCTag)
-    }
-
-}

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

@@ -1,159 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.*
-import android.content.pm.PackageManager
-import android.database.DatabaseUtils
-import android.graphics.drawable.BitmapDrawable
-import android.net.Uri
-import android.os.Bundle
-import android.support.v4.app.NotificationCompat
-import at.bitfire.davdroid.AccountSettings
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.model.CollectionInfo
-import at.bitfire.davdroid.model.ServiceDB
-import at.bitfire.davdroid.model.ServiceDB.Collections
-import at.bitfire.davdroid.model.ServiceDB.Services
-import at.bitfire.davdroid.resource.LocalTaskList
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.davdroid.ui.NotificationUtils
-import at.bitfire.ical4android.AndroidTaskList
-import at.bitfire.ical4android.TaskProvider
-import org.dmfs.tasks.contract.TaskContract
-import java.util.logging.Level
-
-/**
- * Synchronization manager for CalDAV collections; handles tasks ({@code VTODO}).
- */
-class TasksSyncAdapterService: SyncAdapterService() {
-
-    override fun syncAdapter() = TasksSyncAdapter(this)
-
-
-	class TasksSyncAdapter(
-            context: Context
-    ): SyncAdapter(context) {
-
-        override fun sync(settings: ISettings, account: Account, extras: Bundle, authority: String, provider: ContentProviderClient, syncResult: SyncResult) {
-            try {
-                val taskProvider = TaskProvider.fromProviderClient(context, provider)
-                val accountSettings = AccountSettings(context, settings, account)
-                /* don't run sync if
-                   - sync conditions (e.g. "sync only in WiFi") are not met AND
-                   - this is is an automatic sync (i.e. manual syncs are run regardless of sync conditions)
-                 */
-                if (!extras.containsKey(ContentResolver.SYNC_EXTRAS_MANUAL) && !checkSyncConditions(accountSettings))
-                    return
-
-                updateLocalTaskLists(taskProvider, account, accountSettings)
-
-                for (taskList in AndroidTaskList.find(account, taskProvider, LocalTaskList.Factory, "${TaskContract.TaskLists.SYNC_ENABLED}!=0", null)) {
-                    Logger.log.info("Synchronizing task list #${taskList.id} [${taskList.syncId}]")
-                    TasksSyncManager(context, settings, account, accountSettings, extras, authority, syncResult, taskProvider, taskList).use {
-                        it.performSync()
-                    }
-                }
-            } catch (e: TaskProvider.ProviderTooOldException) {
-                val nm = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
-                val notify = NotificationCompat.Builder(context, NotificationUtils.CHANNEL_SYNC_PROBLEMS)
-                        .setSmallIcon(R.drawable.ic_sync_error_notification)
-                        .setContentTitle(context.getString(R.string.sync_error_opentasks_too_old))
-                        .setContentText(context.getString(R.string.sync_error_opentasks_required_version, e.provider.minVersionName, e.installedVersionName))
-                        .setCategory(NotificationCompat.CATEGORY_ERROR)
-
-                try {
-                    val icon = context.packageManager.getApplicationIcon(e.provider.packageName)
-                    if (icon is BitmapDrawable)
-                        notify.setLargeIcon(icon.bitmap)
-                } catch(ignored: PackageManager.NameNotFoundException) {}
-
-                val intent = Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=${e.provider.packageName}"))
-                if (intent.resolveActivity(context.packageManager) != null)
-                    notify  .setContentIntent(PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT))
-                            .setAutoCancel(true)
-
-                nm.notify(Constants.NOTIFICATION_TASK_SYNC, notify.build())
-                syncResult.databaseError = true
-            } catch (e: Exception) {
-                Logger.log.log(Level.SEVERE, "Couldn't sync task lists", e)
-                syncResult.databaseError = true
-            }
-
-            Logger.log.info("Task sync complete")
-        }
-
-        private fun updateLocalTaskLists(provider: TaskProvider, account: Account, settings: AccountSettings) {
-            ServiceDB.OpenHelper(context).use { dbHelper ->
-                val db = dbHelper.readableDatabase
-
-                fun getService() =
-                        db.query(Services._TABLE, arrayOf(Services.ID),
-                                "${Services.ACCOUNT_NAME}=? AND ${Services.SERVICE}=?",
-                                arrayOf(account.name, Services.SERVICE_CALDAV), null, null, null)?.use { c ->
-                            if (c.moveToNext())
-                                c.getLong(0)
-                            else
-                                null
-                        }
-
-                fun remoteTaskLists(service: Long?): MutableMap<String, CollectionInfo> {
-                    val collections = mutableMapOf<String, CollectionInfo>()
-                    service?.let {
-                        db.query(Collections._TABLE, null,
-                                "${Collections.SERVICE_ID}=? AND ${Collections.SUPPORTS_VTODO}!=0 AND ${Collections.SYNC}",
-                                arrayOf(service.toString()), null, null, null)?.use { cursor ->
-                            while (cursor.moveToNext()) {
-                                val values = ContentValues(cursor.columnCount)
-                                DatabaseUtils.cursorRowToContentValues(cursor, values)
-                                val info = CollectionInfo(values)
-                                collections[info.url] = info
-                            }
-                        }
-                    }
-                    return collections
-                }
-
-                // enumerate remote and local task lists
-                val service = getService()
-                val remote = remoteTaskLists(service)
-
-                // delete/update local task lists
-                val updateColors = settings.getManageCalendarColors()
-
-                for (list in AndroidTaskList.find(account, provider, LocalTaskList.Factory, null, null))
-                    list.syncId?.let { url ->
-                        val info = remote[url]
-                        if (info == null) {
-                            Logger.log.fine("Deleting obsolete local task list $url")
-                            list.delete()
-                        } else {
-                            // remote CollectionInfo found for this local collection, update data
-                            Logger.log.log(Level.FINE, "Updating local task list $url", info)
-                            list.update(info, updateColors)
-                            // we already have a local task list for this remote collection, don't take into consideration anymore
-                            remote -= url
-                        }
-                    }
-
-                // create new local task lists
-                for ((_,info) in remote) {
-                    Logger.log.log(Level.INFO, "Adding local task list", info)
-                    LocalTaskList.create(account, provider, info)
-                }
-            }
-        }
-
-    }
-
-}

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

@@ -1,191 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.syncadapter
-
-import android.accounts.Account
-import android.content.Context
-import android.content.SyncResult
-import android.os.Bundle
-import at.bitfire.dav4android.DavCalendar
-import at.bitfire.dav4android.exception.DavException
-import at.bitfire.dav4android.property.CalendarData
-import at.bitfire.dav4android.property.GetCTag
-import at.bitfire.dav4android.property.GetETag
-import at.bitfire.davdroid.AccountSettings
-import at.bitfire.davdroid.Constants
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import at.bitfire.davdroid.resource.LocalResource
-import at.bitfire.davdroid.resource.LocalTask
-import at.bitfire.davdroid.resource.LocalTaskList
-import at.bitfire.davdroid.settings.ISettings
-import at.bitfire.ical4android.InvalidCalendarException
-import at.bitfire.ical4android.Task
-import at.bitfire.ical4android.TaskProvider
-import okhttp3.HttpUrl
-import okhttp3.RequestBody
-import org.apache.commons.collections4.ListUtils
-import java.io.ByteArrayOutputStream
-import java.io.Reader
-import java.io.StringReader
-import java.util.*
-import java.util.logging.Level
-
-class TasksSyncManager(
-        context: Context,
-        settings: ISettings,
-        account: Account,
-        accountSettings: AccountSettings,
-        extras: Bundle,
-        authority: String,
-        syncResult: SyncResult,
-        val provider: TaskProvider,
-        val localTaskList: LocalTaskList
-): SyncManager(context, settings, account, accountSettings, extras, authority, syncResult, "taskList/${localTaskList.id}") {
-
-    val MAX_MULTIGET = 30
-
-
-    init {
-        localCollection = localTaskList
-    }
-
-    override fun notificationId() = Constants.NOTIFICATION_TASK_SYNC
-
-    override fun getSyncErrorTitle() = context.getString(R.string.sync_error_tasks, account.name)!!
-
-
-    override fun prepare(): Boolean {
-        collectionURL = HttpUrl.parse(localTaskList.syncId ?: return false) ?: return false
-        davCollection = DavCalendar(httpClient.okHttpClient, collectionURL)
-        return true
-    }
-
-    override fun queryCapabilities() {
-        davCollection.propfind(0, GetCTag.NAME)
-    }
-
-    override fun prepareUpload(resource: LocalResource): RequestBody {
-        if (resource is LocalTask) {
-            val task = requireNotNull(resource.task)
-            Logger.log.log(Level.FINE, "Preparing upload of task ${resource.fileName}", task)
-
-            val os = ByteArrayOutputStream()
-            task.write(os)
-
-            return RequestBody.create(
-                    DavCalendar.MIME_ICALENDAR,
-                    os.toByteArray()
-            )
-        } else
-            throw IllegalArgumentException("resource must be a LocalTask")
-    }
-
-    override fun listRemote() {
-        // fetch list of remote VTODOs and build hash table to index file name
-        val calendar = davCalendar()
-        currentDavResource = calendar
-        calendar.calendarQuery("VTODO", null, null)
-
-        remoteResources = HashMap(davCollection.members.size)
-        for (vCard in davCollection.members) {
-            val fileName = vCard.fileName()
-            Logger.log.fine("Found remote VTODO: $fileName")
-            remoteResources[fileName] = vCard
-        }
-
-        currentDavResource = null
-    }
-
-    override fun downloadRemote() {
-        Logger.log.info("Downloading ${toDownload.size} tasks ($MAX_MULTIGET at once)")
-
-        // download new/updated iCalendars from server
-        for (bunch in ListUtils.partition(toDownload.toList(), MAX_MULTIGET)) {
-            abortIfCancelled()
-            Logger.log.info("Downloading ${bunch.joinToString(", ")}")
-
-            if (bunch.size == 1) {
-                // only one contact, use GET
-                val remote = bunch.first()
-                currentDavResource = remote
-
-                val body = remote.get("text/calendar")
-
-                // CalDAV servers MUST return ETag on GET [https://tools.ietf.org/html/rfc4791#section-5.3.4]
-                val eTag = remote.properties[GetETag::class.java]
-                if (eTag == null || eTag.eTag.isNullOrEmpty())
-                    throw DavException("Received CalDAV GET response without ETag for ${remote.location}")
-
-                body.charStream().use { reader ->
-                    processVTodo(remote.fileName(), eTag.eTag!!, reader)
-                }
-
-            } else {
-                // multiple contacts, use multi-get
-                val calendar = davCalendar()
-                currentDavResource = calendar
-                calendar.multiget(bunch.map { it.location })
-
-                // process multiget results
-                for (remote in davCollection.members) {
-                    currentDavResource = remote
-
-                    val eTag = remote.properties[GetETag::class.java]?.eTag
-                            ?: throw DavException("Received multi-get response without ETag")
-
-                    val calendarData = remote.properties[CalendarData::class.java]
-                    val iCalendar = calendarData?.iCalendar
-                            ?: throw DavException("Received multi-get response without task data")
-
-                    processVTodo(remote.fileName(), eTag, StringReader(iCalendar))
-                }
-            }
-
-            currentDavResource = null
-        }
-    }
-
-
-    // helpers
-
-    private fun davCalendar() = davCollection as DavCalendar
-
-    private fun processVTodo(fileName: String, eTag: String, reader: Reader) {
-        val tasks: List<Task>
-        try {
-            tasks = Task.fromReader(reader)
-        } catch (e: InvalidCalendarException) {
-            Logger.log.log(Level.SEVERE, "Received invalid iCalendar, ignoring", e)
-            return
-        }
-
-        if (tasks.size == 1) {
-            val newData = tasks.first()
-
-            // update local task, if it exists
-            val localTask = localResources[fileName] as LocalTask?
-            currentLocalResource = localTask
-            if (localTask != null) {
-                Logger.log.info("Updating $fileName in local tasklist")
-                localTask.eTag = eTag
-                localTask.update(newData)
-                syncResult.stats.numUpdates++
-            } else {
-                Logger.log.info("Adding $fileName to local task list")
-                val newTask = LocalTask(localTaskList, newData, fileName, eTag)
-                currentLocalResource = newTask
-                newTask.add()
-                syncResult.stats.numInserts++
-            }
-        } else
-            Logger.log.severe("Received VCALENDAR with not exactly one VTODO; ignoring $fileName")
-    }
-
-}

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

@@ -1,219 +0,0 @@
-/*
- * Copyright © Ricki Hirner (bitfire web engineering).
- * All rights reserved. This program and the accompanying materials
- * are made available under the terms of the GNU Public License v3.0
- * which accompanies this distribution, and is available at
- * http://www.gnu.org/licenses/gpl.html
- */
-
-package at.bitfire.davdroid.ui
-
-import android.annotation.SuppressLint
-import android.content.Context
-import android.os.Bundle
-import android.support.v4.app.Fragment
-import android.support.v4.app.FragmentManager
-import android.support.v4.app.FragmentPagerAdapter
-import android.support.v4.app.LoaderManager
-import android.support.v4.content.AsyncTaskLoader
-import android.support.v4.content.Loader
-import android.support.v7.app.AppCompatActivity
-import android.text.Html
-import android.text.Spanned
-import android.text.util.Linkify
-import android.view.LayoutInflater
-import android.view.View
-import android.view.ViewGroup
-import at.bitfire.davdroid.BuildConfig
-import at.bitfire.davdroid.R
-import at.bitfire.davdroid.log.Logger
-import ezvcard.Ezvcard
-import kotlinx.android.synthetic.main.about_component.view.*
-import kotlinx.android.synthetic.main.activity_about.*
-import org.apache.commons.io.IOUtils
-import java.io.IOException
-import java.util.*
-import java.util.logging.Level
-
-class AboutActivity: AppCompatActivity() {
-
-    private class ComponentInfo(
-            val title: String?,
-            val version: String?,
-            val website: String,
-            val copyright: String,
-            val licenseInfo: Int?,
-            val licenseTextFile: String?
-    )
-
-    private lateinit var components: Array<ComponentInfo>
-
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-
-        components = arrayOf(
-            ComponentInfo(
-                    null, BuildConfig.VERSION_NAME, getString(R.string.homepage_url),
-                    "Ricki Hirner, Bernhard Stockmann (bitfire web engineering)",
-                    null, null
-            ), ComponentInfo(
-                    "AmbilWarna", null, "https://github.com/yukuku/ambilwarna",
-                    "Yuku", R.string.about_license_info_no_warranty, "apache2.html"
-            ), ComponentInfo(
-                    "Apache Commons", null, "http://commons.apache.org/",
-                    "Apache Software Foundation", R.string.about_license_info_no_warranty, "apache2.html"
-            ), ComponentInfo(
-                    "dnsjava", null, "http://dnsjava.org/",
-                    "Brian Wellington", R.string.about_license_info_no_warranty, "bsd.html"
-            ), ComponentInfo(
-                    "ez-vcard", Ezvcard.VERSION, "https://github.com/mangstadt/ez-vcard",
-                    "Michael Angstadt", R.string.about_license_info_no_warranty, "bsd.html"
-            ), ComponentInfo(
-                    "ical4j", "2.x", "https://ical4j.github.io/",
-                    "Ben Fortuna", R.string.about_license_info_no_warranty, "bsd-3clause.html"
-            ), ComponentInfo(
-                    "OkHttp", null, "https://square.github.io/okhttp/",
-                    "Square, Inc.", R.string.about_license_info_no_warranty, "apache2.html"
-            ), ComponentInfo(
-                    "Project Lombok", null, "https://projectlombok.org/",
-                    "The Project Lombok Authors", R.string.about_license_info_no_warranty, "mit.html"
-            )
-        )
-
-        setContentView(R.layout.activity_about)
-
-        setSupportActionBar(toolbar)
-        supportActionBar?.setDisplayHomeAsUpEnabled(true)
-
-        viewpager.adapter = TabsAdapter(supportFragmentManager)
-        tabs.setupWithViewPager(viewpager)
-    }
-
-
-    private inner class TabsAdapter(
-            fm: FragmentManager
-    ): FragmentPagerAdapter(fm) {
-
-        override fun getCount() = components.size
-
-        override fun getPageTitle(position: Int) =
-                components[position].title ?: getString(R.string.app_name)!!
-
-        override fun getItem(position: Int) = ComponentFragment.instantiate(position)
-    }
-
-
-    class ComponentFragment: Fragment(), LoaderManager.LoaderCallbacks<Spanned> {
-
-        companion object {
-            val KEY_POSITION = "position"
-            val KEY_FILE_NAME = "fileName"
-
-            fun instantiate(position: Int): ComponentFragment {
-                val frag = ComponentFragment()
-                val args = Bundle(1)
-                args.putInt(KEY_POSITION, position)
-                frag.arguments = args
-                return frag
-            }
-        }
-
-        private val licenseFragmentLoader = ServiceLoader.load(ILicenseFragment::class.java)!!.firstOrNull()
-
-
-        @SuppressLint("SetTextI18n")
-        override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
-            val info = (activity as AboutActivity).components[arguments!!.getInt(KEY_POSITION)]
-
-            val v = inflater.inflate(R.layout.about_component, container, false)
-
-            var title = info.title ?: getString(R.string.app_name)
-            info.version?.let { title += " ${info.version}" }
-            v.title.text = title
-
-            v.website.autoLinkMask = Linkify.WEB_URLS
-            v.website.text = info.website
-
-            v.copyright.text = "© ${info.copyright}"
-
-            if (info.licenseInfo == null && info.licenseTextFile == null) {
-                // No license text, so this must be the app's tab. Show the license fragment here, if available.
-                licenseFragmentLoader?.let { factory ->
-                    fragmentManager!!.beginTransaction()
-                            .add(R.id.license_fragment, factory.getFragment())
-                            .commit()
-                }
-                v.license_terms.visibility = View.GONE
-
-            } else {
-                // show license info
-                if (info.licenseInfo == null)
-                    v.license_info.visibility = View.GONE
-                else
-                    v.license_info.setText(info.licenseInfo)
-
-                // load and format license text
-                if (info.licenseTextFile == null) {
-                    v.license_header.visibility = View.GONE
-                    v.license_text.visibility = View.GONE
-                } else {
-                    val args = Bundle(1)
-                    args.putString(KEY_FILE_NAME, info.licenseTextFile)
-                    loaderManager.initLoader(0, args, this)
-                }
-            }
-
-
-            return v
-        }
-
-        override fun onCreateLoader(id: Int, args: Bundle) =
-                LicenseLoader(activity!!, args.getString(KEY_FILE_NAME))
-
-        override fun onLoadFinished(loader: Loader<Spanned>, license: Spanned?) {
-            view?.let { v ->
-                v.license_text.autoLinkMask = Linkify.EMAIL_ADDRESSES or Linkify.WEB_URLS
-                v.license_text.text = license
-            }
-        }
-
-        override fun onLoaderReset(loader: Loader<Spanned>) {}
-    }
-
-    class LicenseLoader(
-            context: Context,
-            val fileName: String
-    ): AsyncTaskLoader<Spanned>(context) {
-
-        private var content: Spanned? = null
-
-        override fun onStartLoading() {
-            if (content != null)
-                deliverResult(content)
-            else
-                forceLoad()
-        }
-
-        override fun loadInBackground(): Spanned? {
-            Logger.log.fine("Loading license file $fileName")
-            try {
-                context.resources.assets.open(fileName).use {
-                    content = Html.fromHtml(IOUtils.toString(it, Charsets.UTF_8))
-                    return content
-                }
-            } catch(e: IOException) {
-                Logger.log.log(Level.SEVERE, "Couldn't read license file", e)
-                return null
-            }
-        }
-    }
-
-
-    interface ILicenseFragment {
-
-        fun getFragment(): Fragment
-
-    }
-
-}

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

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