.circleci/config.yml

@@ -0,0 +1,135 @@
+version: 2
+jobs:
+  build:
+    docker:
+      - image: circleci/android:api-28
+    working_directory: ~/ultrasonic
+    envoronment:
+      JVM_OPTS: -Xmx3200m
+    steps:
+      - checkout
+      - restore_cache:
+          key: gradle-cache-{{ checksum "dependencies.gradle" }}
+      - run:
+          name: clean gradle.properties
+          command: echo "" > gradle.properties
+      - run:
+          name: checkstyle
+          command: ./gradlew -Pqc ktlintCheck
+      - run:
+          name: static analysis
+          command: ./gradlew -Pqc detektCheck
+      - run:
+          name: build
+          command: ./gradlew assembleDebug
+      - run:
+          name: unit-tests
+          command: |
+            ./gradlew ciTest testDebugUnitTest
+            ./gradlew jacocoFullReport
+            bash <(curl -s https://codecov.io/bash)
+      - run:
+          name: lint
+          command: ./gradlew :ultrasonic:lintRelease
+      - run:
+          name: assemble release build
+          command: ./gradlew assembleRelease
+      - save_cache:
+          paths:
+            - ~/.gradle
+          key: gradle-cache-{{ checksum "dependencies.gradle" }}
+      - store_artifacts:
+          path: ultrasonic/build/reports
+          destination: reports
+      - store_artifacts:
+          path: subsonic-api/build/reports
+          destination: reports
+      - store_artifacts:
+          path: build/reports/jacoco/jacocoFullReport/
+  push_translations:
+    docker:
+      - image: circleci/python:3.6
+    working_directory: ~/ultrasonic
+    steps:
+      - checkout
+      - run:
+          name: install transifex client
+          command: |
+            python -m venv ~/venv
+            . ~/venv/bin/activate
+            pip install transifex-client
+      - run:
+          name: configure transifex client
+          command: echo $'[https://www.transifex.com]\nhostname = https://www.transifex.com\nusername = api\npassword = '"${TRANSIFEX_PASSWORD}"$'\n' > ~/.transifexrc
+      - run:
+          name: push changes in translation files
+          command: |
+            . ~/venv/bin/activate
+            tx push -st
+  generate_signed_apk:
+    docker:
+      - image: circleci/android:api-28
+    working_directory: ~/ultrasonic
+    envoronment:
+      JAVA_TOOL_OPTIONS: "-XX:+UnlockExperimentalVMOptions -XX:+UseCGroupMemoryLimitForHeap"
+    steps:
+      - checkout
+      - restore_cache:
+          key: gradle-cache-{{ checksum "dependencies.gradle" }}
+      - run:
+          name: decrypt ultrasonic-keystore
+          command: openssl aes-256-cbc -K ${ULTRASONIC_KEYSTORE_KEY} -iv ${ULTRASONIC_KEYSTORE_IV} -in ultrasonic-keystore.enc -out ultrasonic-keystore -d
+      - run:
+          name: build release apk
+          command: ./gradlew build assembleRelease
+      - run:
+          name: sign release apk
+          command: |
+            mkdir -p /tmp/ultrasonic-release
+            jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore ~/ultrasonic/ultrasonic-keystore -storepass ${ULTRASONIC_KEYSTORE_STOREPASS} -keypass ${ULTRASONIC_KEYSTORE_KEYPASS} ultrasonic/build/outputs/apk/release/ultrasonic-release-unsigned.apk ultrasonic
+            jarsigner -verify ultrasonic/build/outputs/apk/release/ultrasonic-release-unsigned.apk
+            ${ANDROID_HOME}/build-tools/27.0.0/zipalign -v 4 ultrasonic/build/outputs/apk/release/ultrasonic-release-unsigned.apk /tmp/ultrasonic-release/ultrasonic-${CIRCLE_TAG}.apk
+      - persist_to_workspace:
+          root: /tmp/ultrasonic-release
+          paths:
+            - ultrasonic-*.apk
+  publish_github_signed_apk:
+    docker:
+      - image: circleci/golang
+    steps:
+      - attach_workspace:
+          at: /tmp/ultrasonic-release
+      - run:
+          name: install ghr
+          command: go get -v github.com/tcnksm/ghr
+      - run:
+          name: publish release on github tag
+          command: ghr -u ${CIRCLE_PROJECT_USERNAME} -r ${CIRCLE_PROJECT_REPONAME} ${CIRCLE_TAG} /tmp/ultrasonic-release
+workflows:
+  version: 2
+  build_and_push_translations:
+    jobs:
+      - build
+      - push_translations:
+          requires:
+            - build
+          filters:
+            branches:
+              only:
+                - develop
+                - master
+      - generate_signed_apk:
+          filters:
+            tags:
+              only: /^[0-9]+(\.[0-9]+)*/
+            branches:
+              ignore: /.*/
+      - publish_github_signed_apk:
+          requires:
+            - generate_signed_apk
+          filters:
+            tags:
+              only: /^[0-9]+(\.[0-9]+)*/
+            branches:
+              ignore: /.*/
+

.editorconfig

@@ -1,2 +0,0 @@
-[*.{kt,kts}]
-ktlint_code_style = android_studio

.gitignore

@@ -18,7 +18,6 @@ out/
 
 # Gradle files
 .gradle/
-.kotlin/
 build/
 
 # Local configuration file (sdk path, etc)
@@ -40,7 +39,6 @@ captures/
 *.iml
 .idea/
 
-
 # Keystore files
 *.jks
 

.gitlab-ci.yml

@@ -1,151 +0,0 @@
-default:
-  image: registry.gitlab.com/ultrasonic/ci-android:1.2.0
-  cache: &global_cache
-    key:
-      files:
-        - gradle/wrapper/gradle-wrapper.properties
-    paths:
-      - .gradle/
-
-variables:
-  CACHE_FALLBACK_KEY: develop-protected
-  MEMORY_CONFIG: "-Xmx3200m -Xms256m -XX:MaxMetaspaceSize=1g"
-  MEMORY_CONFIG_DEBUG: "-Xmx3200m -Xms256m -XX:MaxMetaspaceSize=1g -verbose:gc -Xlog:gc*"
-  JVM_OPTS: ${MEMORY_CONFIG}
-  JAVA_TOOL_OPTIONS: ${MEMORY_CONFIG}
-  GRADLE_OPTS: ${MEMORY_CONFIG}
-  PACKAGE_REGISTRY_URL: "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/Ultrasonic/${CI_COMMIT_TAG}"
-  PACKAGE_APK: "ultrasonic-${CI_COMMIT_TAG}.apk"
-  PACKAGE_APK_IDSIG: "ultrasonic-${CI_COMMIT_TAG}.apk.idsig"
-  GRADLE_USER_HOME: "$CI_PROJECT_DIR/.gradle"
-  # The project id of https://gitlab.com/ultrasonic/ultrasonic/
-  ROOT_PROJECT_ID: 37671564
-
-stages:
-  - Check
-  - Build
-  - Sign APK
-  - Publish
-  - Release
-
-Check Style:
-  stage: Check
-  script: ./gradlew -Pqc ktlintCheck
-  cache:
-    # inherit all global cache settings
-    <<: *global_cache
-    policy: pull
-  rules:
-    - if: $CI_COMMIT_REF_NAME == "develop" || $CI_COMMIT_REF_NAME == "master" || $CI_COMMIT_TAG || $CI_PROJECT_ID != $ROOT_PROJECT_ID
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-
-Static Analysis:
-  stage: Check
-  script: ./gradlew -Pqc detekt
-  cache:
-    # inherit all global cache settings
-    <<: *global_cache
-    policy: pull
-  rules:
-    - if: $CI_COMMIT_REF_NAME == "develop" || $CI_COMMIT_REF_NAME == "master" || $CI_COMMIT_TAG || $CI_PROJECT_ID != $ROOT_PROJECT_ID
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-
-Lint:
-  stage: Check
-  script: ./gradlew :ultrasonic:lintRelease
-  cache:
-    # inherit all global cache settings
-    <<: *global_cache
-    policy: pull-push
-  rules:
-    - if: $CI_COMMIT_REF_NAME == "develop" || $CI_COMMIT_REF_NAME == "master" || $CI_COMMIT_TAG || $CI_PROJECT_ID != $ROOT_PROJECT_ID
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-
-Unit Tests:
-  stage: Check
-  script: ./gradlew ciTest testDebugUnitTest
-  cache:
-    # inherit all global cache settings
-    <<: *global_cache
-    policy: pull-push
-  rules:
-    - if: $CI_COMMIT_REF_NAME == "develop" || $CI_COMMIT_REF_NAME == "master" || $CI_COMMIT_TAG || $CI_PROJECT_ID != $ROOT_PROJECT_ID
-    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
-
-Assemble Release:
-  stage: Build
-  script:
-    - sed -i 's/applicationId \"org.moire.ultrasonic\"/applicationId "org.moire.ultrasonic.gitlab"/' ultrasonic/build.gradle
-    - ./gradlew assembleRelease
-  artifacts:
-    name: ultrasonic-release-unsigned-${CI_COMMIT_SHA}
-    paths:
-      - ultrasonic/build/outputs/apk/release/ultrasonic-release-unsigned.apk
-  rules:
-    - if: $CI_COMMIT_REF_NAME == "develop" || $CI_COMMIT_REF_NAME == "master" || $CI_COMMIT_TAG || $CI_PROJECT_ID != $ROOT_PROJECT_ID
-
-# We generate a signed package for each commit to develop as well as when making a release.
-# Since the develop signed apk are not persistent they can be downloaded for around 3 weeks before Gitlab deletes them.
-Generate Signed APK:
-  stage: Sign APK
-  # We don't need the gradle cache here
-  cache: []
-  script:
-    - openssl aes-256-cbc -K ${ULTRASONIC_KEYSTORE_KEY} -iv ${ULTRASONIC_KEYSTORE_IV} -in ultrasonic-keystore.enc -out ultrasonic-keystore -d
-    - mkdir -p ${CI_PROJECT_DIR}/ultrasonic-release
-    - ${ANDROID_HOME}/build-tools/*/zipalign -v 4 ultrasonic/build/outputs/apk/release/ultrasonic-release-unsigned.apk ${CI_PROJECT_DIR}/ultrasonic-release/${PACKAGE_APK}
-    - ${ANDROID_HOME}/build-tools/*/apksigner sign --verbose --ks ${CI_PROJECT_DIR}/ultrasonic-keystore --ks-pass pass:${ULTRASONIC_KEYSTORE_STOREPASS} --key-pass pass:${ULTRASONIC_KEYSTORE_KEYPASS} ${CI_PROJECT_DIR}/ultrasonic-release/${PACKAGE_APK}
-    - ${ANDROID_HOME}/build-tools/*/apksigner verify --verbose ${CI_PROJECT_DIR}/ultrasonic-release/${PACKAGE_APK}
-  artifacts:
-    name: $PACKAGE_APK
-    paths:
-      - ultrasonic-release/
-  rules:
-    # Run when releasing a new tag
-    - if: $CI_COMMIT_TAG && $CI_PROJECT_ID == $ROOT_PROJECT_ID
-    # Or when adding a new commit to develop (but never inside merge events)
-    - if: $CI_COMMIT_REF_NAME == "develop" && $CI_PROJECT_ID == $ROOT_PROJECT_ID && $CI_PIPELINE_SOURCE != "merge_request_event"
-      variables:
-        PACKAGE_APK: ultrasonic-${CI_COMMIT_SHA}.apk
-
-
-Publish Signed APK:
-  stage: Publish
-  image: curlimages/curl:latest
-  script:
-    - |
-      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file ultrasonic-release/${PACKAGE_APK} "${PACKAGE_REGISTRY_URL}/${PACKAGE_APK}"
-    - |
-      curl --header "JOB-TOKEN: ${CI_JOB_TOKEN}" --upload-file ultrasonic-release/${PACKAGE_APK_IDSIG} "${PACKAGE_REGISTRY_URL}/${PACKAGE_APK_IDSIG}"
-  rules:
-    - if: $CI_COMMIT_TAG && $CI_PROJECT_ID == $ROOT_PROJECT_ID
-
-Release:
-  stage: Release
-  image: registry.gitlab.com/gitlab-org/release-cli:latest
-  script: |
-    release-cli create --name "Release ${CI_COMMIT_TAG}" --tag-name ${CI_COMMIT_TAG} \
-      --assets-link "{\"name\":\"${PACKAGE_APK}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${PACKAGE_APK}\"}" \
-      --assets-link "{\"name\":\"${PACKAGE_APK_IDSIG}\",\"url\":\"${PACKAGE_REGISTRY_URL}/${PACKAGE_APK_IDSIG}\"}"
-  rules:
-    - if: $CI_COMMIT_TAG && $CI_PROJECT_ID == $ROOT_PROJECT_ID
-
-RoboTest:
-  stage: Release
-  image: gcr.io/google.com/cloudsdktool/google-cloud-cli:latest
-  # We don't need the gradle cache here
-  cache: []
-  script:
-    - curl --silent "https://gitlab.com/gitlab-org/incubation-engineering/mobile-devops/download-secure-files/-/raw/main/installer" | bash
-    - gcloud auth activate-service-account --key-file .secure_files/firebase-key.json 
-    - gcloud firebase test android run --project ultrasonic-61089 --type robo --app ultrasonic-release/${PACKAGE_APK} --robo-directives click:button1= --device model=Nexus6,version=21,locale=en,orientation=portrait  --device model=Pixel3,version=28,locale=fr,orientation=landscape 
-  rules:
-    # Run when releasing a new tag
-    - if: $CI_COMMIT_TAG && $CI_PROJECT_ID == $ROOT_PROJECT_ID
-    # or when requested by using [ROBO] inside the commit message and merging to develop
-    # Would be nice to be able to run it in a MR as well, but currently not possible
-    # Because it would not have access to the protected keys.
-    - if: $CI_COMMIT_MESSAGE =~ /^\[ROBO\].*/ && $CI_PROJECT_ID == $ROOT_PROJECT_ID && $CI_COMMIT_REF_NAME == "develop" && $CI_PIPELINE_SOURCE != "merge_request_event"
-      variables:
-        PACKAGE_APK: ultrasonic-${CI_COMMIT_SHA}.apk
-

.gitlab/issue_templates/Default.md

@@ -1,35 +0,0 @@
-## Problem description
-
-Describe your problem here. Describe what you want to happen, and what
-happens if you try to do it. If you have a stack trace or any logs, please
-format them using Markdown triple backquote notation.
-
-### Steps to reproduce
-
-Describe how somebody else could observe the same behavior you do. Don't
-share here any logins and passwords!
-
-### Please provide a log!
-
-Many issues are hard to reproduce without a log file. Please enable logging by opening the setting and scrolling to the bottom.
-There you will find an option to activate loging and to export the file. Please note that the log might contain personal information,
-such as the name of the tracks you listened to. If you don't want to post it publicly, let us know, and we will find a way.
-
-
-## System information
-
-### Ultrasonic client
-
- * **Ultrasonic version**: *version of the app*
- * **Android version**: *Version of Android OS on the device*
- * **Device info**: *Device manufacturer, model*
-
-### Server
-
- * **Server name**: *Airsonic, Ampache, Supysonic...*
- * **Server version**: *version of server software*
- * **Protocol used**: *http or https (self certificate, letsencrypt...)*
-
-## Additional notes
-
-Include any extra notes here. Otherwise you may remove this section.

.gitlab/issue_templates/Enhancement.md

@@ -1,32 +0,0 @@
-## Motivation
-
-Describe here what motivated you to make this enhancement request. What is
-currently happening and what would you like to improve. If you have a stack
-trace or any logs, please format them using Markdown triple backquote
-notation.
-
-### Proposal
-
-Tell us in detail what you propose. How you want to achieve what you would
-like to improve.
-
-## System information
-
-Include this section only if you consider that is relevant to this ticket,
-otherwise you may remove it.
-
-### Ultrasonic client
-
- * **Ultrasonic version**: *version of the app*
- * **Android version**: *Version of Android OS on the device*
- * **Device info**: *Device manufacturer, model*
-
-### Server
-
- * **Server name**: *Airsonic, Ampache, Supysonic...*
- * **Server version**: *version of server software*
- * **Protocol used**: *http or https (self certificate, letsencrypt...)*
-
-## Additional notes
-
-Include any extra notes here. Otherwise you may remove this section.

.gitlab/issue_templates/Feature Request.md

@@ -1,27 +0,0 @@
-## Proposal
-
-Describe your proposed feature request here. Use this template only to
-request a new feature that does not exist in Ultrasonic. If you are
-requesting an enhancement to a current feature, please use the enhancement
-template.
-
-## System information
-
-Include this section only if you consider that is relevant to this ticket,
-otherwise you may remove it.
-
-### Ultrasonic client
-
- * **Ultrasonic version**: *version of the app*
- * **Android version**: *Version of Android OS on the device*
- * **Device info**: *Device manufacturer, model*
-
-### Server
-
- * **Server name**: *Airsonic, Ampache, Supysonic...*
- * **Server version**: *version of server software*
- * **Protocol used**: *http or https (self certificate, letsencrypt...)*
-
-## Additional notes
-
-Include any extra notes here. Otherwise you may remove this section.

.gitlab/merge_request_templates/Default.md

@@ -1,12 +0,0 @@
-<!-- Please describe your changes here -->
-
-----------------------------------------------------------------------------
-
-- [ ] I have opened an issue where I discuss the change I wish to make.
-- [ ] I ran `./gradlew -Pqc ktlintCheck`, `./gradlew -Pqc detekt` and
-  `./gradlew :ultrasonic:lintRelease` and no problems found. See
-  [CONTRIBUTING](CONTRIBUTING.md) for further information.
-- [ ] All commits [are
-  signed](https://docs.gitlab.com/ee/user/project/repository/gpg_signed_commits/).
-- [ ] I agree to release my code and all other changes of this MR under the
-  [GNU GPLv3](LICENSE) license.

.gitlab/merge_request_templates/Release.md

@@ -1,10 +0,0 @@
-#### Before merge:
-- [ ] MR is targetting the master branch
-- [ ] **Squash commits must be disabled!**
-- [ ] RoboTests (5 physical, 10 virtual) on a Release apk return no errors
-- [ ] Release notes present
-
-#### After merge
-- [ ] ``git fetch``
-- [ ] Create an annotated and signed tag: ``git tag -sa``
-- [ ] Push the tag to git:``git push --tags``

.gitlab/renovate.json

@@ -1,6 +0,0 @@
-{
-  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:base"],
-  "baseBranches": [ "develop" ],
-  "labels": [ "housekeeping", "dependencies" ]
-}

.idea/codeStyles/Project.xml

@@ -1,123 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <code_scheme name="Project" version="173">
-    <JetCodeStyleSettings>
-      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
-    </JetCodeStyleSettings>
-    <codeStyleSettings language="XML">
-      <option name="FORCE_REARRANGE_MODE" value="1" />
-      <indentOptions>
-        <option name="CONTINUATION_INDENT_SIZE" value="4" />
-      </indentOptions>
-      <arrangement>
-        <rules>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>xmlns:android</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>^$</XML_NAMESPACE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>xmlns:.*</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>^$</XML_NAMESPACE>
-                </AND>
-              </match>
-              <order>BY_NAME</order>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>.*:id</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>.*:name</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>name</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>^$</XML_NAMESPACE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>style</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>^$</XML_NAMESPACE>
-                </AND>
-              </match>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>.*</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>^$</XML_NAMESPACE>
-                </AND>
-              </match>
-              <order>BY_NAME</order>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>.*</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>http://schemas.android.com/apk/res/android</XML_NAMESPACE>
-                </AND>
-              </match>
-              <order>ANDROID_ATTRIBUTE_ORDER</order>
-            </rule>
-          </section>
-          <section>
-            <rule>
-              <match>
-                <AND>
-                  <NAME>.*</NAME>
-                  <XML_ATTRIBUTE />
-                  <XML_NAMESPACE>.*</XML_NAMESPACE>
-                </AND>
-              </match>
-              <order>BY_NAME</order>
-            </rule>
-          </section>
-        </rules>
-      </arrangement>
-    </codeStyleSettings>
-    <codeStyleSettings language="kotlin">
-      <option name="CODE_STYLE_DEFAULTS" value="KOTLIN_OFFICIAL" />
-    </codeStyleSettings>
-  </code_scheme>
-</component>

.idea/codeStyles/codeStyleConfig.xml

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

.idea/compiler.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="21" />
-  </component>
-  <component name="JavacSettings">
-    <option name="ADDITIONAL_OPTIONS_OVERRIDE">
-      <module name="Ultrasonic.core.subsonic-api" options="-Xlint:deprecation" />
-      <module name="Ultrasonic.core.subsonic-api.main" options="-Xlint:deprecation" />
-      <module name="Ultrasonic.core.subsonic-api.test" options="-Xlint:deprecation" />
-      <module name="ultrasonic.core.subsonic-api" options="-Xlint:deprecation" />
-      <module name="ultrasonic.core.subsonic-api.main" options="-Xlint:deprecation" />
-      <module name="ultrasonic.core.subsonic-api.test" options="-Xlint:deprecation" />
-    </option>
-  </component>
-</project>

.idea/copyright/Default.xml

@@ -1,6 +0,0 @@
-<component name="CopyrightManager">
-  <copyright>
-    <option name="notice" value="&amp;#36;file.fileName&#10;Copyright (C) 2009-&amp;#36;today.year Ultrasonic developers&#10;&#10;Distributed under terms of the GNU GPLv3 license." />
-    <option name="myName" value="Default" />
-  </copyright>
-</component>

.idea/copyright/profiles_settings.xml

@@ -1,7 +0,0 @@
-<component name="CopyrightManager">
-  <settings default="Default">
-    <LanguageOptions name="Kotlin">
-      <option name="fileTypeOverride" value="3" />
-    </LanguageOptions>
-  </settings>
-</component>

.idea/inspectionProfiles/Project_Default.xml

@@ -1,8 +0,0 @@
-<component name="InspectionProjectProfileManager">
-  <profile version="1.0">
-    <option name="myName" value="Project Default" />
-    <inspection_tool class="Reformat" enabled="false" level="WEAK WARNING" enabled_by_default="false">
-      <option name="processChangedFilesOnly" value="true" />
-    </inspection_tool>
-  </profile>
-</component>

.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

.tx/config

@@ -0,0 +1,10 @@
+[main]
+host = https://www.transifex.com
+lang_map = nl_NL:nl,pl_PL:pl,fr_CA:fr-rCA,pt_BR:pt-rBR,pt_PT:pt,zh_CN:zh-rCN,zh_HK:zh-rHK,zh_TW:zh-rTW,da_DK:da-rDK,de_DE:de,tr_TR:tr,fr_FR:fr,es_ES:es,hu_HU:hu,sv_SE:sv-rSE,bg_BG:bg,el_GR:el,kn_IN:kn-rIN,cs_CZ:cs,sr:sr,he:iw,id:in,lt_LT:lt,km_KH:km-rKH,th_TH:th,ru_RU:ru,it_IT:it
+
+[ultrasonic.app]
+file_filter = ultrasonic/src/main/res/values-<lang>/strings.xml
+source_file = ultrasonic/src/main/res/values/strings.xml
+source_lang = en
+type = ANDROID
+

CONTRIBUTING.md

@@ -1,83 +1,35 @@
 # Contributing
 
-Ultrasonic development is a community project, and contributions are
-welcomed.
+Ultrasonic development is a community project, and contributions are welcomed.
 
-First, see if your issue haven’t been yet reported
-[here](https://gitlab.com/ultrasonic/ultrasonic/issues), then, please, first
-discuss the change you wish to make via [a new
-issue](https://gitlab.com/ultrasonic/ultrasonic/issues/new).
+First, see if your issue haven’t been yet reported [here](https://github.com/ultrasonic/ultrasonic/issues),
+then, please, first discuss the change you wish to make via [a new issue](https://github.com/ultrasonic/ultrasonic/issues/new).
 
 ## Contributing Translations
 
 Interested in help to translate Ultrasonic? You can contribute in our
-[Weblate team](https://hosted.weblate.org/projects/ultrasonic/).
+[Transifex team](https://www.transifex.com/ultrasonic/ultrasonic/).
 
 ## Contributing Code
 
-By default, merge requests should be opened against the **develop** branch
-from your own branch, MR against the **master** branch should only be used
-for critical bug fixes.
+By default Pull Request should be opened against **develop** branch, PR against **master** branch should be used only
+ for critical bugfixes.
 
 ### Here are a few guidelines you should follow before submitting:
 
-1. **License Acceptance:** All contributions must be licensed as [GNU
-   GPLv3](LICENSE) to be accepted. Use `git commit --signoff` to acknowledge
-   this.
-2. **No Breakage**: New features or changes to existing ones must not
-   degrade the user experience.
-3. **Coding standards**: best-practices should be followed, comment
-   generously, and avoid "clever" algorithms. Refactoring existing messes is
-   great, but watch out for breakage.
-4. **No large PR**: Try to limit the scope of PR only to the related issue,
-   so it will be easier to review and test.
-5. **Make your own branch**: When you send us a merge request, please do it
-   from your own branch. Avoid using the `develop` branch.
+1. **License Acceptance:** All contributions must be licensed as [GNU GPLv3](LICENSE) to be accepted.
+Use `git commit --signoff` to acknowledge this.
+2. **App is migrating to [Kotlin](https://kotlinlang.org/) programming language:** new Pull Requests
+should be written in this programming language.
+3. **No Breakage:** New features or changes to existing ones must not degrade the user experience.
+4. **Coding standards:** best-practices should be followed, comment generously, and avoid "clever" algorithms.
+Refactoring existing messes is great, but watch out for breakage.
+5. **No large PR:** Try to limit the scope of PR only to the related issue, so it will be easier to review
+and test.
 
-### Merge request process
+### Pull Request Process
 
-On each merge request GitLab runs a number of checks to make sure there are
-no problems.
-
-Take special note of point five of the previous paragraph. Do not use the
-`develop` branch, make your own. Not following this step will cause your
-merge request to be rejected without even checking it.
-
-#### Signed commits
-
-Commits must be signed. [See here how to set it
-up](https://docs.gitlab.com/ee/user/project/repository/gpg_signed_commits/).
-
-#### KtLint
-
-This programm checks if the source code is formatted correctly. You can run
-it yourself locally with
-```
-./gradlew -Pqc ktlintFormat
-```
-Running this command will fix common problems and will notify you of
-problems it couldn't fix automatically.
-
-#### Detekt
-
-Detekt is a static analyser. It helps to find potential bugs in our code.
-You can run it yourself locally with
-```
-./gradlew -Pqc detekt
-```
-There is a "baseline" file, in which errors which have been in the code base
-before are noted. Sometimes it is necessary to regenerate this file by
-running:
-```
-./gradlew -Pqc detektBaseline
-```
-
-#### Lint
-
-Lint looks for general problems in the code or unused resources etc. You can
-run it with
-```
-./gradlew -Pqc lintRelease
-```
-If there is a need to regenerate the baseline, remove
-`ultrasonic/lint-baseline.xml` and rerun the command.
+1. Ensure all commits are signed-off.
+2. Check tests for the new code are added.
+3. Check code style is passing.
+4. Check code static analysis is passing.

ISSUE_TEMPLATE.md

@@ -0,0 +1,20 @@
+## Problem description
+
+Describe your problem here. Describe what you want to happen, and what happens
+if you try to do it. If you have a stack trace or any logs, please format them using
+github triple backquote notation
+
+### Steps to reproduce
+
+Describe how somebody else could observe the same behavior you do. Don't share here any logins and 
+passwords!
+
+## System information
+
+ * **Ultrasonic version**: *version of the app*
+ * **Android version**: *Version of Android OS on the device*
+ * **Device info**: *Device manufacturer, model*
+
+## Additional notes
+
+Include any extra notes here. Otherwise you may remove this section.

README.md

@@ -1,14 +1,14 @@
 # Ultrasonic
+[![Build Status](https://circleci.com/gh/ultrasonic/ultrasonic/tree/develop.svg?style=shield&circle-token=:circle-token)](https://circleci.com/gh/ultrasonic)
+[![Codecov branch](https://img.shields.io/codecov/c/github/ultrasonic/ultrasonic/develop.svg)]()
+[![ktlint](https://img.shields.io/badge/code%20style-%E2%9D%A4-FF4081.svg)](https://ktlint.github.io/)
 
-Ultrasonic is free and open-source music streaming Android client for
-[Subsonic][subsonic] [API][subapi] (version 1.7.0 or higher) compatible
-servers.
+Ultrasonic is free and open-source music streaming Android client for [Subsonic](http://www.subsonic.org/) [API](http://www.subsonic.org/pages/api.jsp) (version 1.7.0 or higher) compatible servers.
 
 ## Help wanted
 
 We currently don't have that much time to spend developing Subsonic, so any
 contributions or active developers are always welcomed.
-Have a look at [CONTRIBUTING](CONTRIBUTING.md) to get started.
 
 ## Download
 
@@ -16,20 +16,22 @@ App is available to download at following stores:
 
 [<img src="https://play.google.com/intl/en_us/badges/images/generic/en-play-badge.png" alt="Get it on Google Play" height="70">](https://play.google.com/store/apps/details?id=org.moire.ultrasonic)
 [<img src="https://f-droid.org/badge/get-it-on.png" alt="Get it on F-Droid" height="70">](https://f-droid.org/packages/org.moire.ultrasonic/)
-[<img src="https://ultrasonic.gitlab.io/assets/img/get-it-on-gitlab.png" alt="Get it on GitLab" height="70">](https://gitlab.com/ultrasonic/ultrasonic/-/releases)
+[<img src="https://ultrasonic.github.io/assets/img/get-it-on-github.png" alt="Get it on GitHub" height="70">](https://github.com/ultrasonic/ultrasonic/releases)
 
 **Warning**: All three versions (Google Play, F-Droid and the APKs) are not
 compatible (not signed by the same key)! You must uninstall one to install
 the other, which will delete all your data.
 
-If you want to use the version downloaded from F-Droid or from GitLab with
-**Android Auto**, you must enable Unknown Sources as it is described in
-[this wiki page][wikiaa].
-
 ## Bugs and issues
 
-First, see if your issue haven’t been yet reported [here][issues], otherwise
-open [a new issue][newissue].
+First, see if your issue haven’t been yet reported [here](https://github.com/ultrasonic/ultrasonic/issues),
+otherwise open [a new issue](https://github.com/ultrasonic/ultrasonic/issues/new).
+
+### Known (not our) bugs
+
+If you are using *Madsonic 5.1.X* several sections of Ultrasonic will not
+work. This is caused by bad implementation of Subsonic API by Madsonic. For
+more info about this you can read [this bug](https://github.com/ultrasonic/ultrasonic/issues/129).
 
 ## Contributing
 
@@ -37,28 +39,15 @@ See [CONTRIBUTING](CONTRIBUTING.md).
 
 ## Supported (tested) Subsonic API implementations
 
-- [Subsonic][subsonic]
-- [Airsonic-Advanced][airsonic]
-- [Supysonic][supysonic]
-- [Ampache][ampache]
+- [Subsonic](http://www.subsonic.org/pages/index.jsp)
+- [Airsonic](https://github.com/airsonic/airsonic)
+- [Supysonic](https://github.com/spl0k/supysonic)
 
-Other *Subsonic API* implementations should work as well as long as they
-follow API [documentation][subapi].
+Other *Subsonic API* implementations should work as well as long as they follow API
+[documentation](http://www.subsonic.org/pages/api.jsp).
 
 ## License
 
-This software is licensed under the terms of the GNU General Public License
-version 3 (GPLv3).
+This software is licensed under the terms of the GNU General Public License version 3 (GPLv3).
 
-Full text of the license is available in the [LICENSE](LICENSE) file and
-[online][gpl3].
-
-[wikiaa]: https://gitlab.com/ultrasonic/ultrasonic/-/wikis/Using-Ultrasonic-with-Android-Auto
-[issues]: https://gitlab.com/ultrasonic/ultrasonic/-/issues
-[newissue]: https://gitlab.com/ultrasonic/ultrasonic/-/issues/new
-[subsonic]: http://www.subsonic.org/
-[subapi]: http://www.subsonic.org/pages/api.jsp
-[airsonic]: https://github.com/airsonic-advanced/airsonic-advanced
-[supysonic]: https://github.com/spl0k/supysonic
-[ampache]: https://ampache.org/
-[gpl3]: https://opensource.org/licenses/gpl-3.0.html
+Full text of the license is available in the [LICENSE](LICENSE) file and [online](https://opensource.org/licenses/gpl-3.0.html).

build.gradle

@@ -1,8 +1,6 @@
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
-
 // Top-level build file where you can add configuration options common to all sub-projects/modules.
 buildscript {
-    apply from: 'gradle/versions.gradle'
+    apply from: 'dependencies.gradle'
 
     ext.bootstrap = [
             kotlinModule : "${project.rootDir}/gradle_scripts/kotlin-module-bootstrap.gradle",
@@ -10,17 +8,16 @@ buildscript {
     ]
 
     repositories {
+        jcenter()
         google()
-        mavenCentral()
-        gradlePluginPortal()
-        maven { url = "https://plugins.gradle.org/m2/" }
+        maven { url "https://plugins.gradle.org/m2/" }
     }
     dependencies {
-        classpath libs.gradle
-        classpath libs.kotlin
-        classpath libs.ktlintGradle
-        classpath libs.detekt
-        classpath libs.navigationSafeArgs
+        classpath gradlePlugins.androidTools
+        classpath gradlePlugins.kotlin
+        classpath gradlePlugins.ktlintGradle
+        classpath gradlePlugins.detekt
+        classpath gradlePlugins.jacoco
     }
 }
 
@@ -28,33 +25,20 @@ allprojects {
     // Buildscript here is required by detekt
     buildscript {
         repositories {
-            mavenCentral()
-            gradlePluginPortal()
+            jcenter()
             google()
         }
     }
 
     repositories {
-        mavenCentral()
-        gradlePluginPortal()
+        jcenter()
         google()
     }
-
-    // Set Kotlin JVM target to the same for all subprojects
-    tasks.withType(KotlinCompile).configureEach {
-        kotlinOptions {
-            jvmTarget = "21"
-        }
-    }
-
-    tasks.withType(JavaCompile).tap {
-        configureEach {
-            options.compilerArgs.add("-Xlint:deprecation")
-        }
-    }
 }
 
-wrapper {
-    gradleVersion = libs.versions.gradle.get()
-    distributionType = "all"
-}
+apply from: 'gradle_scripts/jacoco.gradle'
+
+task wrapper(type: Wrapper) {
+    gradleVersion(versions.gradle)
+    distributionType("all")
+}

config/detekt/detekt.yml

@@ -1,84 +0,0 @@
-build:
-  maxIssues: 0
-  weights:
-    complexity: 2
-    LongParameterList: 1
-    comments: 1
-
-potential-bugs:
-  active: true
-  EqualsWithHashCodeExist:
-    active: true
-  ExplicitGarbageCollectionCall:
-    active: true
-  LateinitUsage:
-    active: false
-  UnsafeCallOnNullableType:
-    active: false
-  UnsafeCast:
-    active: false
-
-performance:
-  active: true
-  ForEachOnRange:
-    active: true
-  SpreadOperator:
-    active: true
-
-exceptions:
-  active: true
-  TooGenericExceptionCaught:
-    allowedExceptionNameRegex: '_|(all|ignore|expected).*'
-
-empty-blocks:
-  active: true
-  EmptyFunctionBlock:
-    active: true
-    ignoreOverridden: true
-
-complexity:
-  active: true
-  TooManyFunctions:
-    thresholdInFiles: 25
-    thresholdInClasses: 25
-    thresholdInInterfaces: 20
-    thresholdInObjects: 30
-  LabeledExpression:
-    active: false
-
-style:
-  active: true
-  NewLineAtEndOfFile:
-    active: true
-  ForbiddenComment:
-    active: true
-    comments:
-      - reason: 'Forbidden FIXME todo marker in comment, please fix the problem.'
-        value: 'FIXME:'
-      - reason: 'Forbidden STOPSHIP todo marker in comment, please address the problem before shipping the code.'
-        value: 'STOPSHIP:'
-  WildcardImport:
-    active: true
-  MaxLineLength:
-    active: false
-  MagicNumber:
-    # 100 common in percentage, 1000 in milliseconds
-    ignoreNumbers: ['-1', '0', '1', '2', '5', '10', '100', '256', '512', '1000', '1024', '4096']
-    ignoreEnums: true
-    ignorePropertyDeclaration: true
-  UnnecessaryAbstractClass:
-    active: false
-  ReturnCount:
-    max: 5
-  ForbiddenImport:
-    imports: ['android.app.AlertDialog']
-
-comments:
-  active: true
-  UndocumentedPublicClass:
-    active: false
-    searchInNestedClass: true
-    searchInInnerClass: true
-    searchInInnerInterface: true
-  UndocumentedPublicFunction:
-    active: false

core/cache/build.gradle

@@ -0,0 +1,12 @@
+apply from: bootstrap.kotlinModule
+
+dependencies {
+    api project(':core:domain')
+    api other.twitterSerial
+
+    testImplementation testing.kotlinJunit
+    testImplementation testing.mockito
+    testImplementation testing.mockitoInline
+    testImplementation testing.mockitoKotlin
+    testImplementation testing.kluent
+}

core/cache/src/main/kotlin/org/moire/ultrasonic/cache/Directories.kt

@@ -0,0 +1,14 @@
+package org.moire.ultrasonic.cache
+
+import java.io.File
+
+/**
+ * Provides access to generic directories:
+ * - for temporary caches
+ * - for permanent data storage
+ */
+interface Directories {
+    fun getInternalCacheDir(): File
+    fun getInternalDataDir(): File
+    fun getExternalCacheDir(): File?
+}

core/cache/src/main/kotlin/org/moire/ultrasonic/cache/PermanentFileStorage.kt

@@ -0,0 +1,75 @@
+package org.moire.ultrasonic.cache
+
+import com.twitter.serial.serializer.SerializationContext
+import com.twitter.serial.serializer.Serializer
+import com.twitter.serial.stream.Serial
+import com.twitter.serial.stream.bytebuffer.ByteBufferSerial
+import java.io.File
+
+typealias DomainEntitySerializer<T> = Serializer<T>
+
+internal const val STORAGE_DIR_NAME = "persistent_storage"
+
+/**
+ * Provides access to permanent file based storage.
+ *
+ * [serverId] is currently active server. Should be unique per server so stored data will not
+ * interfere with other server data.
+ *
+ * Look at [org.moire.ultrasonic.cache.serializers] package for available [DomainEntitySerializer]s.
+ */
+class PermanentFileStorage(
+    private val directories: Directories,
+    private val serverId: String,
+    private val debug: Boolean = false
+) {
+    private val serializationContext = object : SerializationContext {
+        override fun isDebug(): Boolean = debug
+        override fun isRelease(): Boolean = !debug
+    }
+
+    private val serializer: Serial = ByteBufferSerial(serializationContext)
+
+    /**
+     * Stores given [objectToStore] using [name] as a key and [objectSerializer] as serializer.
+     */
+    fun <T> store(
+        name: String,
+        objectToStore: T,
+        objectSerializer: DomainEntitySerializer<T>
+    ) {
+        val storeFile = getFile(name)
+        if (!storeFile.exists()) storeFile.createNewFile()
+        storeFile.writeBytes(serializer.toByteArray(objectToStore, objectSerializer))
+    }
+
+    /**
+     * Loads object with [name] key using [objectDeserializer] deserializer.
+     */
+    fun <T> load(
+        name: String,
+        objectDeserializer: DomainEntitySerializer<T>
+    ): T? {
+        val storeFile = getFile(name)
+        if (!storeFile.exists()) return null
+
+        return serializer.fromByteArray(storeFile.readBytes(), objectDeserializer)
+    }
+
+    /**
+     * Clear all files in storage.
+     */
+    fun clearAll() {
+        val storageDir = getStorageDir()
+        storageDir.listFiles().forEach { it.deleteRecursively() }
+    }
+
+    private fun getFile(name: String) = File(getStorageDir(), "$name.ser")
+
+    private fun getStorageDir(): File {
+        val mainDir = File(directories.getInternalDataDir(), STORAGE_DIR_NAME)
+        val serverDir = File(mainDir, serverId)
+        if (!serverDir.exists()) serverDir.mkdirs()
+        return serverDir
+    }
+}

core/cache/src/main/kotlin/org/moire/ultrasonic/cache/serializers/ArtistSerializer.kt

@@ -0,0 +1,65 @@
+@file:JvmMultifileClass
+@file:JvmName("DomainSerializers")
+package org.moire.ultrasonic.cache.serializers
+
+import com.twitter.serial.serializer.CollectionSerializers
+import com.twitter.serial.serializer.ObjectSerializer
+import com.twitter.serial.serializer.SerializationContext
+import com.twitter.serial.stream.SerializerDefs
+import com.twitter.serial.stream.SerializerInput
+import com.twitter.serial.stream.SerializerOutput
+import org.moire.ultrasonic.cache.DomainEntitySerializer
+import org.moire.ultrasonic.domain.Artist
+
+private const val SERIALIZER_VERSION = 1
+
+private val artistSerializer get() = object : ObjectSerializer<Artist>(SERIALIZER_VERSION) {
+    override fun serializeObject(
+        context: SerializationContext,
+        output: SerializerOutput<out SerializerOutput<*>>,
+        item: Artist
+    ) {
+        output.writeString(item.id)
+                .writeString(item.name)
+                .writeString(item.index)
+                .writeString(item.coverArt)
+                .apply {
+                    val albumCount = item.albumCount
+                    if (albumCount != null) writeLong(albumCount) else writeNull()
+                }
+                .writeInt(item.closeness)
+    }
+
+    override fun deserializeObject(
+        context: SerializationContext,
+        input: SerializerInput,
+        versionNumber: Int
+    ): Artist? {
+        if (versionNumber != SERIALIZER_VERSION) return null
+
+        val id = input.readString()
+        val name = input.readString()
+        val index = input.readString()
+        val coverArt = input.readString()
+        val albumCount = if (input.peekType() == SerializerDefs.TYPE_NULL) {
+            input.readNull()
+            null
+        } else {
+            input.readLong()
+        }
+        val closeness = input.readInt()
+        return Artist(id, name, index, coverArt, albumCount, closeness)
+    }
+}
+
+/**
+ * Serializer/deserializer for [Artist] domain entity.
+ */
+fun getArtistsSerializer(): DomainEntitySerializer<Artist> = artistSerializer
+
+private val artistListSerializer = CollectionSerializers.getListSerializer(artistSerializer)
+
+/**
+ * Serializer/deserializer for list of [Artist] domain entities.
+ */
+fun getArtistListSerializer(): DomainEntitySerializer<List<Artist>> = artistListSerializer

core/cache/src/main/kotlin/org/moire/ultrasonic/cache/serializers/IndexesSerializer.kt

@@ -0,0 +1,48 @@
+@file:JvmMultifileClass
+@file:JvmName("DomainSerializers")
+package org.moire.ultrasonic.cache.serializers
+
+import com.twitter.serial.serializer.ObjectSerializer
+import com.twitter.serial.serializer.SerializationContext
+import com.twitter.serial.stream.SerializerInput
+import com.twitter.serial.stream.SerializerOutput
+import org.moire.ultrasonic.cache.DomainEntitySerializer
+import org.moire.ultrasonic.domain.Artist
+import org.moire.ultrasonic.domain.Indexes
+
+private const val SERIALIZATION_VERSION = 1
+
+private val indexesSerializer get() = object : ObjectSerializer<Indexes>(SERIALIZATION_VERSION) {
+    override fun serializeObject(
+        context: SerializationContext,
+        output: SerializerOutput<out SerializerOutput<*>>,
+        item: Indexes
+    ) {
+        val artistListSerializer = getArtistListSerializer()
+        output.writeLong(item.lastModified)
+                .writeString(item.ignoredArticles)
+                .writeObject<MutableList<Artist>>(context, item.shortcuts, artistListSerializer)
+                .writeObject<MutableList<Artist>>(context, item.artists, artistListSerializer)
+    }
+
+    override fun deserializeObject(
+        context: SerializationContext,
+        input: SerializerInput,
+        versionNumber: Int
+    ): Indexes? {
+        if (versionNumber != SERIALIZATION_VERSION) return null
+
+        val artistListDeserializer = getArtistListSerializer()
+        val lastModified = input.readLong()
+        val ignoredArticles = input.readString() ?: return null
+        val shortcutsList = input.readObject(context, artistListDeserializer) ?: return null
+        val artistsList = input.readObject(context, artistListDeserializer) ?: return null
+        return Indexes(lastModified, ignoredArticles, shortcutsList.toMutableList(),
+                artistsList.toMutableList())
+    }
+}
+
+/**
+ * Get serializer/deserializer for [Indexes] entity.
+ */
+fun getIndexesSerializer(): DomainEntitySerializer<Indexes> = indexesSerializer

core/cache/src/main/kotlin/org/moire/ultrasonic/cache/serializers/MusicFolderSerializer.kt

@@ -0,0 +1,50 @@
+@file:JvmMultifileClass
+@file:JvmName("DomainSerializers")
+package org.moire.ultrasonic.cache.serializers
+
+import com.twitter.serial.serializer.CollectionSerializers
+import com.twitter.serial.serializer.ObjectSerializer
+import com.twitter.serial.serializer.SerializationContext
+import com.twitter.serial.stream.SerializerInput
+import com.twitter.serial.stream.SerializerOutput
+import org.moire.ultrasonic.cache.DomainEntitySerializer
+import org.moire.ultrasonic.domain.MusicFolder
+
+private const val SERIALIZATION_VERSION = 1
+
+private val musicFolderSerializer = object : ObjectSerializer<MusicFolder>(SERIALIZATION_VERSION) {
+
+    override fun serializeObject(
+        context: SerializationContext,
+        output: SerializerOutput<out SerializerOutput<*>>,
+        item: MusicFolder
+    ) {
+        output.writeString(item.id).writeString(item.name)
+    }
+
+    override fun deserializeObject(
+        context: SerializationContext,
+        input: SerializerInput,
+        versionNumber: Int
+    ): MusicFolder? {
+        if (versionNumber != SERIALIZATION_VERSION) return null
+
+        val id = input.readString() ?: return null
+        val name = input.readString() ?: return null
+        return MusicFolder(id, name)
+    }
+}
+
+/**
+ * Serializer/deserializer for [MusicFolder] domain entity.
+ */
+fun getMusicFolderSerializer(): DomainEntitySerializer<MusicFolder> = musicFolderSerializer
+
+private val musicFolderListSerializer =
+        CollectionSerializers.getListSerializer(musicFolderSerializer)
+
+/**
+ * Serializer/deserializer for [List] of [MusicFolder] items.
+ */
+fun getMusicFolderListSerializer(): DomainEntitySerializer<List<MusicFolder>> =
+        musicFolderListSerializer

core/cache/src/test/kotlin/org/moire/ultrasonic/cache/BaseStorageTest.kt

@@ -0,0 +1,42 @@
+package org.moire.ultrasonic.cache
+
+import com.nhaarman.mockito_kotlin.mock
+import com.twitter.serial.util.SerializationUtils
+import org.amshove.kluent.`it returns`
+import org.junit.Before
+import org.junit.Rule
+import org.junit.rules.TemporaryFolder
+import java.io.File
+
+internal const val INTERNAL_DATA_FOLDER = "data"
+internal const val INTERNAL_CACHE_FOLDER = "cache"
+internal const val EXTERNAL_CACHE_FOLDER = "external_cache"
+
+/**
+ * Base test class that inits the storage
+ */
+abstract class BaseStorageTest {
+    @get:Rule val tempFileRule = TemporaryFolder()
+
+    protected lateinit var mockDirectories: Directories
+    protected lateinit var storage: PermanentFileStorage
+
+    open val serverId: String = ""
+
+    @Before
+    fun setUp() {
+        mockDirectories = mock<Directories> {
+            on { getInternalDataDir() } `it returns` tempFileRule.newFolder(INTERNAL_DATA_FOLDER)
+            on { getInternalCacheDir() } `it returns` tempFileRule.newFolder(INTERNAL_CACHE_FOLDER)
+            on { getExternalCacheDir() } `it returns` tempFileRule.newFolder(EXTERNAL_CACHE_FOLDER)
+        }
+        storage = PermanentFileStorage(mockDirectories, serverId, true)
+    }
+
+    protected val storageDir get() = File(mockDirectories.getInternalDataDir(), STORAGE_DIR_NAME)
+
+    protected fun validateSerializedData(index: Int = 0) {
+        val serializedFileBytes = storageDir.listFiles()[index].readBytes()
+        SerializationUtils.validateSerializedData(serializedFileBytes)
+    }
+}

core/cache/src/test/kotlin/org/moire/ultrasonic/cache/PermanentFileStorageTest.kt

@@ -0,0 +1,81 @@
+package org.moire.ultrasonic.cache
+
+import org.amshove.kluent.`should be equal to`
+import org.amshove.kluent.`should contain`
+import org.amshove.kluent.`should equal`
+import org.junit.Test
+import org.moire.ultrasonic.cache.serializers.getMusicFolderSerializer
+import org.moire.ultrasonic.domain.MusicFolder
+import java.io.File
+
+/**
+ * Integration test for [PermanentFileStorage].
+ */
+class PermanentFileStorageTest : BaseStorageTest() {
+    override val serverId: String
+        get() = "some-server-id"
+
+    @Test
+    fun `Should create storage dir if it is not exist`() {
+        val item = MusicFolder("1", "2")
+        storage.store("test", item, getMusicFolderSerializer())
+
+        storageDir.exists() `should be equal to` true
+        getServerStorageDir().exists() `should be equal to` true
+    }
+
+    @Test
+    fun `Should serialize to file`() {
+        val item = MusicFolder("1", "23")
+        val name = "some-name"
+
+        storage.store(name, item, getMusicFolderSerializer())
+
+        val storageFiles = getServerStorageDir().listFiles()
+        storageFiles.size `should be equal to` 1
+        storageFiles[0].name `should contain` name
+    }
+
+    @Test
+    fun `Should deserialize stored object`() {
+        val item = MusicFolder("some", "nice")
+        val name = "some-name"
+        storage.store(name, item, getMusicFolderSerializer())
+
+        val loadedItem = storage.load(name, getMusicFolderSerializer())
+
+        loadedItem `should equal` item
+    }
+
+    @Test
+    fun `Should overwrite existing stored object`() {
+        val name = "some-nice-name"
+        val item1 = MusicFolder("1", "1")
+        val item2 = MusicFolder("2", "2")
+        storage.store(name, item1, getMusicFolderSerializer())
+        storage.store(name, item2, getMusicFolderSerializer())
+
+        val loadedItem = storage.load(name, getMusicFolderSerializer())
+
+        loadedItem `should equal` item2
+    }
+
+    @Test
+    fun `Should clear all files when clearAll is called`() {
+        storage.store("name1", MusicFolder("1", "1"), getMusicFolderSerializer())
+        storage.store("name2", MusicFolder("2", "2"), getMusicFolderSerializer())
+
+        storage.clearAll()
+
+        getServerStorageDir().listFiles().size `should be equal to` 0
+    }
+
+    @Test
+    fun `Should return null if serialized file not available`() {
+        val loadedItem = storage.load("some-name", getMusicFolderSerializer())
+
+        loadedItem `should equal` null
+    }
+
+    private fun getServerStorageDir() = File(storageDir, serverId)
+}

core/cache/src/test/kotlin/org/moire/ultrasonic/cache/serializers/ArtistSerializerTest.kt

@@ -0,0 +1,57 @@
+package org.moire.ultrasonic.cache.serializers
+
+import org.amshove.kluent.`should equal`
+import org.junit.Test
+import org.moire.ultrasonic.cache.BaseStorageTest
+import org.moire.ultrasonic.domain.Artist
+
+/**
+ * [Artist] serializers test.
+ */
+class ArtistSerializerTest : BaseStorageTest() {
+    @Test
+    fun `Should correctly serialize Artist object`() {
+        val item = Artist("id", "name", "index", "coverArt", 1, 0)
+
+        storage.store("some-name", item, getArtistsSerializer())
+
+        validateSerializedData()
+    }
+
+    @Test
+    fun `Should correctly deserialize Artist object`() {
+        val itemName = "some-name"
+        val item = Artist("id", "name", "index", "coverArt", null, 0)
+        storage.store(itemName, item, getArtistsSerializer())
+
+        val loadedItem = storage.load(itemName, getArtistsSerializer())
+
+        loadedItem `should equal` item
+    }
+
+    @Test
+    fun `Should correctly serialize list of Artists`() {
+        val itemsList = listOf(
+                Artist(id = "1"),
+                Artist(id = "2", name = "some")
+        )
+
+        storage.store("some-name", itemsList, getArtistListSerializer())
+
+        validateSerializedData()
+    }
+
+    @Test
+    fun `Should correctly deserialize list of Artists`() {
+        val name = "some-name"
+        val itemsList = listOf(
+                Artist(id = "1"),
+                Artist(id = "2", name = "some")
+        )
+        storage.store(name, itemsList, getArtistListSerializer())
+
+        val loadedItems = storage.load(name, getArtistListSerializer())
+
+        loadedItems `should equal` itemsList
+    }
+}

core/cache/src/test/kotlin/org/moire/ultrasonic/cache/serializers/IndexesSerializerTest.kt

@@ -0,0 +1,40 @@
+package org.moire.ultrasonic.cache.serializers
+
+import org.amshove.kluent.`should equal`
+import org.junit.Test
+import org.moire.ultrasonic.cache.BaseStorageTest
+import org.moire.ultrasonic.domain.Artist
+import org.moire.ultrasonic.domain.Indexes
+
+/**
+ * Test [Indexes] domain entity serializer.
+ */
+class IndexesSerializerTest : BaseStorageTest() {
+    @Test
+    fun `Should correctly serialize Indexes object`() {
+        val item = Indexes(220L, "", mutableListOf(
+                Artist("12")
+        ), mutableListOf(
+                Artist("233", "some")
+        ))
+
+        storage.store("some-name", item, getIndexesSerializer())
+
+        validateSerializedData()
+    }
+
+    @Test
+    fun `Should correctly deserialize Indexes object`() {
+        val name = "some-name"
+        val item = Indexes(220L, "", mutableListOf(
+                Artist("12")
+        ), mutableListOf(
+                Artist("233", "some")
+        ))
+        storage.store(name, item, getIndexesSerializer())
+
+        val loadedItem = storage.load(name, getIndexesSerializer())
+
+        loadedItem `should equal` item
+    }
+}

core/cache/src/test/kotlin/org/moire/ultrasonic/cache/serializers/MusicFolderSerializerTest.kt

@@ -0,0 +1,57 @@
+package org.moire.ultrasonic.cache.serializers
+
+import org.amshove.kluent.`should equal`
+import org.junit.Test
+import org.moire.ultrasonic.cache.BaseStorageTest
+import org.moire.ultrasonic.domain.MusicFolder
+
+/**
+ * [MusicFolder] serializers test.
+ */
+class MusicFolderSerializerTest : BaseStorageTest() {
+    @Test
+    fun `Should correctly serialize MusicFolder object`() {
+        val item = MusicFolder("Music", "Folder")
+
+        storage.store("some-name", item, getMusicFolderSerializer())
+
+        validateSerializedData()
+    }
+
+    @Test
+    fun `Should correctly deserialize MusicFolder object`() {
+        val name = "name"
+        val item = MusicFolder("some", "none")
+        storage.store(name, item, getMusicFolderSerializer())
+
+        val loadedItem = storage.load(name, getMusicFolderSerializer())
+
+        loadedItem `should equal` item
+    }
+
+    @Test
+    fun `Should correctly serialize list of MusicFolders objects`() {
+        val itemsList = listOf(
+                MusicFolder("1", "1"),
+                MusicFolder("2", "2")
+        )
+
+        storage.store("some-name", itemsList, getMusicFolderListSerializer())
+
+        validateSerializedData()
+    }
+
+    @Test
+    fun `Should correctly deserialize list of MusicFolder objects`() {
+        val name = "some-name"
+        val itemsList = listOf(
+                MusicFolder("1", "1"),
+                MusicFolder("2", "2")
+        )
+        storage.store(name, itemsList, getMusicFolderListSerializer())
+
+        val loadedItem = storage.load(name, getMusicFolderListSerializer())
+
+        loadedItem `should equal` itemsList
+    }
+}

core/domain/build.gradle

@@ -1,20 +1,10 @@
-plugins {
-    alias libs.plugins.ksp
+apply from: bootstrap.kotlinModule
+
+ext {
+    jacocoExclude = [
+            '**/domain/**'
+    ]
 }
-
-apply from: bootstrap.androidModule
-
 dependencies {
-    implementation libs.core
-    implementation libs.roomRuntime
-    implementation libs.roomKtx
-    ksp libs.room
-}
-
-android {
-    namespace = 'org.moire.ultrasonic.subsonic.domain'
-    compileOptions {
-        sourceCompatibility JavaVersion.VERSION_21
-        targetCompatibility JavaVersion.VERSION_21
-    }
+    api other.semver
 }

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Album.kt

@@ -1,38 +0,0 @@
-/*
- * Album.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
-package org.moire.ultrasonic.domain
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import java.util.Date
-
-@Entity(tableName = "albums", primaryKeys = ["id", "serverId"])
-data class Album(
-    override var id: String,
-    @ColumnInfo(defaultValue = "-1")
-    override var serverId: Int = -1,
-    override var parent: String? = null,
-    override var album: String? = null,
-    override var title: String? = null,
-    override val name: String? = null,
-    override var discNumber: Int? = 0,
-    override var coverArt: String? = null,
-    override var songCount: Long? = null,
-    override var created: Date? = null,
-    override var artist: String? = null,
-    override var artistId: String? = null,
-    override var duration: Int? = 0,
-    override var year: Int? = 0,
-    override var genre: String? = null,
-    override var starred: Boolean = false,
-    override var path: String? = null,
-    override var closeness: Int = 0
-) : MusicDirectory.Child() {
-    override var isDirectory = true
-    override var isVideo = false
-}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Artist.kt

@@ -1,23 +1,16 @@
-/*
- * Artist.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
 package org.moire.ultrasonic.domain
 
-import androidx.room.ColumnInfo
-import androidx.room.Entity
+import java.io.Serializable
 
-@Entity(tableName = "artists", primaryKeys = ["id", "serverId"])
 data class Artist(
-    override var id: String,
-    @ColumnInfo(defaultValue = "-1")
-    override var serverId: Int = -1,
-    override var name: String? = null,
-    override var index: String? = null,
-    override var coverArt: String? = null,
-    override var albumCount: Long? = null,
-    override var closeness: Int = 0
-) : ArtistOrIndex(id, serverId)
+    var id: String? = null,
+    var name: String? = null,
+    var index: String? = null,
+    var coverArt: String? = null,
+    var albumCount: Long? = null,
+    var closeness: Int = 0
+) : Serializable {
+    companion object {
+        private const val serialVersionUID = -5790532593784846982L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/ArtistOrIndex.kt

@@ -1,45 +0,0 @@
-/*
- * ArtistOrIndex.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
-package org.moire.ultrasonic.domain
-
-import androidx.room.Ignore
-
-@Suppress("LongParameterList")
-abstract class ArtistOrIndex(
-    @Ignore
-    override var id: String,
-    @Ignore
-    open var serverId: Int,
-    @Ignore
-    override var name: String? = null,
-    @Ignore
-    open var index: String? = null,
-    @Ignore
-    open var coverArt: String? = null,
-    @Ignore
-    open var albumCount: Long? = null,
-    @Ignore
-    open var closeness: Int = 0
-) : GenericEntry() {
-
-    fun compareTo(other: ArtistOrIndex): Int {
-        return when {
-            this.closeness == other.closeness -> {
-                0
-            }
-            this.closeness > other.closeness -> {
-                -1
-            }
-            else -> {
-                1
-            }
-        }
-    }
-
-    override fun compareTo(other: Identifiable) = compareTo(other as ArtistOrIndex)
-}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Bookmark.kt

@@ -1,5 +1,7 @@
 package org.moire.ultrasonic.domain
 
+import org.moire.ultrasonic.domain.MusicDirectory.Entry
+
 import java.io.Serializable
 import java.util.Date
 
@@ -9,7 +11,7 @@ data class Bookmark(
     val comment: String,
     val created: Date? = null,
     val changed: Date? = null,
-    val track: Track
+    val entry: Entry
 ) : Serializable {
     companion object {
         private const val serialVersionUID = 8988990025189807803L

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Genre.kt

@@ -1,13 +1,10 @@
 package org.moire.ultrasonic.domain
 
-import androidx.room.Entity
-import androidx.room.PrimaryKey
 import java.io.Serializable
 
-@Entity
 data class Genre(
-    @PrimaryKey val index: String,
-    val name: String
+    val name: String,
+    val index: String
 ) : Serializable {
     companion object {
         private const val serialVersionUID = -3943025175219134028L

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Identifiable.kt

@@ -1,19 +0,0 @@
-package org.moire.ultrasonic.domain
-
-import androidx.room.Ignore
-
-abstract class GenericEntry : Identifiable {
-    @Ignore
-    open val name: String? = null
-}
-
-interface Identifiable : Comparable<Identifiable> {
-    val id: String
-
-    val longId: Long
-        get() = id.hashCode().toLong()
-
-    override fun compareTo(other: Identifiable): Int {
-        return longId.compareTo(other.longId)
-    }
-}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Index.kt

@@ -1,24 +0,0 @@
-/*
- * Index.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
-package org.moire.ultrasonic.domain
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-
-@Entity(tableName = "indexes", primaryKeys = ["id", "serverId"])
-data class Index(
-    override var id: String,
-    @ColumnInfo(defaultValue = "-1")
-    override var serverId: Int = -1,
-    override var name: String? = null,
-    override var index: String? = null,
-    override var coverArt: String? = null,
-    override var albumCount: Long? = null,
-    override var closeness: Int = 0,
-    var musicFolderId: String? = null
-) : ArtistOrIndex(id, serverId)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Indexes.kt

@@ -0,0 +1,14 @@
+package org.moire.ultrasonic.domain
+
+import java.io.Serializable
+
+data class Indexes(
+    val lastModified: Long,
+    val ignoredArticles: String,
+    val shortcuts: MutableList<Artist> = mutableListOf(),
+    val artists: MutableList<Artist> = mutableListOf()
+) : Serializable {
+    companion object {
+        private const val serialVersionUID = 8156117238598414701L
+    }
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/MusicDirectory.kt

@@ -1,58 +1,78 @@
-/*
- * MusicDirectory.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
 package org.moire.ultrasonic.domain
 
+import java.io.Serializable
 import java.util.Date
 
-class MusicDirectory : ArrayList<MusicDirectory.Child>() {
+class MusicDirectory {
     var name: String? = null
+    private val children = mutableListOf<Entry>()
+
+    fun addAll(entries: Collection<Entry>) {
+        children.addAll(entries)
+    }
+
+    fun addFirst(child: Entry) {
+        children.add(0, child)
+    }
+
+    fun addChild(child: Entry) {
+        children.add(child)
+    }
+
+    fun findChild(id: String): Entry? = children.lastOrNull { it.id == id }
+
+    fun getAllChild(): List<Entry> = children.toList()
 
     @JvmOverloads
-    fun getChildren(includeDirs: Boolean = true, includeFiles: Boolean = true): List<Child> {
+    fun getChildren(
+        includeDirs: Boolean = true,
+        includeFiles: Boolean = true
+    ): List<Entry> {
         if (includeDirs && includeFiles) {
-            return toList()
+            return children
         }
 
-        return filter { it.isDirectory && includeDirs || !it.isDirectory && includeFiles }
+        return children.filter { it.isDirectory && includeDirs || !it.isDirectory && includeFiles }
     }
 
-    fun getTracks(): List<Track> {
-        return mapNotNull {
-            it as? Track
+    data class Entry(
+        var id: String? = null,
+        var parent: String? = null,
+        var isDirectory: Boolean = false,
+        var title: String? = null,
+        var album: String? = null,
+        var albumId: String? = null,
+        var artist: String? = null,
+        var artistId: String? = null,
+        var track: Int? = 0,
+        var year: Int? = 0,
+        var genre: String? = null,
+        var contentType: String? = null,
+        var suffix: String? = null,
+        var transcodedContentType: String? = null,
+        var transcodedSuffix: String? = null,
+        var coverArt: String? = null,
+        var size: Long? = null,
+        var songCount: Long? = null,
+        var duration: Int? = null,
+        var bitRate: Int? = null,
+        var path: String? = null,
+        var isVideo: Boolean = false,
+        var starred: Boolean = false,
+        var discNumber: Int? = null,
+        var type: String? = null,
+        var created: Date? = null,
+        var closeness: Int = 0,
+        var bookmarkPosition: Int = 0,
+        var userRating: Int? = null,
+        var averageRating: Float? = null
+    ) : Serializable {
+        fun setDuration(duration: Long) {
+            this.duration = duration.toInt()
         }
-    }
 
-    fun getAlbums(): List<Album> {
-        return mapNotNull {
-            it as? Album
+        companion object {
+            private const val serialVersionUID = -3339106650010798108L
         }
     }
-
-    abstract class Child : GenericEntry() {
-        abstract override var id: String
-        abstract var serverId: Int
-        abstract var parent: String?
-        abstract var isDirectory: Boolean
-        abstract var album: String?
-        abstract var title: String?
-        abstract override val name: String?
-        abstract var discNumber: Int?
-        abstract var coverArt: String?
-        abstract var songCount: Long?
-        abstract var created: Date?
-        abstract var artist: String?
-        abstract var artistId: String?
-        abstract var duration: Int?
-        abstract var year: Int?
-        abstract var genre: String?
-        abstract var starred: Boolean
-        abstract var path: String?
-        abstract var closeness: Int
-        abstract var isVideo: Boolean
-    }
 }

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/MusicFolder.kt

@@ -1,22 +1,9 @@
-/*
- * MusicFolder.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
 package org.moire.ultrasonic.domain
 
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-
 /**
  * Represents a top level directory in which music or other media is stored.
  */
-@Entity(tableName = "music_folders", primaryKeys = ["id", "serverId"])
 data class MusicFolder(
-    override val id: String,
-    override val name: String,
-    @ColumnInfo(defaultValue = "-1")
-    var serverId: Int
-) : GenericEntry()
+    val id: String,
+    val name: String
+)

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/PlayerState.kt

@@ -0,0 +1,12 @@
+package org.moire.ultrasonic.domain
+
+enum class PlayerState {
+    IDLE,
+    DOWNLOADING,
+    PREPARING,
+    PREPARED,
+    STARTED,
+    STOPPED,
+    PAUSED,
+    COMPLETED
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Playlist.kt

@@ -3,19 +3,15 @@ package org.moire.ultrasonic.domain
 import java.io.Serializable
 
 data class Playlist @JvmOverloads constructor(
-    override val id: String,
-    override var name: String,
+    val id: String,
+    var name: String,
     val owner: String = "",
     val comment: String = "",
     val songCount: String = "",
     val created: String = "",
     val public: Boolean? = null
-) : Serializable, GenericEntry() {
+) : Serializable {
     companion object {
         private const val serialVersionUID = -4160515427075433798L
     }
-
-    override fun toString(): String {
-        return name
-    }
 }

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/PodcastsChannel.kt

@@ -3,15 +3,13 @@ package org.moire.ultrasonic.domain
 import java.io.Serializable
 
 data class PodcastsChannel(
-    override val id: String,
+    val id: String,
     val title: String?,
     val url: String?,
     val description: String?,
     val status: String?
-) : Serializable, GenericEntry() {
+) : Serializable {
     companion object {
         private const val serialVersionUID = -4160515427075433798L
     }
-
-    override fun toString(): String = title.toString()
 }

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/RepeatMode.kt

@@ -0,0 +1,15 @@
+package org.moire.ultrasonic.domain
+
+enum class RepeatMode {
+    OFF {
+        override operator fun next(): RepeatMode = ALL
+    },
+    ALL {
+        override operator fun next(): RepeatMode = SINGLE
+    },
+    SINGLE {
+        override operator fun next(): RepeatMode = OFF
+    };
+
+    abstract operator fun next(): RepeatMode
+}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/SearchResult.kt

@@ -1,10 +1,12 @@
 package org.moire.ultrasonic.domain
 
+import org.moire.ultrasonic.domain.MusicDirectory.Entry
+
 /**
  * The result of a search.  Contains matching artists, albums and songs.
  */
 data class SearchResult(
-    val artists: List<ArtistOrIndex> = listOf(),
-    val albums: List<Album> = listOf(),
-    val songs: List<Track> = listOf()
+    val artists: List<Artist>,
+    val albums: List<Entry>,
+    val songs: List<Entry>
 )

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Share.kt

@@ -1,9 +1,10 @@
 package org.moire.ultrasonic.domain
 
+import org.moire.ultrasonic.domain.MusicDirectory.Entry
 import java.io.Serializable
 
 data class Share(
-    override var id: String,
+    var id: String? = null,
     var url: String? = null,
     var description: String? = null,
     var username: String? = null,
@@ -11,22 +12,17 @@ data class Share(
     var lastVisited: String? = null,
     var expires: String? = null,
     var visitCount: Long? = null,
-    private val tracks: MutableList<Track> = mutableListOf()
-) : Serializable, GenericEntry() {
-    override val name: String?
-        get() {
-            if (url != null) {
-                return urlPattern.matcher(url!!).replaceFirst("$1")
-            }
-            return null
-        }
+    private val entries: MutableList<Entry> = mutableListOf()
+) : Serializable {
+    val name: String?
+        get() = url?.let { urlPattern.matcher(url).replaceFirst("$1") }
 
-    fun getEntries(): List<Track> {
-        return tracks.toList()
+    fun getEntries(): List<Entry> {
+        return entries.toList()
     }
 
-    fun addEntry(track: Track) {
-        tracks.add(track)
+    fun addEntry(entry: Entry) {
+        entries.add(entry)
     }
 
     companion object {

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Track.kt

@@ -1,74 +0,0 @@
-/*
- * Track.kt
- * Copyright (C) 2009-2022 Ultrasonic developers
- *
- * Distributed under terms of the GNU GPLv3 license.
- */
-
-package org.moire.ultrasonic.domain
-
-import androidx.room.ColumnInfo
-import androidx.room.Entity
-import java.io.Serializable
-import java.util.Date
-
-@Entity(tableName = "tracks", primaryKeys = ["id", "serverId"])
-data class Track(
-    override var id: String,
-    @ColumnInfo(defaultValue = "-1")
-    override var serverId: Int = -1,
-    override var parent: String? = null,
-    override var isDirectory: Boolean = false,
-    override var title: String? = null,
-    override var album: String? = null,
-    var albumId: String? = null,
-    override var artist: String? = null,
-    override var artistId: String? = null,
-    var track: Int? = null,
-    override var year: Int? = null,
-    override var genre: String? = null,
-    var contentType: String? = null,
-    var suffix: String? = null,
-    var transcodedContentType: String? = null,
-    var transcodedSuffix: String? = null,
-    override var coverArt: String? = null,
-    var size: Long? = null,
-    override var songCount: Long? = null,
-    override var duration: Int? = null,
-    var bitRate: Int? = null,
-    override var path: String? = null,
-    override var isVideo: Boolean = false,
-    override var starred: Boolean = false,
-    override var discNumber: Int? = null,
-    var type: String? = null,
-    override var created: Date? = null,
-    override var closeness: Int = 0,
-    var bookmarkPosition: Int = 0,
-    var userRating: Int? = null,
-    var averageRating: Float? = null,
-    override var name: String? = null
-) : Serializable, MusicDirectory.Child() {
-    fun setDuration(duration: Long) {
-        this.duration = duration.toInt()
-    }
-
-    companion object {
-        private const val serialVersionUID = -3339106650010798108L
-    }
-
-    fun compareTo(other: Track): Int {
-        return when {
-            this.closeness == other.closeness -> {
-                0
-            }
-            this.closeness > other.closeness -> {
-                -1
-            }
-            else -> {
-                1
-            }
-        }
-    }
-
-    override fun compareTo(other: Identifiable) = compareTo(other as Track)
-}

core/domain/src/main/kotlin/org/moire/ultrasonic/domain/Version.kt

@@ -0,0 +1,27 @@
+package org.moire.ultrasonic.domain
+
+import net.swiftzer.semver.SemVer
+
+/**
+ * Represents the version number of the Subsonic Android app.
+ */
+data class Version(
+    val version: SemVer
+) : Comparable<Version> {
+
+    override fun compareTo(other: Version): Int {
+        return version.compareTo(other.version)
+    }
+
+    companion object {
+        /**
+         * Creates a new version instance by parsing the given string.
+         *
+         * @param version A string of the format "1.27", "1.27.2" or "1.27.beta3".
+         */
+        @JvmStatic
+        fun fromCharSequence(version: String): Version {
+            return Version(SemVer.parse(version))
+        }
+    }
+}

core/library/build.gradle

@@ -0,0 +1,13 @@
+apply from: bootstrap.androidModule
+apply plugin: 'com.android.library'
+
+android {
+    lintOptions {
+        baselineFile file("lint-baseline.xml")
+        abortOnError true
+    }
+}
+
+dependencies {
+    api androidSupport.support
+}

core/library/lint-baseline.xml

@@ -0,0 +1,59 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="4" by="lint 2.3.3">
+
+    <issue
+        id="NewApi"
+        message="Call requires API level 21 (current min is 14): android.widget.AbsListView#setSelectionFromTop"
+        errorLine1="            setSelectionFromTop(movePos, top - padTop);"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/mobeta/android/dslv/DragSortListView.java"
+            line="2936"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="OldTargetApi"
+        message="Not targeting the latest versions of Android; compatibility modes apply. Consider testing and updating this version. Consult the `android.os.Build.VERSION_CODES` javadoc for details."
+        errorLine1="    &lt;uses-sdk android:targetSdkVersion=&quot;7&quot;"
+        errorLine2="              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="6"
+            column="15"/>
+    </issue>
+
+    <issue
+        id="GradleOverrides"
+        message="This `targetSdkVersion` value (`7`) is not used; it is always overridden by the value specified in the Gradle build script (`22`)"
+        errorLine1="    &lt;uses-sdk android:targetSdkVersion=&quot;7&quot;"
+        errorLine2="              ~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="6"
+            column="15"/>
+    </issue>
+
+    <issue
+        id="GradleOverrides"
+        message="This `minSdkVersion` value (`7`) is not used; it is always overridden by the value specified in the Gradle build script (`14`)"
+        errorLine1="      android:minSdkVersion=&quot;7&quot; />"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ClickableViewAccessibility"
+        message="`com/mobeta/android/dslv/DragSortController#onTouch` should call `View#performClick` when a click is detected"
+        errorLine1="    public boolean onTouch(View v, MotionEvent ev) {"
+        errorLine2="                   ~~~~~~~">
+        <location
+            file="src/main/java/com/mobeta/android/dslv/DragSortController.java"
+            line="238"
+            column="20"/>
+    </issue>
+
+</issues>

core/library/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="com.mobeta.android.dslv"
+      android:versionCode="4"
+      android:versionName="0.6.1">
+</manifest>

core/library/src/main/java/com/mobeta/android/dslv/DragSortController.java

@@ -0,0 +1,468 @@
+package com.mobeta.android.dslv;
+
+import android.graphics.Point;
+import android.view.GestureDetector;
+import android.view.HapticFeedbackConstants;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.widget.AdapterView;
+
+/**
+ * Class that starts and stops item drags on a {@link DragSortListView}
+ * based on touch gestures. This class also inherits from
+ * {@link SimpleFloatViewManager}, which provides basic float View
+ * creation.
+ *
+ * An instance of this class is meant to be passed to the methods
+ * {@link DragSortListView#setTouchListener()} and
+ * {@link DragSortListView#setFloatViewManager()} of your
+ * {@link DragSortListView} instance.
+ */
+public class DragSortController extends SimpleFloatViewManager implements View.OnTouchListener, GestureDetector.OnGestureListener {
+
+    /**
+     * Drag init mode enum.
+     */
+    public static final int ON_DOWN = 0;
+    public static final int ON_DRAG = 1;
+    public static final int ON_LONG_PRESS = 2;
+
+    private int mDragInitMode = ON_DOWN;
+
+    private boolean mSortEnabled = true;
+
+    /**
+     * Remove mode enum.
+     */
+    public static final int CLICK_REMOVE = 0;
+    public static final int FLING_REMOVE = 1;
+
+    /**
+     * The current remove mode.
+     */
+    private int mRemoveMode;
+
+    private boolean mRemoveEnabled = false;
+    private boolean mIsRemoving = false;
+
+    private GestureDetector mDetector;
+
+    private GestureDetector mFlingRemoveDetector;
+
+    private int mTouchSlop;
+
+    public static final int MISS = -1;
+
+    private int mHitPos = MISS;
+    private int mFlingHitPos = MISS;
+
+    private int mClickRemoveHitPos = MISS;
+
+    private int[] mTempLoc = new int[2];
+
+    private int mItemX;
+    private int mItemY;
+
+    private int mCurrX;
+    private int mCurrY;
+
+    private boolean mDragging = false;
+
+    private float mFlingSpeed = 500f;
+
+    private int mDragHandleId;
+
+    private int mClickRemoveId;
+
+    private int mFlingHandleId;
+    private boolean mCanDrag;
+
+    private DragSortListView mDslv;
+    private int mPositionX;
+
+    /**
+     * Calls {@link #DragSortController(DragSortListView, int)} with a
+     * 0 drag handle id, FLING_RIGHT_REMOVE remove mode,
+     * and ON_DOWN drag init. By default, sorting is enabled, and
+     * removal is disabled.
+     *
+     * @param dslv The DSLV instance
+     */
+    public DragSortController(DragSortListView dslv) {
+        this(dslv, 0, ON_DOWN, FLING_REMOVE);
+    }
+
+    public DragSortController(DragSortListView dslv, int dragHandleId, int dragInitMode, int removeMode) {
+        this(dslv, dragHandleId, dragInitMode, removeMode, 0);
+    }
+
+    public DragSortController(DragSortListView dslv, int dragHandleId, int dragInitMode, int removeMode, int clickRemoveId) {
+        this(dslv, dragHandleId, dragInitMode, removeMode, clickRemoveId, 0);
+    }
+
+    /**
+     * By default, sorting is enabled, and removal is disabled.
+     *
+     * @param dslv The DSLV instance
+     * @param dragHandleId The resource id of the View that represents
+     * the drag handle in a list item.
+     */
+    public DragSortController(DragSortListView dslv, int dragHandleId, int dragInitMode,
+            int removeMode, int clickRemoveId, int flingHandleId) {
+        super(dslv);
+        mDslv = dslv;
+        mDetector = new GestureDetector(dslv.getContext(), this);
+        mFlingRemoveDetector = new GestureDetector(dslv.getContext(), mFlingRemoveListener);
+        mFlingRemoveDetector.setIsLongpressEnabled(false);
+        mTouchSlop = ViewConfiguration.get(dslv.getContext()).getScaledTouchSlop();
+        mDragHandleId = dragHandleId;
+        mClickRemoveId = clickRemoveId;
+        mFlingHandleId = flingHandleId;
+        setRemoveMode(removeMode);
+        setDragInitMode(dragInitMode);
+    }
+
+
+    public int getDragInitMode() {
+        return mDragInitMode;
+    }
+
+    /**
+     * Set how a drag is initiated. Needs to be one of
+     * {@link ON_DOWN}, {@link ON_DRAG}, or {@link ON_LONG_PRESS}.
+     *
+     * @param mode The drag init mode.
+     */
+    public void setDragInitMode(int mode) {
+        mDragInitMode = mode;
+    }
+
+    /**
+     * Enable/Disable list item sorting. Disabling is useful if only item
+     * removal is desired. Prevents drags in the vertical direction.
+     *
+     * @param enabled Set <code>true</code> to enable list
+     * item sorting.
+     */
+    public void setSortEnabled(boolean enabled) {
+        mSortEnabled = enabled;
+    }
+
+    public boolean isSortEnabled() {
+        return mSortEnabled;
+    }
+
+    /**
+     * One of {@link CLICK_REMOVE}, {@link FLING_RIGHT_REMOVE},
+     * {@link FLING_LEFT_REMOVE},
+     * {@link SLIDE_RIGHT_REMOVE}, or {@link SLIDE_LEFT_REMOVE}.
+     */
+    public void setRemoveMode(int mode) {
+        mRemoveMode = mode;
+    }
+
+    public int getRemoveMode() {
+        return mRemoveMode;
+    }
+
+    /**
+     * Enable/Disable item removal without affecting remove mode.
+     */
+    public void setRemoveEnabled(boolean enabled) {
+        mRemoveEnabled = enabled;
+    }
+
+    public boolean isRemoveEnabled() {
+        return mRemoveEnabled;
+    }
+
+    /**
+     * Set the resource id for the View that represents the drag
+     * handle in a list item.
+     *
+     * @param id An android resource id.
+     */
+    public void setDragHandleId(int id) {
+        mDragHandleId = id;
+    }
+
+    /**
+     * Set the resource id for the View that represents the fling
+     * handle in a list item.
+     *
+     * @param id An android resource id.
+     */
+    public void setFlingHandleId(int id) {
+        mFlingHandleId = id;
+    }
+
+    /**
+     * Set the resource id for the View that represents click
+     * removal button.
+     *
+     * @param id An android resource id.
+     */
+    public void setClickRemoveId(int id) {
+        mClickRemoveId = id;
+    }
+
+    /**
+     * Sets flags to restrict certain motions of the floating View
+     * based on DragSortController settings (such as remove mode).
+     * Starts the drag on the DragSortListView.
+     *
+     * @param position The list item position (includes headers).
+     * @param deltaX Touch x-coord minus left edge of floating View.
+     * @param deltaY Touch y-coord minus top edge of floating View.
+     *
+     * @return True if drag started, false otherwise.
+     */
+    public boolean startDrag(int position, int deltaX, int deltaY) {
+
+        int dragFlags = 0;
+        if (mSortEnabled && !mIsRemoving) {
+            dragFlags |= DragSortListView.DRAG_POS_Y | DragSortListView.DRAG_NEG_Y;
+        }
+        if (mRemoveEnabled && mIsRemoving) {
+            dragFlags |= DragSortListView.DRAG_POS_X;
+            dragFlags |= DragSortListView.DRAG_NEG_X;
+        }
+
+        mDragging = mDslv.startDrag(position - mDslv.getHeaderViewsCount(), dragFlags, deltaX,
+                deltaY);
+        return mDragging;
+    }
+
+    @Override
+    public boolean onTouch(View v, MotionEvent ev) {
+        if (!mDslv.isDragEnabled() || mDslv.listViewIntercepted()) {
+            return false;
+        }
+
+        mDetector.onTouchEvent(ev);
+        if (mRemoveEnabled && mDragging && mRemoveMode == FLING_REMOVE) {
+            mFlingRemoveDetector.onTouchEvent(ev);
+        }
+
+        int action = ev.getAction() & MotionEvent.ACTION_MASK;
+        switch (action) {
+            case MotionEvent.ACTION_DOWN:
+                mCurrX = (int) ev.getX();
+                mCurrY = (int) ev.getY();
+                break;
+            case MotionEvent.ACTION_UP:
+                if (mRemoveEnabled && mIsRemoving) {
+                    int x = mPositionX >= 0 ? mPositionX : -mPositionX;
+                    int removePoint = mDslv.getWidth() / 2;
+                    if (x > removePoint) {
+                        mDslv.stopDragWithVelocity(true, 0);
+                    }
+                }
+            case MotionEvent.ACTION_CANCEL:
+                mIsRemoving = false;
+                mDragging = false;
+                break;
+        }
+
+        return false;
+    }
+
+    /**
+     * Overrides to provide fading when slide removal is enabled.
+     */
+    @Override
+    public void onDragFloatView(View floatView, Point position, Point touch) {
+
+        if (mRemoveEnabled && mIsRemoving) {
+            mPositionX = position.x;
+        }
+    }
+
+    /**
+     * Get the position to start dragging based on the ACTION_DOWN
+     * MotionEvent. This function simply calls
+     * {@link #dragHandleHitPosition(MotionEvent)}. Override
+     * to change drag handle behavior;
+     * this function is called internally when an ACTION_DOWN
+     * event is detected.
+     *
+     * @param ev The ACTION_DOWN MotionEvent.
+     *
+     * @return The list position to drag if a drag-init gesture is
+     * detected; MISS if unsuccessful.
+     */
+    public int startDragPosition(MotionEvent ev) {
+        return dragHandleHitPosition(ev);
+    }
+
+    public int startFlingPosition(MotionEvent ev) {
+        return mRemoveMode == FLING_REMOVE ? flingHandleHitPosition(ev) : MISS;
+    }
+
+    /**
+     * Checks for the touch of an item's drag handle (specified by
+     * {@link #setDragHandleId(int)}), and returns that item's position
+     * if a drag handle touch was detected.
+     *
+     * @param ev The ACTION_DOWN MotionEvent.
+
+     * @return The list position of the item whose drag handle was
+     * touched; MISS if unsuccessful.
+     */
+    public int dragHandleHitPosition(MotionEvent ev) {
+        return viewIdHitPosition(ev, mDragHandleId);
+    }
+
+    public int flingHandleHitPosition(MotionEvent ev) {
+        return viewIdHitPosition(ev, mFlingHandleId);
+    }
+
+    public int viewIdHitPosition(MotionEvent ev, int id) {
+        final int x = (int) ev.getX();
+        final int y = (int) ev.getY();
+
+        int touchPos = mDslv.pointToPosition(x, y); // includes headers/footers
+
+        final int numHeaders = mDslv.getHeaderViewsCount();
+        final int numFooters = mDslv.getFooterViewsCount();
+        final int count = mDslv.getCount();
+
+        // Log.d("mobeta", "touch down on position " + itemnum);
+        // We're only interested if the touch was on an
+        // item that's not a header or footer.
+        if (touchPos != AdapterView.INVALID_POSITION && touchPos >= numHeaders
+                && touchPos < (count - numFooters)) {
+            final View item = mDslv.getChildAt(touchPos - mDslv.getFirstVisiblePosition());
+            final int rawX = (int) ev.getRawX();
+            final int rawY = (int) ev.getRawY();
+
+            View dragBox = id == 0 ? item : (View) item.findViewById(id);
+            if (dragBox != null) {
+                dragBox.getLocationOnScreen(mTempLoc);
+
+                if (rawX > mTempLoc[0] && rawY > mTempLoc[1] &&
+                        rawX < mTempLoc[0] + dragBox.getWidth() &&
+                        rawY < mTempLoc[1] + dragBox.getHeight()) {
+
+                    mItemX = item.getLeft();
+                    mItemY = item.getTop();
+
+                    return touchPos;
+                }
+            }
+        }
+
+        return MISS;
+    }
+
+    @Override
+    public boolean onDown(MotionEvent ev) {
+        if (mRemoveEnabled && mRemoveMode == CLICK_REMOVE) {
+            mClickRemoveHitPos = viewIdHitPosition(ev, mClickRemoveId);
+        }
+
+        mHitPos = startDragPosition(ev);
+        if (mHitPos != MISS && mDragInitMode == ON_DOWN) {
+            startDrag(mHitPos, (int) ev.getX() - mItemX, (int) ev.getY() - mItemY);
+        }
+
+        mIsRemoving = false;
+        mCanDrag = true;
+        mPositionX = 0;
+        mFlingHitPos = startFlingPosition(ev);
+
+        return true;
+    }
+
+    @Override
+    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
+
+        final int x1 = (int) e1.getX();
+        final int y1 = (int) e1.getY();
+        final int x2 = (int) e2.getX();
+        final int y2 = (int) e2.getY();
+        final int deltaX = x2 - mItemX;
+        final int deltaY = y2 - mItemY;
+
+        if (mCanDrag && !mDragging && (mHitPos != MISS || mFlingHitPos != MISS)) {
+            if (mHitPos != MISS) {
+                if (mDragInitMode == ON_DRAG && Math.abs(y2 - y1) > mTouchSlop && mSortEnabled) {
+                    startDrag(mHitPos, deltaX, deltaY);
+                }
+                else if (mDragInitMode != ON_DOWN && Math.abs(x2 - x1) > mTouchSlop && mRemoveEnabled)
+                {
+                    mIsRemoving = true;
+                    startDrag(mFlingHitPos, deltaX, deltaY);
+                }
+            } else if (mFlingHitPos != MISS) {
+                if (Math.abs(x2 - x1) > mTouchSlop && mRemoveEnabled) {
+                    mIsRemoving = true;
+                    startDrag(mFlingHitPos, deltaX, deltaY);
+                } else if (Math.abs(y2 - y1) > mTouchSlop) {
+                    mCanDrag = false; // if started to scroll the list then
+                                      // don't allow sorting nor fling-removing
+                }
+            }
+        }
+        // return whatever
+        return false;
+    }
+
+    @Override
+    public void onLongPress(MotionEvent e) {
+        // Log.d("mobeta", "lift listener long pressed");
+        if (mHitPos != MISS && mDragInitMode == ON_LONG_PRESS) {
+            mDslv.performHapticFeedback(HapticFeedbackConstants.LONG_PRESS);
+            startDrag(mHitPos, mCurrX - mItemX, mCurrY - mItemY);
+        }
+    }
+
+    // complete the OnGestureListener interface
+    @Override
+    public final boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
+        return false;
+    }
+
+    // complete the OnGestureListener interface
+    @Override
+    public boolean onSingleTapUp(MotionEvent ev) {
+        if (mRemoveEnabled && mRemoveMode == CLICK_REMOVE) {
+            if (mClickRemoveHitPos != MISS) {
+                mDslv.removeItem(mClickRemoveHitPos - mDslv.getHeaderViewsCount());
+            }
+        }
+        return true;
+    }
+
+    // complete the OnGestureListener interface
+    @Override
+    public void onShowPress(MotionEvent ev) {
+        // do nothing
+    }
+
+    private GestureDetector.OnGestureListener mFlingRemoveListener =
+            new GestureDetector.SimpleOnGestureListener() {
+                @Override
+                public final boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
+                        float velocityY) {
+                    // Log.d("mobeta", "on fling remove called");
+                    if (mRemoveEnabled && mIsRemoving) {
+                        int w = mDslv.getWidth();
+                        int minPos = w / 5;
+                        if (velocityX > mFlingSpeed) {
+                            if (mPositionX > -minPos) {
+                                mDslv.stopDragWithVelocity(true, velocityX);
+                            }
+                        } else if (velocityX < -mFlingSpeed) {
+                            if (mPositionX < minPos) {
+                                mDslv.stopDragWithVelocity(true, velocityX);
+                            }
+                        }
+                        mIsRemoving = false;
+                    }
+                    return false;
+                }
+            };
+
+}

core/library/src/main/java/com/mobeta/android/dslv/DragSortCursorAdapter.java

@@ -0,0 +1,241 @@
+package com.mobeta.android.dslv;
+
+import java.util.ArrayList;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.util.SparseIntArray;
+import android.view.View;
+import android.view.ViewGroup;
+import android.support.v4.widget.CursorAdapter;
+
+
+/**
+ * A subclass of {@link android.widget.CursorAdapter} that provides
+ * reordering of the elements in the Cursor based on completed
+ * drag-sort operations. The reordering is a simple mapping of
+ * list positions into Cursor positions (the Cursor is unchanged).
+ * To persist changes made by drag-sorts, one can retrieve the
+ * mapping with the {@link #getCursorPositions()} method, which
+ * returns the reordered list of Cursor positions.
+ *
+ * An instance of this class is passed
+ * to {@link DragSortListView#setAdapter(ListAdapter)} and, since
+ * this class implements the {@link DragSortListView.DragSortListener}
+ * interface, it is automatically set as the DragSortListener for
+ * the DragSortListView instance.
+ */
+public abstract class DragSortCursorAdapter extends CursorAdapter implements DragSortListView.DragSortListener {
+
+    public static final int REMOVED = -1;
+
+    /**
+     * Key is ListView position, value is Cursor position
+     */
+    private SparseIntArray mListMapping = new SparseIntArray();
+
+    private ArrayList<Integer> mRemovedCursorPositions = new ArrayList<Integer>();
+    
+    public DragSortCursorAdapter(Context context, Cursor c) {
+        super(context, c);
+    }
+
+    public DragSortCursorAdapter(Context context, Cursor c, boolean autoRequery) {
+        super(context, c, autoRequery);
+    }
+
+    public DragSortCursorAdapter(Context context, Cursor c, int flags) {
+        super(context, c, flags);
+    }
+
+    /**
+     * Swaps Cursor and clears list-Cursor mapping.
+     *
+     * @see android.widget.CursorAdapter#swapCursor(android.database.Cursor)
+     */
+    @Override
+    public Cursor swapCursor(Cursor newCursor) {
+        Cursor old = super.swapCursor(newCursor);
+        resetMappings();
+        return old;
+    }
+
+    /**
+     * Changes Cursor and clears list-Cursor mapping.
+     *
+     * @see android.widget.CursorAdapter#changeCursor(android.database.Cursor)
+     */
+    @Override
+    public void changeCursor(Cursor cursor) {
+        super.changeCursor(cursor);
+        resetMappings();
+    }
+
+    /**
+     * Resets list-cursor mapping.
+     */
+    public void reset() {
+        resetMappings();
+        notifyDataSetChanged();
+    }
+
+    private void resetMappings() {
+        mListMapping.clear();
+        mRemovedCursorPositions.clear();
+    }
+
+    @Override
+    public Object getItem(int position) {
+        return super.getItem(mListMapping.get(position, position));
+    }
+
+    @Override
+    public long getItemId(int position) {
+        return super.getItemId(mListMapping.get(position, position));
+    }
+
+    @Override
+    public View getDropDownView(int position, View convertView, ViewGroup parent) {
+        return super.getDropDownView(mListMapping.get(position, position), convertView, parent);
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        return super.getView(mListMapping.get(position, position), convertView, parent);
+    }
+
+    /**
+     * On drop, this updates the mapping between Cursor positions
+     * and ListView positions. The Cursor is unchanged. Retrieve
+     * the current mapping with {@link getCursorPositions()}.
+     *
+     * @see DragSortListView.DropListener#drop(int, int)
+     */
+    @Override
+    public void drop(int from, int to) {
+        if (from != to) {
+            int cursorFrom = mListMapping.get(from, from);
+
+            if (from > to) {
+                for (int i = from; i > to; --i) {
+                    mListMapping.put(i, mListMapping.get(i - 1, i - 1));
+                }
+            } else {
+                for (int i = from; i < to; ++i) {
+                    mListMapping.put(i, mListMapping.get(i + 1, i + 1));
+                }
+            }
+            mListMapping.put(to, cursorFrom);
+
+            cleanMapping();        
+            notifyDataSetChanged();
+        }
+    }
+
+    /**
+     * On remove, this updates the mapping between Cursor positions
+     * and ListView positions. The Cursor is unchanged. Retrieve
+     * the current mapping with {@link getCursorPositions()}.
+     *
+     * @see DragSortListView.RemoveListener#remove(int)
+     */
+    @Override
+    public void remove(int which) {
+        int cursorPos = mListMapping.get(which, which);
+        if (!mRemovedCursorPositions.contains(cursorPos)) {
+            mRemovedCursorPositions.add(cursorPos);
+        }
+
+        int newCount = getCount();
+        for (int i = which; i < newCount; ++i) {
+            mListMapping.put(i, mListMapping.get(i + 1, i + 1));
+        }
+
+        mListMapping.delete(newCount);
+
+        cleanMapping();
+        notifyDataSetChanged();
+    }
+
+    /**
+     * Does nothing. Just completes DragSortListener interface.
+     */
+    @Override
+    public void drag(int from, int to) {
+        // do nothing
+    }
+
+    /**
+     * Remove unnecessary mappings from sparse array.
+     */
+    private void cleanMapping() {
+        ArrayList<Integer> toRemove = new ArrayList<Integer>();
+
+        int size = mListMapping.size();
+        for (int i = 0; i < size; ++i) {
+            if (mListMapping.keyAt(i) == mListMapping.valueAt(i)) {
+                toRemove.add(mListMapping.keyAt(i));
+            }
+        }
+
+        size = toRemove.size();
+        for (int i = 0; i < size; ++i) {
+            mListMapping.delete(toRemove.get(i));
+        }
+    }
+
+    @Override
+    public int getCount() {
+        return super.getCount() - mRemovedCursorPositions.size();
+    }
+
+    /**
+     * Get the Cursor position mapped to by the provided list position
+     * (given all previously handled drag-sort
+     * operations).
+     *
+     * @param position List position
+     *
+     * @return The mapped-to Cursor position
+     */
+    public int getCursorPosition(int position) {
+        return mListMapping.get(position, position);
+    }
+
+    /**
+     * Get the current order of Cursor positions presented by the
+     * list.
+     */
+    public ArrayList<Integer> getCursorPositions() {
+        ArrayList<Integer> result = new ArrayList<Integer>();
+
+        for (int i = 0; i < getCount(); ++i) {
+            result.add(mListMapping.get(i, i));
+        }
+
+        return result;
+    }
+
+    /**
+     * Get the list position mapped to by the provided Cursor position.
+     * If the provided Cursor position has been removed by a drag-sort,
+     * this returns {@link #REMOVED}.
+     *
+     * @param cursorPosition A Cursor position
+     * @return The mapped-to list position or REMOVED
+     */
+    public int getListPosition(int cursorPosition) {
+        if (mRemovedCursorPositions.contains(cursorPosition)) {
+            return REMOVED;
+        }
+
+        int index = mListMapping.indexOfValue(cursorPosition);
+        if (index < 0) {
+            return cursorPosition;
+        } else {
+            return mListMapping.keyAt(index);
+        }
+    }
+
+
+}

core/library/src/main/java/com/mobeta/android/dslv/DragSortItemView.java

@@ -0,0 +1,100 @@
+package com.mobeta.android.dslv;
+
+import android.content.Context;
+import android.view.Gravity;
+import android.view.View;
+import android.view.View.MeasureSpec;
+import android.view.ViewGroup;
+import android.widget.AbsListView;
+import android.util.Log;
+
+/**
+ * Lightweight ViewGroup that wraps list items obtained from user's
+ * ListAdapter. ItemView expects a single child that has a definite
+ * height (i.e. the child's layout height is not MATCH_PARENT).
+ * The width of
+ * ItemView will always match the width of its child (that is,
+ * the width MeasureSpec given to ItemView is passed directly
+ * to the child, and the ItemView measured width is set to the
+ * child's measured width). The height of ItemView can be anything;
+ * the 
+ * 
+ *
+ * The purpose of this class is to optimize slide
+ * shuffle animations.
+ */
+public class DragSortItemView extends ViewGroup {
+
+    private int mGravity = Gravity.TOP;
+
+    public DragSortItemView(Context context) {
+        super(context);
+
+        // always init with standard ListView layout params
+        setLayoutParams(new AbsListView.LayoutParams(
+                ViewGroup.LayoutParams.FILL_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        //setClipChildren(true);
+    }
+
+    public void setGravity(int gravity) {
+        mGravity = gravity;
+    }
+
+    public int getGravity() {
+        return mGravity;
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
+        final View child = getChildAt(0);
+
+        if (child == null) {
+            return;
+        }
+
+        if (mGravity == Gravity.TOP) {
+            child.layout(0, 0, getMeasuredWidth(), child.getMeasuredHeight());
+        } else {
+            child.layout(0, getMeasuredHeight() - child.getMeasuredHeight(), getMeasuredWidth(), getMeasuredHeight());
+        }
+    }
+
+    /**
+     * 
+     */
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        
+        int height = MeasureSpec.getSize(heightMeasureSpec);
+        int width = MeasureSpec.getSize(widthMeasureSpec);
+
+        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        final View child = getChildAt(0);
+        if (child == null) {
+            setMeasuredDimension(0, width);
+            return;
+        }
+
+        if (child.isLayoutRequested()) {
+            // Always let child be as tall as it wants.
+            measureChild(child, widthMeasureSpec,
+                    MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED));
+        }
+
+        if (heightMode == MeasureSpec.UNSPECIFIED) {
+            ViewGroup.LayoutParams lp = getLayoutParams();
+
+            if (lp.height > 0) {
+                height = lp.height;
+            } else {
+                height = child.getMeasuredHeight();
+            }
+        }
+
+        setMeasuredDimension(width, height);
+    }
+
+}

core/library/src/main/java/com/mobeta/android/dslv/DragSortItemViewCheckable.java

@@ -0,0 +1,55 @@
+package com.mobeta.android.dslv;
+
+import android.content.Context;
+import android.view.Gravity;
+import android.view.View;
+import android.view.View.MeasureSpec;
+import android.view.ViewGroup;
+import android.widget.AbsListView;
+import android.widget.Checkable;
+import android.util.Log;
+
+/**
+ * Lightweight ViewGroup that wraps list items obtained from user's
+ * ListAdapter. ItemView expects a single child that has a definite
+ * height (i.e. the child's layout height is not MATCH_PARENT).
+ * The width of
+ * ItemView will always match the width of its child (that is,
+ * the width MeasureSpec given to ItemView is passed directly
+ * to the child, and the ItemView measured width is set to the
+ * child's measured width). The height of ItemView can be anything;
+ * the 
+ * 
+ *
+ * The purpose of this class is to optimize slide
+ * shuffle animations.
+ */
+public class DragSortItemViewCheckable extends DragSortItemView implements Checkable {
+
+    public DragSortItemViewCheckable(Context context) {
+        super(context);
+    }
+
+    @Override
+    public boolean isChecked() {
+        View child = getChildAt(0);
+        if (child instanceof Checkable)
+            return ((Checkable) child).isChecked();
+        else
+            return false;
+    }
+
+    @Override
+    public void setChecked(boolean checked) {
+        View child = getChildAt(0);
+        if (child instanceof Checkable)
+            ((Checkable) child).setChecked(checked);
+    }
+
+    @Override
+    public void toggle() {
+        View child = getChildAt(0);
+        if (child instanceof Checkable)
+            ((Checkable) child).toggle();
+    }
+}

core/library/src/main/java/com/mobeta/android/dslv/ResourceDragSortCursorAdapter.java

@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mobeta.android.dslv;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.LayoutInflater;
+
+// taken from v4 rev. 10 ResourceCursorAdapter.java
+
+/**
+ * Static library support version of the framework's {@link android.widget.ResourceCursorAdapter}.
+ * Used to write apps that run on platforms prior to Android 3.0.  When running
+ * on Android 3.0 or above, this implementation is still used; it does not try
+ * to switch to the framework's implementation.  See the framework SDK
+ * documentation for a class overview.
+ */
+public abstract class ResourceDragSortCursorAdapter extends DragSortCursorAdapter {
+    private int mLayout;
+
+    private int mDropDownLayout;
+    
+    private LayoutInflater mInflater;
+    
+    /**
+     * Constructor the enables auto-requery.
+     *
+     * @deprecated This option is discouraged, as it results in Cursor queries
+     * being performed on the application's UI thread and thus can cause poor
+     * responsiveness or even Application Not Responding errors.  As an alternative,
+     * use {@link android.app.LoaderManager} with a {@link android.content.CursorLoader}.
+     *
+     * @param context The context where the ListView associated with this adapter is running
+     * @param layout resource identifier of a layout file that defines the views
+     *            for this list item.  Unless you override them later, this will
+     *            define both the item views and the drop down views.
+     */
+    @Deprecated
+    public ResourceDragSortCursorAdapter(Context context, int layout, Cursor c) {
+        super(context, c);
+        mLayout = mDropDownLayout = layout;
+        mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+    
+    /**
+     * Constructor with default behavior as per
+     * {@link CursorAdapter#CursorAdapter(Context, Cursor, boolean)}; it is recommended
+     * you not use this, but instead {@link #ResourceCursorAdapter(Context, int, Cursor, int)}.
+     * When using this constructor, {@link #FLAG_REGISTER_CONTENT_OBSERVER}
+     * will always be set.
+     *
+     * @param context The context where the ListView associated with this adapter is running
+     * @param layout resource identifier of a layout file that defines the views
+     *            for this list item.  Unless you override them later, this will
+     *            define both the item views and the drop down views.
+     * @param c The cursor from which to get the data.
+     * @param autoRequery If true the adapter will call requery() on the
+     *                    cursor whenever it changes so the most recent
+     *                    data is always displayed.  Using true here is discouraged.
+     */
+    public ResourceDragSortCursorAdapter(Context context, int layout, Cursor c, boolean autoRequery) {
+        super(context, c, autoRequery);
+        mLayout = mDropDownLayout = layout;
+        mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    /**
+     * Standard constructor.
+     *
+     * @param context The context where the ListView associated with this adapter is running
+     * @param layout Resource identifier of a layout file that defines the views
+     *            for this list item.  Unless you override them later, this will
+     *            define both the item views and the drop down views.
+     * @param c The cursor from which to get the data.
+     * @param flags Flags used to determine the behavior of the adapter,
+     * as per {@link CursorAdapter#CursorAdapter(Context, Cursor, int)}.
+     */
+    public ResourceDragSortCursorAdapter(Context context, int layout, Cursor c, int flags) {
+        super(context, c, flags);
+        mLayout = mDropDownLayout = layout;
+        mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    /**
+     * Inflates view(s) from the specified XML file.
+     * 
+     * @see android.widget.CursorAdapter#newView(android.content.Context,
+     *      android.database.Cursor, ViewGroup)
+     */
+    @Override
+    public View newView(Context context, Cursor cursor, ViewGroup parent) {
+        return mInflater.inflate(mLayout, parent, false);
+    }
+
+    @Override
+    public View newDropDownView(Context context, Cursor cursor, ViewGroup parent) {
+        return mInflater.inflate(mDropDownLayout, parent, false);
+    }
+
+    /**
+     * <p>Sets the layout resource of the item views.</p>
+     *
+     * @param layout the layout resources used to create item views
+     */
+    public void setViewResource(int layout) {
+        mLayout = layout;
+    }
+    
+    /**
+     * <p>Sets the layout resource of the drop down views.</p>
+     *
+     * @param dropDownLayout the layout resources used to create drop down views
+     */
+    public void setDropDownViewResource(int dropDownLayout) {
+        mDropDownLayout = dropDownLayout;
+    }
+}

core/library/src/main/java/com/mobeta/android/dslv/SimpleDragSortCursorAdapter.java

@@ -0,0 +1,422 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mobeta.android.dslv;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.view.View;
+import android.widget.TextView;
+import android.widget.ImageView;
+
+// taken from sdk/sources/android-16/android/widget/SimpleCursorAdapter.java
+
+/**
+ * An easy adapter to map columns from a cursor to TextViews or ImageViews
+ * defined in an XML file. You can specify which columns you want, which
+ * views you want to display the columns, and the XML file that defines
+ * the appearance of these views.
+ *
+ * Binding occurs in two phases. First, if a
+ * {@link android.widget.SimpleCursorAdapter.ViewBinder} is available,
+ * {@link ViewBinder#setViewValue(android.view.View, android.database.Cursor, int)}
+ * is invoked. If the returned value is true, binding has occured. If the
+ * returned value is false and the view to bind is a TextView,
+ * {@link #setViewText(TextView, String)} is invoked. If the returned value
+ * is false and the view to bind is an ImageView,
+ * {@link #setViewImage(ImageView, String)} is invoked. If no appropriate
+ * binding can be found, an {@link IllegalStateException} is thrown.
+ *
+ * If this adapter is used with filtering, for instance in an
+ * {@link android.widget.AutoCompleteTextView}, you can use the
+ * {@link android.widget.SimpleCursorAdapter.CursorToStringConverter} and the
+ * {@link android.widget.FilterQueryProvider} interfaces
+ * to get control over the filtering process. You can refer to
+ * {@link #convertToString(android.database.Cursor)} and
+ * {@link #runQueryOnBackgroundThread(CharSequence)} for more information.
+ */
+public class SimpleDragSortCursorAdapter extends ResourceDragSortCursorAdapter {
+    /**
+     * A list of columns containing the data to bind to the UI.
+     * This field should be made private, so it is hidden from the SDK.
+     * {@hide}
+     */
+    protected int[] mFrom;
+    /**
+     * A list of View ids representing the views to which the data must be bound.
+     * This field should be made private, so it is hidden from the SDK.
+     * {@hide}
+     */
+    protected int[] mTo;
+
+    private int mStringConversionColumn = -1;
+    private CursorToStringConverter mCursorToStringConverter;
+    private ViewBinder mViewBinder;
+
+    String[] mOriginalFrom;
+
+    /**
+     * Constructor the enables auto-requery.
+     *
+     * @deprecated This option is discouraged, as it results in Cursor queries
+     * being performed on the application's UI thread and thus can cause poor
+     * responsiveness or even Application Not Responding errors.  As an alternative,
+     * use {@link android.app.LoaderManager} with a {@link android.content.CursorLoader}.
+     */
+    @Deprecated
+    public SimpleDragSortCursorAdapter(Context context, int layout, Cursor c, String[] from, int[] to) {
+        super(context, layout, c);
+        mTo = to;
+        mOriginalFrom = from;
+        findColumns(c, from);
+    }
+
+    /**
+     * Standard constructor.
+     * 
+     * @param context The context where the ListView associated with this
+     *            SimpleListItemFactory is running
+     * @param layout resource identifier of a layout file that defines the views
+     *            for this list item. The layout file should include at least
+     *            those named views defined in "to"
+     * @param c The database cursor.  Can be null if the cursor is not available yet.
+     * @param from A list of column names representing the data to bind to the UI.  Can be null 
+     *            if the cursor is not available yet.
+     * @param to The views that should display column in the "from" parameter.
+     *            These should all be TextViews. The first N views in this list
+     *            are given the values of the first N columns in the from
+     *            parameter.  Can be null if the cursor is not available yet.
+     * @param flags Flags used to determine the behavior of the adapter,
+     * as per {@link CursorAdapter#CursorAdapter(Context, Cursor, int)}.
+     */
+    public SimpleDragSortCursorAdapter(Context context, int layout,
+            Cursor c, String[] from, int[] to, int flags) {
+        super(context, layout, c, flags);
+        mTo = to;
+        mOriginalFrom = from;
+        findColumns(c, from);
+    }
+
+    /**
+     * Binds all of the field names passed into the "to" parameter of the
+     * constructor with their corresponding cursor columns as specified in the
+     * "from" parameter.
+     *
+     * Binding occurs in two phases. First, if a
+     * {@link android.widget.SimpleCursorAdapter.ViewBinder} is available,
+     * {@link ViewBinder#setViewValue(android.view.View, android.database.Cursor, int)}
+     * is invoked. If the returned value is true, binding has occured. If the
+     * returned value is false and the view to bind is a TextView,
+     * {@link #setViewText(TextView, String)} is invoked. If the returned value is
+     * false and the view to bind is an ImageView,
+     * {@link #setViewImage(ImageView, String)} is invoked. If no appropriate
+     * binding can be found, an {@link IllegalStateException} is thrown.
+     *
+     * @throws IllegalStateException if binding cannot occur
+     * 
+     * @see android.widget.CursorAdapter#bindView(android.view.View,
+     *      android.content.Context, android.database.Cursor)
+     * @see #getViewBinder()
+     * @see #setViewBinder(android.widget.SimpleCursorAdapter.ViewBinder)
+     * @see #setViewImage(ImageView, String)
+     * @see #setViewText(TextView, String)
+     */
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        final ViewBinder binder = mViewBinder;
+        final int count = mTo.length;
+        final int[] from = mFrom;
+        final int[] to = mTo;
+
+        for (int i = 0; i < count; i++) {
+            final View v = view.findViewById(to[i]);
+            if (v != null) {
+                boolean bound = false;
+                if (binder != null) {
+                    bound = binder.setViewValue(v, cursor, from[i]);
+                }
+
+                if (!bound) {
+                    String text = cursor.getString(from[i]);
+                    if (text == null) {
+                        text = "";
+                    }
+
+                    if (v instanceof TextView) {
+                        setViewText((TextView) v, text);
+                    } else if (v instanceof ImageView) {
+                        setViewImage((ImageView) v, text);
+                    } else {
+                        throw new IllegalStateException(v.getClass().getName() + " is not a " +
+                                " view that can be bounds by this SimpleCursorAdapter");
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns the {@link ViewBinder} used to bind data to views.
+     *
+     * @return a ViewBinder or null if the binder does not exist
+     *
+     * @see #bindView(android.view.View, android.content.Context, android.database.Cursor)
+     * @see #setViewBinder(android.widget.SimpleCursorAdapter.ViewBinder)
+     */
+    public ViewBinder getViewBinder() {
+        return mViewBinder;
+    }
+
+    /**
+     * Sets the binder used to bind data to views.
+     *
+     * @param viewBinder the binder used to bind data to views, can be null to
+     *        remove the existing binder
+     *
+     * @see #bindView(android.view.View, android.content.Context, android.database.Cursor)
+     * @see #getViewBinder()
+     */
+    public void setViewBinder(ViewBinder viewBinder) {
+        mViewBinder = viewBinder;
+    }
+
+    /**
+     * Called by bindView() to set the image for an ImageView but only if
+     * there is no existing ViewBinder or if the existing ViewBinder cannot
+     * handle binding to an ImageView.
+     *
+     * By default, the value will be treated as an image resource. If the
+     * value cannot be used as an image resource, the value is used as an
+     * image Uri.
+     *
+     * Intended to be overridden by Adapters that need to filter strings
+     * retrieved from the database.
+     *
+     * @param v ImageView to receive an image
+     * @param value the value retrieved from the cursor
+     */
+    public void setViewImage(ImageView v, String value) {
+        try {
+            v.setImageResource(Integer.parseInt(value));
+        } catch (NumberFormatException nfe) {
+            v.setImageURI(Uri.parse(value));
+        }
+    }
+
+    /**
+     * Called by bindView() to set the text for a TextView but only if
+     * there is no existing ViewBinder or if the existing ViewBinder cannot
+     * handle binding to a TextView.
+     *
+     * Intended to be overridden by Adapters that need to filter strings
+     * retrieved from the database.
+     * 
+     * @param v TextView to receive text
+     * @param text the text to be set for the TextView
+     */    
+    public void setViewText(TextView v, String text) {
+        v.setText(text);
+    }
+
+    /**
+     * Return the index of the column used to get a String representation
+     * of the Cursor.
+     *
+     * @return a valid index in the current Cursor or -1
+     *
+     * @see android.widget.CursorAdapter#convertToString(android.database.Cursor)
+     * @see #setStringConversionColumn(int) 
+     * @see #setCursorToStringConverter(android.widget.SimpleCursorAdapter.CursorToStringConverter)
+     * @see #getCursorToStringConverter()
+     */
+    public int getStringConversionColumn() {
+        return mStringConversionColumn;
+    }
+
+    /**
+     * Defines the index of the column in the Cursor used to get a String
+     * representation of that Cursor. The column is used to convert the
+     * Cursor to a String only when the current CursorToStringConverter
+     * is null.
+     *
+     * @param stringConversionColumn a valid index in the current Cursor or -1 to use the default
+     *        conversion mechanism
+     *
+     * @see android.widget.CursorAdapter#convertToString(android.database.Cursor)
+     * @see #getStringConversionColumn()
+     * @see #setCursorToStringConverter(android.widget.SimpleCursorAdapter.CursorToStringConverter)
+     * @see #getCursorToStringConverter()
+     */
+    public void setStringConversionColumn(int stringConversionColumn) {
+        mStringConversionColumn = stringConversionColumn;
+    }
+
+    /**
+     * Returns the converter used to convert the filtering Cursor
+     * into a String.
+     *
+     * @return null if the converter does not exist or an instance of
+     *         {@link android.widget.SimpleCursorAdapter.CursorToStringConverter}
+     *
+     * @see #setCursorToStringConverter(android.widget.SimpleCursorAdapter.CursorToStringConverter)
+     * @see #getStringConversionColumn()
+     * @see #setStringConversionColumn(int)
+     * @see android.widget.CursorAdapter#convertToString(android.database.Cursor)
+     */
+    public CursorToStringConverter getCursorToStringConverter() {
+        return mCursorToStringConverter;
+    }
+
+    /**
+     * Sets the converter  used to convert the filtering Cursor
+     * into a String.
+     *
+     * @param cursorToStringConverter the Cursor to String converter, or
+     *        null to remove the converter
+     *
+     * @see #setCursorToStringConverter(android.widget.SimpleCursorAdapter.CursorToStringConverter) 
+     * @see #getStringConversionColumn()
+     * @see #setStringConversionColumn(int)
+     * @see android.widget.CursorAdapter#convertToString(android.database.Cursor)
+     */
+    public void setCursorToStringConverter(CursorToStringConverter cursorToStringConverter) {
+        mCursorToStringConverter = cursorToStringConverter;
+    }
+
+    /**
+     * Returns a CharSequence representation of the specified Cursor as defined
+     * by the current CursorToStringConverter. If no CursorToStringConverter
+     * has been set, the String conversion column is used instead. If the
+     * conversion column is -1, the returned String is empty if the cursor
+     * is null or Cursor.toString().
+     *
+     * @param cursor the Cursor to convert to a CharSequence
+     *
+     * @return a non-null CharSequence representing the cursor
+     */
+    @Override
+    public CharSequence convertToString(Cursor cursor) {
+        if (mCursorToStringConverter != null) {
+            return mCursorToStringConverter.convertToString(cursor);
+        } else if (mStringConversionColumn > -1) {
+            return cursor.getString(mStringConversionColumn);
+        }
+
+        return super.convertToString(cursor);
+    }
+
+    /**
+     * Create a map from an array of strings to an array of column-id integers in cursor c.
+     * If c is null, the array will be discarded.
+     *
+     * @param c the cursor to find the columns from
+     * @param from the Strings naming the columns of interest
+     */
+    private void findColumns(Cursor c, String[] from) {
+        if (c != null) {
+            int i;
+            int count = from.length;
+            if (mFrom == null || mFrom.length != count) {
+                mFrom = new int[count];
+            }
+            for (i = 0; i < count; i++) {
+                mFrom[i] = c.getColumnIndexOrThrow(from[i]);
+            }
+        } else {
+            mFrom = null;
+        }
+    }
+
+    @Override
+    public Cursor swapCursor(Cursor c) {
+        // super.swapCursor() will notify observers before we have
+        // a valid mapping, make sure we have a mapping before this
+        // happens
+        findColumns(c, mOriginalFrom);
+        return super.swapCursor(c);
+    }
+    
+    /**
+     * Change the cursor and change the column-to-view mappings at the same time.
+     *  
+     * @param c The database cursor.  Can be null if the cursor is not available yet.
+     * @param from A list of column names representing the data to bind to the UI.  Can be null 
+     *            if the cursor is not available yet.
+     * @param to The views that should display column in the "from" parameter.
+     *            These should all be TextViews. The first N views in this list
+     *            are given the values of the first N columns in the from
+     *            parameter.  Can be null if the cursor is not available yet.
+     */
+    public void changeCursorAndColumns(Cursor c, String[] from, int[] to) {
+        mOriginalFrom = from;
+        mTo = to;
+        // super.changeCursor() will notify observers before we have
+        // a valid mapping, make sure we have a mapping before this
+        // happens
+        findColumns(c, mOriginalFrom);
+        super.changeCursor(c);
+    }
+
+    /**
+     * This class can be used by external clients of SimpleCursorAdapter
+     * to bind values fom the Cursor to views.
+     *
+     * You should use this class to bind values from the Cursor to views
+     * that are not directly supported by SimpleCursorAdapter or to
+     * change the way binding occurs for views supported by
+     * SimpleCursorAdapter.
+     *
+     * @see SimpleCursorAdapter#bindView(android.view.View, android.content.Context, android.database.Cursor)
+     * @see SimpleCursorAdapter#setViewImage(ImageView, String) 
+     * @see SimpleCursorAdapter#setViewText(TextView, String)
+     */
+    public static interface ViewBinder {
+        /**
+         * Binds the Cursor column defined by the specified index to the specified view.
+         *
+         * When binding is handled by this ViewBinder, this method must return true.
+         * If this method returns false, SimpleCursorAdapter will attempts to handle
+         * the binding on its own.
+         *
+         * @param view the view to bind the data to
+         * @param cursor the cursor to get the data from
+         * @param columnIndex the column at which the data can be found in the cursor
+         *
+         * @return true if the data was bound to the view, false otherwise
+         */
+        boolean setViewValue(View view, Cursor cursor, int columnIndex);
+    }
+
+    /**
+     * This class can be used by external clients of SimpleCursorAdapter
+     * to define how the Cursor should be converted to a String.
+     *
+     * @see android.widget.CursorAdapter#convertToString(android.database.Cursor)
+     */
+    public static interface CursorToStringConverter {
+        /**
+         * Returns a CharSequence representing the specified Cursor.
+         *
+         * @param cursor the cursor for which a CharSequence representation
+         *        is requested
+         *
+         * @return a non-null CharSequence representing the cursor
+         */
+        CharSequence convertToString(Cursor cursor);
+    }
+
+}

core/library/src/main/java/com/mobeta/android/dslv/SimpleFloatViewManager.java

@@ -0,0 +1,89 @@
+package com.mobeta.android.dslv;
+
+import android.graphics.Bitmap;
+import android.graphics.Point;
+import android.graphics.Color;
+import android.widget.ListView;
+import android.widget.ImageView;
+import android.view.View;
+import android.view.ViewGroup;
+import android.util.Log;
+
+/**
+ * Simple implementation of the FloatViewManager class. Uses list
+ * items as they appear in the ListView to create the floating View.
+ */
+public class SimpleFloatViewManager implements DragSortListView.FloatViewManager {
+
+    private Bitmap mFloatBitmap;
+
+    private ImageView mImageView;
+
+    private int mFloatBGColor = Color.BLACK;
+
+    private ListView mListView;
+
+    public SimpleFloatViewManager(ListView lv) {
+        mListView = lv;
+    }
+
+    public void setBackgroundColor(int color) {
+        mFloatBGColor = color;
+    }
+
+    /**
+     * This simple implementation creates a Bitmap copy of the
+     * list item currently shown at ListView <code>position</code>.
+     */
+    @Override
+    public View onCreateFloatView(int position) {
+        // Guaranteed that this will not be null? I think so. Nope, got
+        // a NullPointerException once...
+        View v = mListView.getChildAt(position + mListView.getHeaderViewsCount() - mListView.getFirstVisiblePosition());
+
+        if (v == null) {
+            return null;
+        }
+
+        v.setPressed(false);
+
+        // Create a copy of the drawing cache so that it does not get
+        // recycled by the framework when the list tries to clean up memory
+        //v.setDrawingCacheQuality(View.DRAWING_CACHE_QUALITY_HIGH);
+        v.setDrawingCacheEnabled(true);
+        mFloatBitmap = Bitmap.createBitmap(v.getDrawingCache());
+        v.setDrawingCacheEnabled(false);
+
+        if (mImageView == null) {
+            mImageView = new ImageView(mListView.getContext());
+        }
+        mImageView.setBackgroundColor(mFloatBGColor);
+        mImageView.setPadding(0, 0, 0, 0);
+        mImageView.setImageBitmap(mFloatBitmap);
+        mImageView.setLayoutParams(new ViewGroup.LayoutParams(v.getWidth(), v.getHeight()));
+
+        return mImageView;
+    }
+
+    /**
+     * This does nothing
+     */
+    @Override
+    public void onDragFloatView(View floatView, Point position, Point touch) {
+        // do nothing
+    }
+
+    /**
+     * Removes the Bitmap from the ImageView created in
+     * onCreateFloatView() and tells the system to recycle it.
+     */
+    @Override
+    public void onDestroyFloatView(View floatView) {
+        ((ImageView) floatView).setImageDrawable(null);
+
+        mFloatBitmap.recycle();
+        mFloatBitmap = null;
+    }
+
+}
+

core/library/src/main/res/values/dslv_attrs.xml

@@ -0,0 +1,30 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <declare-styleable name="DragSortListView">
+    <attr name="collapsed_height" format="dimension" />
+    <attr name="drag_scroll_start" format="float" />
+    <attr name="max_drag_scroll_speed" format="float" />
+    <attr name="float_background_color" format="color" />
+    <attr name="remove_mode">
+      <enum name="clickRemove" value="0" />
+      <enum name="flingRemove" value="1" />
+    </attr>
+    <attr name="track_drag_sort" format="boolean"/>
+    <attr name="float_alpha" format="float"/>
+    <attr name="slide_shuffle_speed" format="float"/>
+    <attr name="remove_animation_duration" format="integer"/>
+    <attr name="drop_animation_duration" format="integer"/>
+    <attr name="drag_enabled" format="boolean" />
+    <attr name="sort_enabled" format="boolean" />
+    <attr name="remove_enabled" format="boolean" />
+    <attr name="drag_start_mode">
+      <enum name="onDown" value="0" />
+      <enum name="onMove" value="1" />
+      <enum name="onLongPress" value="2"/>
+    </attr>
+    <attr name="drag_handle_id" format="integer" />
+    <attr name="fling_handle_id" format="integer" />
+    <attr name="click_remove_id" format="integer" />
+    <attr name="use_default_controller" format="boolean" />
+  </declare-styleable>
+</resources>

core/menudrawer/build.gradle

@@ -0,0 +1,8 @@
+apply from: bootstrap.androidModule
+
+android {
+    lintOptions {
+        baselineFile file("lint-baseline.xml")
+        abortOnError true
+    }
+}

core/menudrawer/lint-baseline.xml

@@ -0,0 +1,246 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="4" by="lint 2.3.3">
+
+    <issue
+        id="InlinedApi"
+        message="Field requires API level 17 (current min is 14): `android.view.View#LAYOUT_DIRECTION_RTL`"
+        errorLine1="        if (mSlideDrawable != null) mSlideDrawable.setIsRtl(layoutDirection == LAYOUT_DIRECTION_RTL);"
+        errorLine2="                                                                               ~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/MenuDrawer.java"
+            line="882"
+            column="80"/>
+    </issue>
+
+    <issue
+        id="InlinedApi"
+        message="Field requires API level 17 (current min is 14): `android.view.View#LAYOUT_DIRECTION_RTL`"
+        errorLine1="        mSlideDrawable.setIsRtl(ViewHelper.getLayoutDirection(this) == LAYOUT_DIRECTION_RTL);"
+        errorLine2="                                                                       ~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/MenuDrawer.java"
+            line="1325"
+            column="72"/>
+    </issue>
+
+    <issue
+        id="OldTargetApi"
+        message="Not targeting the latest versions of Android; compatibility modes apply. Consider testing and updating this version. Consult the `android.os.Build.VERSION_CODES` javadoc for details."
+        errorLine1="    &lt;uses-sdk android:minSdkVersion=&quot;7&quot; android:targetSdkVersion=&quot;16&quot; />"
+        errorLine2="                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="41"/>
+    </issue>
+
+    <issue
+        id="GradleOverrides"
+        message="This `minSdkVersion` value (`7`) is not used; it is always overridden by the value specified in the Gradle build script (`14`)"
+        errorLine1="    &lt;uses-sdk android:minSdkVersion=&quot;7&quot; android:targetSdkVersion=&quot;16&quot; />"
+        errorLine2="              ~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="15"/>
+    </issue>
+
+    <issue
+        id="GradleOverrides"
+        message="This `targetSdkVersion` value (`16`) is not used; it is always overridden by the value specified in the Gradle build script (`22`)"
+        errorLine1="    &lt;uses-sdk android:minSdkVersion=&quot;7&quot; android:targetSdkVersion=&quot;16&quot; />"
+        errorLine2="                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="41"/>
+    </issue>
+
+    <issue
+        id="ParcelClassLoader"
+        message="Using the default class loader will not work if you are restoring your own classes. Consider using for example `readBundle(getClass().getClassLoader())` instead."
+        errorLine1="            mState = in.readBundle();"
+        errorLine2="                        ~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/MenuDrawer.java"
+            line="1630"
+            column="25"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is never &lt; 14"
+        errorLine1="        if (mUsesCompat &amp;&amp; Build.VERSION.SDK_INT &lt; Build.VERSION_CODES.ICE_CREAM_SANDWICH) {"
+        errorLine2="                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="41"
+            column="28"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="43"
+            column="20"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is never &lt; 14"
+        errorLine1="        if (mUsesCompat &amp;&amp; Build.VERSION.SDK_INT &lt; Build.VERSION_CODES.ICE_CREAM_SANDWICH) {"
+        errorLine2="                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="51"
+            column="28"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="53"
+            column="20"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is never &lt; 14"
+        errorLine1="        if (mUsesCompat &amp;&amp; Build.VERSION.SDK_INT &lt; Build.VERSION_CODES.ICE_CREAM_SANDWICH) {"
+        errorLine2="                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="59"
+            column="28"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="61"
+            column="20"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is never &lt; 14"
+        errorLine1="        if (mUsesCompat &amp;&amp; Build.VERSION.SDK_INT &lt; Build.VERSION_CODES.ICE_CREAM_SANDWICH) {"
+        errorLine2="                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="67"
+            column="28"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="69"
+            column="20"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is never &lt; 14"
+        errorLine1="        if (mUsesCompat &amp;&amp; Build.VERSION.SDK_INT &lt; Build.VERSION_CODES.ICE_CREAM_SANDWICH) {"
+        errorLine2="                           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="77"
+            column="28"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java"
+            line="79"
+            column="20"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) {"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/DraggableDrawer.java"
+            line="572"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) {"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/DraggableDrawer.java"
+            line="580"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/DraggableDrawer.java"
+            line="588"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/DraggableDrawer.java"
+            line="596"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="FloatMath"
+        message="Use `java.lang.Math#sqrt` instead of `android.util.FloatMath#sqrt()` since it is faster as of API 8"
+        errorLine1="            float hyp = FloatMath.sqrt(dx * dx + dy * dy);"
+        errorLine2="                        ~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/Scroller.java"
+            line="374"
+            column="25"/>
+    </issue>
+
+    <issue
+        id="FloatMath"
+        message="Use `java.lang.Math#sqrt` instead of `android.util.FloatMath#sqrt()` since it is faster as of API 8"
+        errorLine1="        float velocity = FloatMath.sqrt(velocityX * velocityX + velocityY * velocityY);"
+        errorLine2="                         ~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/net/simonvt/menudrawer/Scroller.java"
+            line="391"
+            column="26"/>
+    </issue>
+
+</issues>

core/menudrawer/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+      package="net.simonvt.menudrawer"
+      android:versionCode="6"
+      android:versionName="3.0.2">
+</manifest>

core/menudrawer/src/main/java/net/simonvt/menudrawer/BuildLayerFrameLayout.java

@@ -0,0 +1,99 @@
+package net.simonvt.menudrawer;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.util.AttributeSet;
+import android.widget.FrameLayout;
+
+/**
+ * FrameLayout which caches the hardware layer if available.
+ * <p/>
+ * If it's not posted twice the layer either wont be built on start, or it'll be built twice.
+ */
+class BuildLayerFrameLayout extends FrameLayout {
+
+    private boolean mChanged;
+
+    private boolean mHardwareLayersEnabled = true;
+
+    private boolean mAttached;
+
+    private boolean mFirst = true;
+
+    public BuildLayerFrameLayout(Context context) {
+        super(context);
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            setLayerType(LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    public BuildLayerFrameLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            setLayerType(LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    public BuildLayerFrameLayout(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            setLayerType(LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    void setHardwareLayersEnabled(boolean enabled) {
+        mHardwareLayersEnabled = enabled;
+    }
+
+    @Override
+    protected void onAttachedToWindow() {
+        super.onAttachedToWindow();
+        mAttached = true;
+    }
+
+    @Override
+    protected void onDetachedFromWindow() {
+        super.onDetachedFromWindow();
+        mAttached = false;
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+
+        if (MenuDrawer.USE_TRANSLATIONS && mHardwareLayersEnabled) {
+            post(new Runnable() {
+                @Override
+                public void run() {
+                    mChanged = true;
+                    invalidate();
+                }
+            });
+        }
+    }
+
+    @Override
+    protected void dispatchDraw(Canvas canvas) {
+        super.dispatchDraw(canvas);
+
+        if (mChanged && MenuDrawer.USE_TRANSLATIONS) {
+            post(new Runnable() {
+                @Override
+                public void run() {
+                    if (mAttached) {
+                        final int layerType = getLayerType();
+                        // If it's already a hardware layer, it'll be built anyway.
+                        if (layerType != LAYER_TYPE_HARDWARE || mFirst) {
+                            mFirst = false;
+                            setLayerType(LAYER_TYPE_HARDWARE, null);
+                            buildLayer();
+                            setLayerType(LAYER_TYPE_NONE, null);
+                        }
+                    }
+                }
+            });
+
+            mChanged = false;
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/ColorDrawable.java

@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.simonvt.menudrawer;
+
+import android.content.res.Resources;
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.Paint;
+import android.graphics.PixelFormat;
+import android.graphics.drawable.Drawable;
+
+/**
+ * A specialized Drawable that fills the Canvas with a specified color.
+ * Note that a ColorDrawable ignores the ColorFilter.
+ * <p/>
+ * <p>It can be defined in an XML file with the <code>&lt;color></code> element.</p>
+ *
+ * @attr ref android.R.styleable#ColorDrawable_color
+ */
+class ColorDrawable extends Drawable {
+
+    private ColorState mState;
+    private final Paint mPaint = new Paint();
+
+    /** Creates a new black ColorDrawable. */
+    public ColorDrawable() {
+        this(null);
+    }
+
+    /**
+     * Creates a new ColorDrawable with the specified color.
+     *
+     * @param color The color to draw.
+     */
+    public ColorDrawable(int color) {
+        this(null);
+        setColor(color);
+    }
+
+    private ColorDrawable(ColorState state) {
+        mState = new ColorState(state);
+    }
+
+    @Override
+    public int getChangingConfigurations() {
+        return super.getChangingConfigurations() | mState.mChangingConfigurations;
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        if ((mState.mUseColor >>> 24) != 0) {
+            mPaint.setColor(mState.mUseColor);
+            canvas.drawRect(getBounds(), mPaint);
+        }
+    }
+
+    /**
+     * Gets the drawable's color value.
+     *
+     * @return int The color to draw.
+     */
+    public int getColor() {
+        return mState.mUseColor;
+    }
+
+    /**
+     * Sets the drawable's color value. This action will clobber the results of prior calls to
+     * {@link #setAlpha(int)} on this object, which side-affected the underlying color.
+     *
+     * @param color The color to draw.
+     */
+    public void setColor(int color) {
+        if (mState.mBaseColor != color || mState.mUseColor != color) {
+            invalidateSelf();
+            mState.mBaseColor = mState.mUseColor = color;
+        }
+    }
+
+    /**
+     * Returns the alpha value of this drawable's color.
+     *
+     * @return A value between 0 and 255.
+     */
+    public int getAlpha() {
+        return mState.mUseColor >>> 24;
+    }
+
+    /**
+     * Sets the color's alpha value.
+     *
+     * @param alpha The alpha value to set, between 0 and 255.
+     */
+    public void setAlpha(int alpha) {
+        alpha += alpha >> 7;   // make it 0..256
+        int baseAlpha = mState.mBaseColor >>> 24;
+        int useAlpha = baseAlpha * alpha >> 8;
+        int oldUseColor = mState.mUseColor;
+        mState.mUseColor = (mState.mBaseColor << 8 >>> 8) | (useAlpha << 24);
+        if (oldUseColor != mState.mUseColor) {
+            invalidateSelf();
+        }
+    }
+
+    /**
+     * Setting a color filter on a ColorDrawable has no effect.
+     *
+     * @param colorFilter Ignore.
+     */
+    public void setColorFilter(ColorFilter colorFilter) {
+    }
+
+    public int getOpacity() {
+        switch (mState.mUseColor >>> 24) {
+            case 255:
+                return PixelFormat.OPAQUE;
+            case 0:
+                return PixelFormat.TRANSPARENT;
+        }
+        return PixelFormat.TRANSLUCENT;
+    }
+
+    @Override
+    public ConstantState getConstantState() {
+        mState.mChangingConfigurations = getChangingConfigurations();
+        return mState;
+    }
+
+    static final class ColorState extends ConstantState {
+
+        int mBaseColor; // base color, independent of setAlpha()
+        int mUseColor;  // basecolor modulated by setAlpha()
+        int mChangingConfigurations;
+
+        ColorState(ColorState state) {
+            if (state != null) {
+                mBaseColor = state.mBaseColor;
+                mUseColor = state.mUseColor;
+            }
+        }
+
+        @Override
+        public Drawable newDrawable() {
+            return new ColorDrawable(this);
+        }
+
+        @Override
+        public Drawable newDrawable(Resources res) {
+            return new ColorDrawable(this);
+        }
+
+        @Override
+        public int getChangingConfigurations() {
+            return mChangingConfigurations;
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/DraggableDrawer.java

@@ -0,0 +1,619 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.Parcelable;
+import android.os.SystemClock;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.view.animation.Interpolator;
+
+public abstract class DraggableDrawer extends MenuDrawer {
+
+    /**
+     * Key used when saving menu visibility state.
+     */
+    private static final String STATE_MENU_VISIBLE = "net.simonvt.menudrawer.MenuDrawer.menuVisible";
+
+    /**
+     * Interpolator used for peeking at the drawer.
+     */
+    private static final Interpolator PEEK_INTERPOLATOR = new PeekInterpolator();
+
+    /**
+     * The maximum alpha of the dark menu overlay used for dimming the menu.
+     */
+    protected static final int MAX_MENU_OVERLAY_ALPHA = 185;
+
+    /**
+     * Default delay from {@link #peekDrawer()} is called until first animation is run.
+     */
+    private static final long DEFAULT_PEEK_START_DELAY = 5000;
+
+    /**
+     * Default delay between each subsequent animation, after {@link #peekDrawer()} has been called.
+     */
+    private static final long DEFAULT_PEEK_DELAY = 10000;
+
+    /**
+     * The duration of the peek animation.
+     */
+    protected static final int PEEK_DURATION = 5000;
+
+    /**
+     * Distance in dp from closed position from where the drawer is considered closed with regards to touch events.
+     */
+    private static final int CLOSE_ENOUGH = 3;
+
+    protected static final int INVALID_POINTER = -1;
+
+    /**
+     * Slop before starting a drag.
+     */
+    protected int mTouchSlop;
+
+    /**
+     * Runnable used when the peek animation is running.
+     */
+    protected final Runnable mPeekRunnable = new Runnable() {
+        @Override
+        public void run() {
+            peekDrawerInvalidate();
+        }
+    };
+
+    /**
+     * Runnable used when animating the drawer open/closed.
+     */
+    private final Runnable mDragRunnable = new Runnable() {
+        @Override
+        public void run() {
+            postAnimationInvalidate();
+        }
+    };
+
+    /**
+     * Indicates whether the drawer is currently being dragged.
+     */
+    protected boolean mIsDragging;
+
+    /**
+     * The current pointer id.
+     */
+    protected int mActivePointerId = INVALID_POINTER;
+
+    /**
+     * The initial X position of a drag.
+     */
+    protected float mInitialMotionX;
+
+    /**
+     * The initial Y position of a drag.
+     */
+    protected float mInitialMotionY;
+
+    /**
+     * The last X position of a drag.
+     */
+    protected float mLastMotionX = -1;
+
+    /**
+     * The last Y position of a drag.
+     */
+    protected float mLastMotionY = -1;
+
+    /**
+     * Default delay between each subsequent animation, after {@link #peekDrawer()} has been called.
+     */
+    protected long mPeekDelay;
+
+    /**
+     * Scroller used for the peek drawer animation.
+     */
+    protected Scroller mPeekScroller;
+
+    /**
+     * Velocity tracker used when animating the drawer open/closed after a drag.
+     */
+    protected VelocityTracker mVelocityTracker;
+
+    /**
+     * Maximum velocity allowed when animating the drawer open/closed.
+     */
+    protected int mMaxVelocity;
+
+    /**
+     * Indicates whether the menu should be offset when dragging the drawer.
+     */
+    protected boolean mOffsetMenu = true;
+
+    /**
+     * Distance in px from closed position from where the drawer is considered closed with regards to touch events.
+     */
+    protected int mCloseEnough;
+
+    /**
+     * Runnable used for first call to {@link #startPeek()} after {@link #peekDrawer()}  has been called.
+     */
+    private Runnable mPeekStartRunnable;
+
+    /**
+     * Scroller used when animating the drawer open/closed.
+     */
+    private Scroller mScroller;
+
+    /**
+     * Indicates whether the current layer type is {@link android.view.View#LAYER_TYPE_HARDWARE}.
+     */
+    protected boolean mLayerTypeHardware;
+
+    DraggableDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public DraggableDrawer(Context context) {
+        super(context);
+    }
+
+    public DraggableDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public DraggableDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+
+        final ViewConfiguration configuration = ViewConfiguration.get(context);
+        mTouchSlop = configuration.getScaledTouchSlop();
+        mMaxVelocity = configuration.getScaledMaximumFlingVelocity();
+
+        mScroller = new Scroller(context, MenuDrawer.SMOOTH_INTERPOLATOR);
+        mPeekScroller = new Scroller(context, DraggableDrawer.PEEK_INTERPOLATOR);
+
+        mCloseEnough = dpToPx(DraggableDrawer.CLOSE_ENOUGH);
+    }
+
+    public void toggleMenu(boolean animate) {
+        if (mDrawerState == STATE_OPEN || mDrawerState == STATE_OPENING) {
+            closeMenu(animate);
+        } else if (mDrawerState == STATE_CLOSED || mDrawerState == STATE_CLOSING) {
+            openMenu(animate);
+        }
+    }
+
+    public boolean isMenuVisible() {
+        return mMenuVisible;
+    }
+
+    public void setMenuSize(final int size) {
+        mMenuSize = size;
+        if (mDrawerState == STATE_OPEN || mDrawerState == STATE_OPENING) {
+            setOffsetPixels(mMenuSize);
+        }
+        requestLayout();
+        invalidate();
+    }
+
+    public void setOffsetMenuEnabled(boolean offsetMenu) {
+        if (offsetMenu != mOffsetMenu) {
+            mOffsetMenu = offsetMenu;
+            requestLayout();
+            invalidate();
+        }
+    }
+
+    public boolean getOffsetMenuEnabled() {
+        return mOffsetMenu;
+    }
+
+    public void peekDrawer() {
+        peekDrawer(DEFAULT_PEEK_START_DELAY, DEFAULT_PEEK_DELAY);
+    }
+
+    public void peekDrawer(long delay) {
+        peekDrawer(DEFAULT_PEEK_START_DELAY, delay);
+    }
+
+    public void peekDrawer(final long startDelay, final long delay) {
+        if (startDelay < 0) {
+            throw new IllegalArgumentException("startDelay must be zero or larger.");
+        }
+        if (delay < 0) {
+            throw new IllegalArgumentException("delay must be zero or larger");
+        }
+
+        removeCallbacks(mPeekRunnable);
+        removeCallbacks(mPeekStartRunnable);
+
+        mPeekDelay = delay;
+        mPeekStartRunnable = new Runnable() {
+            @Override
+            public void run() {
+                startPeek();
+            }
+        };
+        postDelayed(mPeekStartRunnable, startDelay);
+    }
+
+    public void setHardwareLayerEnabled(boolean enabled) {
+        if (enabled != mHardwareLayersEnabled) {
+            mHardwareLayersEnabled = enabled;
+            mMenuContainer.setHardwareLayersEnabled(enabled);
+            mContentContainer.setHardwareLayersEnabled(enabled);
+            stopLayerTranslation();
+        }
+    }
+
+    public int getTouchMode() {
+        return mTouchMode;
+    }
+
+    public void setTouchMode(int mode) {
+        if (mTouchMode != mode) {
+            mTouchMode = mode;
+            updateTouchAreaSize();
+        }
+    }
+
+    public void setTouchBezelSize(int size) {
+        mTouchBezelSize = size;
+    }
+
+    public int getTouchBezelSize() {
+        return mTouchBezelSize;
+    }
+
+    /**
+     * If possible, set the layer type to {@link android.view.View#LAYER_TYPE_HARDWARE}.
+     */
+    protected void startLayerTranslation() {
+        if (USE_TRANSLATIONS && mHardwareLayersEnabled && !mLayerTypeHardware) {
+            mLayerTypeHardware = true;
+            mContentContainer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+            mMenuContainer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    /**
+     * If the current layer type is {@link android.view.View#LAYER_TYPE_HARDWARE}, this will set it to
+     * {@link View#LAYER_TYPE_NONE}.
+     */
+    protected void stopLayerTranslation() {
+        if (mLayerTypeHardware) {
+            mLayerTypeHardware = false;
+            mContentContainer.setLayerType(View.LAYER_TYPE_NONE, null);
+            mMenuContainer.setLayerType(View.LAYER_TYPE_NONE, null);
+        }
+    }
+
+    /**
+     * Called when a drag has been ended.
+     */
+    protected void endDrag() {
+        mIsDragging = false;
+
+        if (mVelocityTracker != null) {
+            mVelocityTracker.recycle();
+            mVelocityTracker = null;
+        }
+    }
+
+    /**
+     * Stops ongoing animation of the drawer.
+     */
+    protected void stopAnimation() {
+        removeCallbacks(mDragRunnable);
+        mScroller.abortAnimation();
+        stopLayerTranslation();
+    }
+
+    /**
+     * Called when a drawer animation has successfully completed.
+     */
+    private void completeAnimation() {
+        mScroller.abortAnimation();
+        final int finalX = mScroller.getFinalX();
+        setOffsetPixels(finalX);
+        setDrawerState(finalX == 0 ? STATE_CLOSED : STATE_OPEN);
+        stopLayerTranslation();
+    }
+
+    protected void cancelContentTouch() {
+        final long now = SystemClock.uptimeMillis();
+        final MotionEvent cancelEvent = MotionEvent.obtain(now, now, MotionEvent.ACTION_CANCEL, 0.0f, 0.0f, 0);
+        final int childCount = getChildCount();
+        for (int i = 0; i < childCount; i++) {
+            getChildAt(i).dispatchTouchEvent(cancelEvent);
+        }
+        mContentContainer.dispatchTouchEvent(cancelEvent);
+        cancelEvent.recycle();
+    }
+
+    /**
+     * Moves the drawer to the position passed.
+     *
+     * @param position The position the content is moved to.
+     * @param velocity Optional velocity if called by releasing a drag event.
+     * @param animate  Whether the move is animated.
+     */
+    protected void animateOffsetTo(int position, int velocity, boolean animate) {
+        endDrag();
+        endPeek();
+
+        final int startX = (int) mOffsetPixels;
+        final int dx = position - startX;
+        if (dx == 0 || !animate) {
+            setOffsetPixels(position);
+            setDrawerState(position == 0 ? STATE_CLOSED : STATE_OPEN);
+            stopLayerTranslation();
+            return;
+        }
+
+        int duration;
+
+        velocity = Math.abs(velocity);
+        if (velocity > 0) {
+            duration = 4 * Math.round(1000.f * Math.abs((float) dx / velocity));
+        } else {
+            duration = (int) (600.f * Math.abs((float) dx / mMenuSize));
+        }
+
+        duration = Math.min(duration, mMaxAnimationDuration);
+        animateOffsetTo(position, duration);
+    }
+
+    protected void animateOffsetTo(int position, int duration) {
+        final int startX = (int) mOffsetPixels;
+        final int dx = position - startX;
+
+        if (dx > 0) {
+            setDrawerState(STATE_OPENING);
+            mScroller.startScroll(startX, 0, dx, 0, duration);
+        } else {
+            setDrawerState(STATE_CLOSING);
+            mScroller.startScroll(startX, 0, dx, 0, duration);
+        }
+
+        startLayerTranslation();
+
+        postAnimationInvalidate();
+    }
+
+    /**
+     * Callback when each frame in the drawer animation should be drawn.
+     */
+    private void postAnimationInvalidate() {
+        if (mScroller.computeScrollOffset()) {
+            final int oldX = (int) mOffsetPixels;
+            final int x = mScroller.getCurrX();
+
+            if (x != oldX) setOffsetPixels(x);
+            if (x != mScroller.getFinalX()) {
+                postOnAnimation(mDragRunnable);
+                return;
+            }
+        }
+
+        completeAnimation();
+    }
+
+    /**
+     * Starts peek drawer animation.
+     */
+    protected void startPeek() {
+        initPeekScroller();
+
+        startLayerTranslation();
+        peekDrawerInvalidate();
+    }
+
+    protected abstract void initPeekScroller();
+
+    /**
+     * Callback when each frame in the peek drawer animation should be drawn.
+     */
+    private void peekDrawerInvalidate() {
+        if (mPeekScroller.computeScrollOffset()) {
+            final int oldX = (int) mOffsetPixels;
+            final int x = mPeekScroller.getCurrX();
+            if (x != oldX) setOffsetPixels(x);
+
+            if (!mPeekScroller.isFinished()) {
+                postOnAnimation(mPeekRunnable);
+                return;
+
+            } else if (mPeekDelay > 0) {
+                mPeekStartRunnable = new Runnable() {
+                    @Override
+                    public void run() {
+                        startPeek();
+                    }
+                };
+                postDelayed(mPeekStartRunnable, mPeekDelay);
+            }
+        }
+
+        completePeek();
+    }
+
+    /**
+     * Called when the peek drawer animation has successfully completed.
+     */
+    private void completePeek() {
+        mPeekScroller.abortAnimation();
+
+        setOffsetPixels(0);
+
+        setDrawerState(STATE_CLOSED);
+        stopLayerTranslation();
+    }
+
+    /**
+     * Stops ongoing peek drawer animation.
+     */
+    protected void endPeek() {
+        removeCallbacks(mPeekStartRunnable);
+        removeCallbacks(mPeekRunnable);
+        stopLayerTranslation();
+    }
+
+    protected boolean isCloseEnough() {
+        return Math.abs(mOffsetPixels) <= mCloseEnough;
+    }
+
+    protected boolean canChildrenScroll(int dx, int dy, int x, int y) {
+        boolean canScroll = false;
+
+        switch (getPosition()) {
+            case LEFT:
+            case RIGHT:
+                if (!mMenuVisible) {
+                    canScroll = canChildScrollHorizontally(mContentContainer, false, dx,
+                            x - ViewHelper.getLeft(mContentContainer), y - ViewHelper.getTop(mContentContainer));
+                } else {
+                    canScroll = canChildScrollHorizontally(mMenuContainer, false, dx,
+                            x - ViewHelper.getLeft(mMenuContainer), y - ViewHelper.getTop(mContentContainer));
+                }
+                break;
+
+            case TOP:
+            case BOTTOM:
+                if (!mMenuVisible) {
+                    canScroll = canChildScrollVertically(mContentContainer, false, dy,
+                            x - ViewHelper.getLeft(mContentContainer), y - ViewHelper.getTop(mContentContainer));
+                } else {
+                    canScroll = canChildScrollVertically(mMenuContainer, false, dy,
+                            x - ViewHelper.getLeft(mMenuContainer), y - ViewHelper.getTop(mContentContainer));
+                }
+        }
+
+        return canScroll;
+    }
+
+    /**
+     * Tests scrollability within child views of v given a delta of dx.
+     *
+     * @param v      View to test for horizontal scrollability
+     * @param checkV Whether the view should be checked for draggability
+     * @param dx     Delta scrolled in pixels
+     * @param x      X coordinate of the active touch point
+     * @param y      Y coordinate of the active touch point
+     * @return true if child views of v can be scrolled by delta of dx.
+     */
+    protected boolean canChildScrollHorizontally(View v, boolean checkV, int dx, int x, int y) {
+        if (v instanceof ViewGroup) {
+            final ViewGroup group = (ViewGroup) v;
+
+            final int count = group.getChildCount();
+            // Count backwards - let topmost views consume scroll distance first.
+            for (int i = count - 1; i >= 0; i--) {
+                final View child = group.getChildAt(i);
+
+                final int childLeft = child.getLeft() + supportGetTranslationX(child);
+                final int childRight = child.getRight() + supportGetTranslationX(child);
+                final int childTop = child.getTop() + supportGetTranslationY(child);
+                final int childBottom = child.getBottom() + supportGetTranslationY(child);
+
+                if (x >= childLeft && x < childRight && y >= childTop && y < childBottom
+                        && canChildScrollHorizontally(child, true, dx, x - childLeft, y - childTop)) {
+                    return true;
+                }
+            }
+        }
+
+        return checkV && mOnInterceptMoveEventListener.isViewDraggable(v, dx, x, y);
+    }
+
+    /**
+     * Tests scrollability within child views of v given a delta of dx.
+     *
+     * @param v      View to test for horizontal scrollability
+     * @param checkV Whether the view should be checked for draggability
+     * @param dx     Delta scrolled in pixels
+     * @param x      X coordinate of the active touch point
+     * @param y      Y coordinate of the active touch point
+     * @return true if child views of v can be scrolled by delta of dx.
+     */
+    protected boolean canChildScrollVertically(View v, boolean checkV, int dx, int x, int y) {
+        if (v instanceof ViewGroup) {
+            final ViewGroup group = (ViewGroup) v;
+
+            final int count = group.getChildCount();
+            // Count backwards - let topmost views consume scroll distance first.
+            for (int i = count - 1; i >= 0; i--) {
+                final View child = group.getChildAt(i);
+
+                final int childLeft = child.getLeft() + supportGetTranslationX(child);
+                final int childRight = child.getRight() + supportGetTranslationX(child);
+                final int childTop = child.getTop() + supportGetTranslationY(child);
+                final int childBottom = child.getBottom() + supportGetTranslationY(child);
+
+                if (x >= childLeft && x < childRight && y >= childTop && y < childBottom
+                        && canChildScrollVertically(child, true, dx, x - childLeft, y - childTop)) {
+                    return true;
+                }
+            }
+        }
+
+        return checkV && mOnInterceptMoveEventListener.isViewDraggable(v, dx, x, y);
+    }
+
+    protected float getXVelocity(VelocityTracker velocityTracker) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) {
+            return velocityTracker.getXVelocity(mActivePointerId);
+        }
+
+        return velocityTracker.getXVelocity();
+    }
+
+    protected float getYVelocity(VelocityTracker velocityTracker) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.FROYO) {
+            return velocityTracker.getYVelocity(mActivePointerId);
+        }
+
+        return velocityTracker.getYVelocity();
+    }
+
+    private int supportGetTranslationY(View v) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            return (int) v.getTranslationY();
+        }
+
+        return 0;
+    }
+
+    private int supportGetTranslationX(View v) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            return (int) v.getTranslationX();
+        }
+
+        return 0;
+    }
+
+    void saveState(Bundle state) {
+        final boolean menuVisible = mDrawerState == STATE_OPEN || mDrawerState == STATE_OPENING;
+        state.putBoolean(STATE_MENU_VISIBLE, menuVisible);
+    }
+
+    public void restoreState(Parcelable in) {
+        super.restoreState(in);
+        Bundle state = (Bundle) in;
+        final boolean menuOpen = state.getBoolean(STATE_MENU_VISIBLE);
+        if (menuOpen) {
+            openMenu(false);
+        } else {
+            setOffsetPixels(0);
+        }
+        mDrawerState = menuOpen ? STATE_OPEN : STATE_CLOSED;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/FloatScroller.java

@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.simonvt.menudrawer;
+
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+
+/**
+ * This class encapsulates scrolling.  The duration of the scroll
+ * can be passed in the constructor and specifies the maximum time that
+ * the scrolling animation should take.  Past this time, the scrolling is
+ * automatically moved to its final stage and computeScrollOffset()
+ * will always return false to indicate that scrolling is over.
+ */
+class FloatScroller {
+
+    private float mStart;
+    private float mFinal;
+
+    private float mCurr;
+    private long mStartTime;
+    private int mDuration;
+    private float mDurationReciprocal;
+    private float mDeltaX;
+    private boolean mFinished;
+    private Interpolator mInterpolator;
+
+    /**
+     * Create a Scroller with the specified interpolator. If the interpolator is
+     * null, the default (viscous) interpolator will be used. Specify whether or
+     * not to support progressive "flywheel" behavior in flinging.
+     */
+    public FloatScroller(Interpolator interpolator) {
+        mFinished = true;
+        mInterpolator = interpolator;
+    }
+
+    /**
+     * Returns whether the scroller has finished scrolling.
+     *
+     * @return True if the scroller has finished scrolling, false otherwise.
+     */
+    public final boolean isFinished() {
+        return mFinished;
+    }
+
+    /**
+     * Force the finished field to a particular value.
+     *
+     * @param finished The new finished value.
+     */
+    public final void forceFinished(boolean finished) {
+        mFinished = finished;
+    }
+
+    /**
+     * Returns how long the scroll event will take, in milliseconds.
+     *
+     * @return The duration of the scroll in milliseconds.
+     */
+    public final int getDuration() {
+        return mDuration;
+    }
+
+    /**
+     * Returns the current offset in the scroll.
+     *
+     * @return The new offset as an absolute distance from the origin.
+     */
+    public final float getCurr() {
+        return mCurr;
+    }
+
+    /**
+     * Returns the start offset in the scroll.
+     *
+     * @return The start offset as an absolute distance from the origin.
+     */
+    public final float getStart() {
+        return mStart;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final offset as an absolute distance from the origin.
+     */
+    public final float getFinal() {
+        return mFinal;
+    }
+
+    public boolean computeScrollOffset() {
+        if (mFinished) {
+            return false;
+        }
+
+        int timePassed = (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+
+        if (timePassed < mDuration) {
+            float x = timePassed * mDurationReciprocal;
+            x = mInterpolator.getInterpolation(x);
+            mCurr = mStart + x * mDeltaX;
+
+        } else {
+            mCurr = mFinal;
+            mFinished = true;
+        }
+        return true;
+    }
+
+    public void startScroll(float start, float delta, int duration) {
+        mFinished = false;
+        mDuration = duration;
+        mStartTime = AnimationUtils.currentAnimationTimeMillis();
+        mStart = start;
+        mFinal = start + delta;
+        mDeltaX = delta;
+        mDurationReciprocal = 1.0f / (float) mDuration;
+    }
+
+    /**
+     * Stops the animation. Contrary to {@link #forceFinished(boolean)},
+     * aborting the animating cause the scroller to move to the final x and y
+     * position
+     *
+     * @see #forceFinished(boolean)
+     */
+    public void abortAnimation() {
+        mCurr = mFinal;
+        mFinished = true;
+    }
+
+    /**
+     * Extend the scroll animation. This allows a running animation to scroll
+     * further and longer, when used with {@link #setFinal(float)}.
+     *
+     * @param extend Additional time to scroll in milliseconds.
+     * @see #setFinal(float)
+     */
+    public void extendDuration(int extend) {
+        int passed = timePassed();
+        mDuration = passed + extend;
+        mDurationReciprocal = 1.0f / mDuration;
+        mFinished = false;
+    }
+
+    /**
+     * Returns the time elapsed since the beginning of the scrolling.
+     *
+     * @return The elapsed time in milliseconds.
+     */
+    public int timePassed() {
+        return (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+    }
+
+    public void setFinal(float newVal) {
+        mFinal = newVal;
+        mDeltaX = mFinal - mStart;
+        mFinished = false;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/NoClickThroughFrameLayout.java

@@ -0,0 +1,28 @@
+package net.simonvt.menudrawer;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+
+/**
+ * FrameLayout which doesn't let touch events propagate to views positioned behind it in the view hierarchy.
+ */
+class NoClickThroughFrameLayout extends BuildLayerFrameLayout {
+
+    public NoClickThroughFrameLayout(Context context) {
+        super(context);
+    }
+
+    public NoClickThroughFrameLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public NoClickThroughFrameLayout(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        return true;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/OverlayDrawer.java

@@ -0,0 +1,781 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.GradientDrawable;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+import android.view.View;
+
+public class OverlayDrawer extends DraggableDrawer {
+
+    private static final String TAG = "OverlayDrawer";
+
+    private int mPeekSize;
+
+    private Runnable mRevealRunnable = new Runnable() {
+        @Override
+        public void run() {
+            cancelContentTouch();
+            int animateTo = 0;
+            switch (getPosition()) {
+                case RIGHT:
+                case BOTTOM:
+                    animateTo = -mPeekSize;
+                    break;
+
+                default:
+                    animateTo = mPeekSize;
+                    break;
+            }
+            animateOffsetTo(animateTo, 250);
+        }
+    };
+
+    OverlayDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public OverlayDrawer(Context context) {
+        super(context);
+    }
+
+    public OverlayDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public OverlayDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        super.addView(mContentContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+        if (USE_TRANSLATIONS) {
+            mContentContainer.setLayerType(View.LAYER_TYPE_NONE, null);
+        }
+        mContentContainer.setHardwareLayersEnabled(false);
+        super.addView(mMenuContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+        mPeekSize = dpToPx(20);
+    }
+
+    @Override
+    protected void drawOverlay(Canvas canvas) {
+        final int width = getWidth();
+        final int height = getHeight();
+        final int offsetPixels = (int) mOffsetPixels;
+        final float openRatio = Math.abs(mOffsetPixels) / mMenuSize;
+
+        switch (getPosition()) {
+            case LEFT:
+                mMenuOverlay.setBounds(offsetPixels, 0, width, height);
+                break;
+
+            case RIGHT:
+                mMenuOverlay.setBounds(0, 0, width + offsetPixels, height);
+                break;
+
+            case TOP:
+                mMenuOverlay.setBounds(0, offsetPixels, width, height);
+                break;
+
+            case BOTTOM:
+                mMenuOverlay.setBounds(0, 0, width, height + offsetPixels);
+                break;
+        }
+
+        mMenuOverlay.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * openRatio));
+        mMenuOverlay.draw(canvas);
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        int animateTo = 0;
+        switch (getPosition()) {
+            case LEFT:
+            case TOP:
+                animateTo = mMenuSize;
+                break;
+
+            case RIGHT:
+            case BOTTOM:
+                animateTo = -mMenuSize;
+                break;
+        }
+
+        animateOffsetTo(animateTo, 0, animate);
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        animateOffsetTo(0, 0, animate);
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        if (USE_TRANSLATIONS) {
+            switch (getPosition()) {
+                case LEFT:
+                    mMenuContainer.setTranslationX(offsetPixels - mMenuSize);
+                    break;
+
+                case TOP:
+                    mMenuContainer.setTranslationY(offsetPixels - mMenuSize);
+                    break;
+
+                case RIGHT:
+                    mMenuContainer.setTranslationX(offsetPixels + mMenuSize);
+                    break;
+
+                case BOTTOM:
+                    mMenuContainer.setTranslationY(offsetPixels + mMenuSize);
+                    break;
+            }
+        } else {
+            switch (getPosition()) {
+                case TOP:
+                    mMenuContainer.offsetTopAndBottom(offsetPixels - mMenuContainer.getBottom());
+                    break;
+
+                case BOTTOM:
+                    mMenuContainer.offsetTopAndBottom(offsetPixels - (mMenuContainer.getTop() - getHeight()));
+                    break;
+
+                case LEFT:
+                    mMenuContainer.offsetLeftAndRight(offsetPixels - mMenuContainer.getRight());
+                    break;
+
+                case RIGHT:
+                    mMenuContainer.offsetLeftAndRight(offsetPixels - (mMenuContainer.getLeft() - getWidth()));
+                    break;
+            }
+        }
+
+        invalidate();
+    }
+
+    @Override
+    protected void initPeekScroller() {
+        switch (getPosition()) {
+            case RIGHT:
+            case BOTTOM: {
+                final int dx = -mPeekSize;
+                mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+                break;
+            }
+
+            default: {
+                final int dx = mPeekSize;
+                mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+                break;
+            }
+        }
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        onOffsetPixelsChanged((int) mOffsetPixels);
+    }
+
+    @Override
+    protected GradientDrawable.Orientation getDropShadowOrientation() {
+        switch (getPosition()) {
+            case TOP:
+                return GradientDrawable.Orientation.TOP_BOTTOM;
+
+            case RIGHT:
+                return GradientDrawable.Orientation.RIGHT_LEFT;
+
+            case BOTTOM:
+                return GradientDrawable.Orientation.BOTTOM_TOP;
+
+            default:
+                return GradientDrawable.Orientation.LEFT_RIGHT;
+        }
+    }
+
+    @Override
+    protected void updateDropShadowRect() {
+        final float openRatio = Math.abs(mOffsetPixels) / mMenuSize;
+        final int dropShadowSize = (int) (mDropShadowSize * openRatio);
+
+        switch (getPosition()) {
+            case LEFT:
+                mDropShadowRect.top = 0;
+                mDropShadowRect.bottom = getHeight();
+                mDropShadowRect.left = ViewHelper.getRight(mMenuContainer);
+                mDropShadowRect.right = mDropShadowRect.left + dropShadowSize;
+                break;
+
+            case TOP:
+                mDropShadowRect.left = 0;
+                mDropShadowRect.right = getWidth();
+                mDropShadowRect.top = ViewHelper.getBottom(mMenuContainer);
+                mDropShadowRect.bottom = mDropShadowRect.top + dropShadowSize;
+                break;
+
+            case RIGHT:
+                mDropShadowRect.top = 0;
+                mDropShadowRect.bottom = getHeight();
+                mDropShadowRect.right = ViewHelper.getLeft(mMenuContainer);
+                mDropShadowRect.left = mDropShadowRect.right - dropShadowSize;
+                break;
+
+            case BOTTOM:
+                mDropShadowRect.left = 0;
+                mDropShadowRect.right = getWidth();
+                mDropShadowRect.bottom = ViewHelper.getTop(mMenuContainer);
+                mDropShadowRect.top = mDropShadowRect.bottom - dropShadowSize;
+                break;
+        }
+    }
+
+    @Override
+    protected void startLayerTranslation() {
+        if (USE_TRANSLATIONS && mHardwareLayersEnabled && !mLayerTypeHardware) {
+            mLayerTypeHardware = true;
+            mMenuContainer.setLayerType(View.LAYER_TYPE_HARDWARE, null);
+        }
+    }
+
+    @Override
+    protected void stopLayerTranslation() {
+        if (mLayerTypeHardware) {
+            mLayerTypeHardware = false;
+            mMenuContainer.setLayerType(View.LAYER_TYPE_NONE, null);
+        }
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+
+        mContentContainer.layout(0, 0, width, height);
+
+        if (USE_TRANSLATIONS) {
+            switch (getPosition()) {
+                case LEFT:
+                    mMenuContainer.layout(0, 0, mMenuSize, height);
+                    break;
+
+                case RIGHT:
+                    mMenuContainer.layout(width - mMenuSize, 0, width, height);
+                    break;
+
+                case TOP:
+                    mMenuContainer.layout(0, 0, width, mMenuSize);
+                    break;
+
+                case BOTTOM:
+                    mMenuContainer.layout(0, height - mMenuSize, width, height);
+                    break;
+            }
+
+        } else {
+            final int offsetPixels = (int) mOffsetPixels;
+            final int menuSize = mMenuSize;
+
+            switch (getPosition()) {
+                case LEFT:
+                    mMenuContainer.layout(-menuSize + offsetPixels, 0, offsetPixels, height);
+                    break;
+
+                case RIGHT:
+                    mMenuContainer.layout(width + offsetPixels, 0, width + menuSize + offsetPixels, height);
+                    break;
+
+                case TOP:
+                    mMenuContainer.layout(0, -menuSize + offsetPixels, width, offsetPixels);
+                    break;
+
+                case BOTTOM:
+                    mMenuContainer.layout(0, height + offsetPixels, width, height + menuSize + offsetPixels);
+                    break;
+            }
+        }
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
+            throw new IllegalStateException("Must measure with an exact size");
+        }
+
+        final int width = MeasureSpec.getSize(widthMeasureSpec);
+        final int height = MeasureSpec.getSize(heightMeasureSpec);
+
+        if (mOffsetPixels == -1) openMenu(false);
+
+        int menuWidthMeasureSpec;
+        int menuHeightMeasureSpec;
+        switch (getPosition()) {
+            case TOP:
+            case BOTTOM:
+                menuWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+                menuHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, 0, mMenuSize);
+                break;
+
+            default:
+                // LEFT/RIGHT
+                menuWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, mMenuSize);
+                menuHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        }
+        mMenuContainer.measure(menuWidthMeasureSpec, menuHeightMeasureSpec);
+
+        final int contentWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+        final int contentHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        mContentContainer.measure(contentWidthMeasureSpec, contentHeightMeasureSpec);
+
+        setMeasuredDimension(width, height);
+
+        updateTouchAreaSize();
+    }
+
+    private boolean isContentTouch(int x, int y) {
+        boolean contentTouch = false;
+
+        switch (getPosition()) {
+            case LEFT:
+                contentTouch = ViewHelper.getRight(mMenuContainer) < x;
+                break;
+
+            case RIGHT:
+                contentTouch = ViewHelper.getLeft(mMenuContainer) > x;
+                break;
+
+            case TOP:
+                contentTouch = ViewHelper.getBottom(mMenuContainer) < y;
+                break;
+
+            case BOTTOM:
+                contentTouch = ViewHelper.getTop(mMenuContainer) > y;
+                break;
+        }
+
+        return contentTouch;
+    }
+
+    protected boolean onDownAllowDrag(int x, int y) {
+        switch (getPosition()) {
+            case LEFT:
+                return (!mMenuVisible && mInitialMotionX <= mTouchSize)
+                        || (mMenuVisible && mInitialMotionX <= mOffsetPixels);
+
+            case RIGHT:
+                final int width = getWidth();
+                final int initialMotionX = (int) mInitialMotionX;
+
+                return (!mMenuVisible && initialMotionX >= width - mTouchSize)
+                        || (mMenuVisible && initialMotionX >= width + mOffsetPixels);
+
+            case TOP:
+                return (!mMenuVisible && mInitialMotionY <= mTouchSize)
+                        || (mMenuVisible && mInitialMotionY <= mOffsetPixels);
+
+            case BOTTOM:
+                final int height = getHeight();
+                return (!mMenuVisible && mInitialMotionY >= height - mTouchSize)
+                        || (mMenuVisible && mInitialMotionY >= height + mOffsetPixels);
+        }
+
+        return false;
+    }
+
+    protected boolean onMoveAllowDrag(int x, int y, float dx, float dy) {
+        if (mMenuVisible && mTouchMode == TOUCH_MODE_FULLSCREEN) {
+            return true;
+        }
+
+        switch (getPosition()) {
+            case LEFT:
+                return (!mMenuVisible && mInitialMotionX <= mTouchSize && (dx > 0)) // Drawer closed
+                        || (mMenuVisible && x <= mOffsetPixels) // Drawer open
+                        || (Math.abs(mOffsetPixels) <= mPeekSize && mMenuVisible); // Drawer revealed
+
+            case RIGHT:
+                final int width = getWidth();
+                return (!mMenuVisible && mInitialMotionX >= width - mTouchSize && (dx < 0))
+                        || (mMenuVisible && x >= width - mOffsetPixels)
+                        || (Math.abs(mOffsetPixels) <= mPeekSize && mMenuVisible);
+
+            case TOP:
+                return (!mMenuVisible && mInitialMotionY <= mTouchSize && (dy > 0))
+                        || (mMenuVisible && x <= mOffsetPixels)
+                        || (Math.abs(mOffsetPixels) <= mPeekSize && mMenuVisible);
+
+            case BOTTOM:
+                final int height = getHeight();
+                return (!mMenuVisible && mInitialMotionY >= height - mTouchSize && (dy < 0))
+                        || (mMenuVisible && x >= height - mOffsetPixels)
+                        || (Math.abs(mOffsetPixels) <= mPeekSize && mMenuVisible);
+        }
+
+        return false;
+    }
+
+    protected void onMoveEvent(float dx, float dy) {
+        switch (getPosition()) {
+            case LEFT:
+                setOffsetPixels(Math.min(Math.max(mOffsetPixels + dx, 0), mMenuSize));
+                break;
+
+            case RIGHT:
+                setOffsetPixels(Math.max(Math.min(mOffsetPixels + dx, 0), -mMenuSize));
+                break;
+
+            case TOP:
+                setOffsetPixels(Math.min(Math.max(mOffsetPixels + dy, 0), mMenuSize));
+                break;
+
+            case BOTTOM:
+                setOffsetPixels(Math.max(Math.min(mOffsetPixels + dy, 0), -mMenuSize));
+                break;
+        }
+    }
+
+    protected void onUpEvent(int x, int y) {
+        final int offsetPixels = (int) mOffsetPixels;
+
+        switch (getPosition()) {
+            case LEFT: {
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getXVelocity(mVelocityTracker);
+                    mLastMotionX = x;
+                    animateOffsetTo(initialVelocity > 0 ? mMenuSize : 0, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible) {
+                    closeMenu();
+                }
+                break;
+            }
+
+            case TOP: {
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getYVelocity(mVelocityTracker);
+                    mLastMotionY = y;
+                    animateOffsetTo(initialVelocity > 0 ? mMenuSize : 0, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible) {
+                    closeMenu();
+                }
+                break;
+            }
+
+            case RIGHT: {
+                final int width = getWidth();
+
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getXVelocity(mVelocityTracker);
+                    mLastMotionX = x;
+                    animateOffsetTo(initialVelocity > 0 ? 0 : -mMenuSize, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible) {
+                    closeMenu();
+                }
+                break;
+            }
+
+            case BOTTOM: {
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getYVelocity(mVelocityTracker);
+                    mLastMotionY = y;
+                    animateOffsetTo(initialVelocity < 0 ? -mMenuSize : 0, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible) {
+                    closeMenu();
+                }
+                break;
+            }
+        }
+    }
+
+    protected boolean checkTouchSlop(float dx, float dy) {
+        switch (getPosition()) {
+            case TOP:
+            case BOTTOM:
+                return Math.abs(dy) > mTouchSlop && Math.abs(dy) > Math.abs(dx);
+
+            default:
+                return Math.abs(dx) > mTouchSlop && Math.abs(dx) > Math.abs(dy);
+        }
+    }
+
+    @Override
+    protected void stopAnimation() {
+        super.stopAnimation();
+        removeCallbacks(mRevealRunnable);
+    }
+
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+            removeCallbacks(mRevealRunnable);
+            mActivePointerId = INVALID_POINTER;
+            mIsDragging = false;
+            if (mVelocityTracker != null) {
+                mVelocityTracker.recycle();
+                mVelocityTracker = null;
+            }
+
+            if (Math.abs(mOffsetPixels) > mMenuSize / 2) {
+                openMenu();
+            } else {
+                closeMenu();
+            }
+
+            return false;
+        }
+
+        if (action == MotionEvent.ACTION_DOWN && mMenuVisible && isCloseEnough()) {
+            setOffsetPixels(0);
+            stopAnimation();
+            endPeek();
+            setDrawerState(STATE_CLOSED);
+            mIsDragging = false;
+        }
+
+        // Always intercept events over the content while menu is visible.
+        if (mMenuVisible) {
+            int index = 0;
+            if (mActivePointerId != INVALID_POINTER) {
+                index = ev.findPointerIndex(mActivePointerId);
+                index = index == -1 ? 0 : index;
+            }
+
+            final int x = (int) ev.getX(index);
+            final int y = (int) ev.getY(index);
+            if (isContentTouch(x, y)) {
+                return true;
+            }
+        }
+
+        if (!mMenuVisible && !mIsDragging && mTouchMode == TOUCH_MODE_NONE) {
+            return false;
+        }
+
+        if (action != MotionEvent.ACTION_DOWN && mIsDragging) {
+            return true;
+        }
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag((int) mLastMotionX, (int) mLastMotionY);
+                mActivePointerId = ev.getPointerId(0);
+
+                if (allowDrag) {
+                    setDrawerState(mMenuVisible ? STATE_OPEN : STATE_CLOSED);
+                    stopAnimation();
+                    endPeek();
+
+                    if (!mMenuVisible && mInitialMotionX <= mPeekSize) {
+                        postDelayed(mRevealRunnable, 160);
+                    }
+
+                    mIsDragging = false;
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final int activePointerId = mActivePointerId;
+                if (activePointerId == INVALID_POINTER) {
+                    // If we don't have a valid id, the touch down wasn't on content.
+                    break;
+                }
+
+                final int pointerIndex = ev.findPointerIndex(activePointerId);
+                if (pointerIndex == -1) {
+                    mIsDragging = false;
+                    mActivePointerId = INVALID_POINTER;
+                    endDrag();
+                    closeMenu(true);
+                    return false;
+                }
+
+                final float x = ev.getX(pointerIndex);
+                final float dx = x - mLastMotionX;
+                final float y = ev.getY(pointerIndex);
+                final float dy = y - mLastMotionY;
+
+                if (Math.abs(dx) >= mTouchSlop || Math.abs(dy) >= mTouchSlop) {
+                    removeCallbacks(mRevealRunnable);
+                    endPeek();
+                }
+
+                if (checkTouchSlop(dx, dy)) {
+                    if (mOnInterceptMoveEventListener != null && (mTouchMode == TOUCH_MODE_FULLSCREEN || mMenuVisible)
+                            && canChildrenScroll((int) dx, (int) dy, (int) x, (int) y)) {
+                        endDrag(); // Release the velocity tracker
+                        requestDisallowInterceptTouchEvent(true);
+                        return false;
+                    }
+
+                    final boolean allowDrag = onMoveAllowDrag((int) x, (int) y, dx, dy);
+
+                    if (allowDrag) {
+                        endPeek();
+                        stopAnimation();
+                        setDrawerState(STATE_DRAGGING);
+                        mIsDragging = true;
+                        mLastMotionX = x;
+                        mLastMotionY = y;
+                    }
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_POINTER_UP:
+                onPointerUp(ev);
+                mLastMotionX = ev.getX(ev.findPointerIndex(mActivePointerId));
+                mLastMotionY = ev.getY(ev.findPointerIndex(mActivePointerId));
+                break;
+        }
+
+        if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
+        mVelocityTracker.addMovement(ev);
+
+        return mIsDragging;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        if (!mMenuVisible && !mIsDragging && mTouchMode == TOUCH_MODE_NONE) {
+            return false;
+        }
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
+        mVelocityTracker.addMovement(ev);
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag((int) mLastMotionX, (int) mLastMotionY);
+
+                mActivePointerId = ev.getPointerId(0);
+
+                if (allowDrag) {
+                    stopAnimation();
+                    endPeek();
+
+                    if (!mMenuVisible && mLastMotionX <= mPeekSize) {
+                        postDelayed(mRevealRunnable, 160);
+                    }
+
+                    startLayerTranslation();
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (pointerIndex == -1) {
+                    mIsDragging = false;
+                    mActivePointerId = INVALID_POINTER;
+                    endDrag();
+                    closeMenu(true);
+                    return false;
+                }
+
+                if (!mIsDragging) {
+                    final float x = ev.getX(pointerIndex);
+                    final float dx = x - mLastMotionX;
+                    final float y = ev.getY(pointerIndex);
+                    final float dy = y - mLastMotionY;
+
+                    if (checkTouchSlop(dx, dy)) {
+                        final boolean allowDrag = onMoveAllowDrag((int) x, (int) y, dx, dy);
+
+                        if (allowDrag) {
+                            endPeek();
+                            stopAnimation();
+                            setDrawerState(STATE_DRAGGING);
+                            mIsDragging = true;
+                            mLastMotionX = x;
+                            mLastMotionY = y;
+                        } else {
+                            mInitialMotionX = x;
+                            mInitialMotionY = y;
+                        }
+                    }
+                }
+
+                if (mIsDragging) {
+                    startLayerTranslation();
+
+                    final float x = ev.getX(pointerIndex);
+                    final float dx = x - mLastMotionX;
+                    final float y = ev.getY(pointerIndex);
+                    final float dy = y - mLastMotionY;
+
+                    mLastMotionX = x;
+                    mLastMotionY = y;
+                    onMoveEvent(dx, dy);
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
+                removeCallbacks(mRevealRunnable);
+                int index = ev.findPointerIndex(mActivePointerId);
+                index = index == -1 ? 0 : index;
+                final int x = (int) ev.getX(index);
+                final int y = (int) ev.getY(index);
+                onUpEvent(x, y);
+                mActivePointerId = INVALID_POINTER;
+                mIsDragging = false;
+                break;
+            }
+
+            case MotionEvent.ACTION_POINTER_DOWN:
+                final int index = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
+                        >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+                mLastMotionX = ev.getX(index);
+                mLastMotionY = ev.getY(index);
+                mActivePointerId = ev.getPointerId(index);
+                break;
+
+            case MotionEvent.ACTION_POINTER_UP:
+                onPointerUp(ev);
+                mLastMotionX = ev.getX(ev.findPointerIndex(mActivePointerId));
+                mLastMotionY = ev.getY(ev.findPointerIndex(mActivePointerId));
+                break;
+        }
+
+        return true;
+    }
+
+    private void onPointerUp(MotionEvent ev) {
+        final int pointerIndex = ev.getActionIndex();
+        final int pointerId = ev.getPointerId(pointerIndex);
+        if (pointerId == mActivePointerId) {
+            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
+            mLastMotionX = ev.getX(newPointerIndex);
+            mActivePointerId = ev.getPointerId(newPointerIndex);
+            if (mVelocityTracker != null) {
+                mVelocityTracker.clear();
+            }
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/PeekInterpolator.java

@@ -0,0 +1,28 @@
+package net.simonvt.menudrawer;
+
+import android.view.animation.Interpolator;
+
+class PeekInterpolator implements Interpolator {
+
+    private static final String TAG = "PeekInterpolator";
+
+    private static final SinusoidalInterpolator SINUSOIDAL_INTERPOLATOR = new SinusoidalInterpolator();
+
+    @Override
+    public float getInterpolation(float input) {
+        float result;
+
+        if (input < 1.f / 3.f) {
+            result = SINUSOIDAL_INTERPOLATOR.getInterpolation(input * 3);
+
+        } else if (input > 2.f / 3.f) {
+            final float val = ((input + 1.f / 3.f) - 1.f) * 3.f;
+            result = 1.f - SINUSOIDAL_INTERPOLATOR.getInterpolation(val);
+
+        } else {
+            result = 1.f;
+        }
+
+        return result;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/Position.java

@@ -0,0 +1,50 @@
+package net.simonvt.menudrawer;
+
+import android.util.SparseArray;
+
+/**
+ * Enums used for positioning the drawer.
+ */
+public enum Position {
+    // Positions the drawer to the left of the content.
+    LEFT(0),
+
+    // Positions the drawer above the content.
+    TOP(1),
+
+    // Positions the drawer to the right of the content.
+    RIGHT(2),
+
+    // Positions the drawer below the content.
+    BOTTOM(3),
+
+    /**
+     * Position the drawer at the start edge. This will position the drawer to the {@link #LEFT} with LTR languages and
+     * {@link #RIGHT} with RTL languages.
+     */
+    START(4),
+
+    /**
+     * Position the drawer at the end edge. This will position the drawer to the {@link #RIGHT} with LTR languages and
+     * {@link #LEFT} with RTL languages.
+     */
+    END(5);
+
+    final int mValue;
+
+    Position(int value) {
+        mValue = value;
+    }
+
+    private static final SparseArray<Position> STRING_MAPPING = new SparseArray<Position>();
+
+    static {
+        for (Position via : Position.values()) {
+            STRING_MAPPING.put(via.mValue, via);
+        }
+    }
+
+    public static Position fromValue(int value) {
+        return STRING_MAPPING.get(value);
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/Scroller.java

@@ -0,0 +1,504 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package net.simonvt.menudrawer;
+
+import android.content.Context;
+import android.hardware.SensorManager;
+import android.os.Build;
+import android.view.ViewConfiguration;
+import android.view.animation.AnimationUtils;
+import android.view.animation.Interpolator;
+
+
+/**
+ * This class encapsulates scrolling.  The duration of the scroll
+ * can be passed in the constructor and specifies the maximum time that
+ * the scrolling animation should take.  Past this time, the scrolling is
+ * automatically moved to its final stage and computeScrollOffset()
+ * will always return false to indicate that scrolling is over.
+ */
+class Scroller  {
+    private int mMode;
+
+    private int mStartX;
+    private int mStartY;
+    private int mFinalX;
+    private int mFinalY;
+
+    private int mMinX;
+    private int mMaxX;
+    private int mMinY;
+    private int mMaxY;
+
+    private int mCurrX;
+    private int mCurrY;
+    private long mStartTime;
+    private int mDuration;
+    private float mDurationReciprocal;
+    private float mDeltaX;
+    private float mDeltaY;
+    private boolean mFinished;
+    private Interpolator mInterpolator;
+    private boolean mFlywheel;
+
+    private float mVelocity;
+
+    private static final int DEFAULT_DURATION = 250;
+    private static final int SCROLL_MODE = 0;
+    private static final int FLING_MODE = 1;
+
+    private static final float DECELERATION_RATE = (float) (Math.log(0.75) / Math.log(0.9));
+    private static final float ALPHA = 800; // pixels / seconds
+    private static final float START_TENSION = 0.4f; // Tension at start: (0.4 * total T, 1.0 * Distance)
+    private static final float END_TENSION = 1.0f - START_TENSION;
+    private static final int NB_SAMPLES = 100;
+    private static final float[] SPLINE = new float[NB_SAMPLES + 1];
+
+    private float mDeceleration;
+    private final float mPpi;
+
+    static {
+        float xMin = 0.0f;
+        for (int i = 0; i <= NB_SAMPLES; i++) {
+            final float t = (float) i / NB_SAMPLES;
+            float xMax = 1.0f;
+            float x, tx, coef;
+            while (true) {
+                x = xMin + (xMax - xMin) / 2.0f;
+                coef = 3.0f * x * (1.0f - x);
+                tx = coef * ((1.0f - x) * START_TENSION + x * END_TENSION) + x * x * x;
+                if (Math.abs(tx - t) < 1E-5) break;
+                if (tx > t) xMax = x;
+                else xMin = x;
+            }
+            final float d = coef + x * x * x;
+            SPLINE[i] = d;
+        }
+        SPLINE[NB_SAMPLES] = 1.0f;
+
+        // This controls the viscous fluid effect (how much of it)
+        sViscousFluidScale = 8.0f;
+        // must be set to 1.0 (used in viscousFluid())
+        sViscousFluidNormalize = 1.0f;
+        sViscousFluidNormalize = 1.0f / viscousFluid(1.0f);
+    }
+
+    private static float sViscousFluidScale;
+    private static float sViscousFluidNormalize;
+
+    /**
+     * Create a Scroller with the default duration and interpolator.
+     */
+    public Scroller(Context context) {
+        this(context, null);
+    }
+
+    /**
+     * Create a Scroller with the specified interpolator. If the interpolator is
+     * null, the default (viscous) interpolator will be used. "Flywheel" behavior will
+     * be in effect for apps targeting Honeycomb or newer.
+     */
+    public Scroller(Context context, Interpolator interpolator) {
+        this(context, interpolator,
+                context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.HONEYCOMB);
+    }
+
+    /**
+     * Create a Scroller with the specified interpolator. If the interpolator is
+     * null, the default (viscous) interpolator will be used. Specify whether or
+     * not to support progressive "flywheel" behavior in flinging.
+     */
+    public Scroller(Context context, Interpolator interpolator, boolean flywheel) {
+        mFinished = true;
+        mInterpolator = interpolator;
+        mPpi = context.getResources().getDisplayMetrics().density * 160.0f;
+        mDeceleration = computeDeceleration(ViewConfiguration.getScrollFriction());
+        mFlywheel = flywheel;
+    }
+
+    /**
+     * The amount of friction applied to flings. The default value
+     * is {@link android.view.ViewConfiguration#getScrollFriction}.
+     *
+     * @param friction A scalar dimension-less value representing the coefficient of
+     *         friction.
+     */
+    public final void setFriction(float friction) {
+        mDeceleration = computeDeceleration(friction);
+    }
+
+    private float computeDeceleration(float friction) {
+        return SensorManager.GRAVITY_EARTH   // g (m/s^2)
+                      * 39.37f               // inch/meter
+                      * mPpi                 // pixels per inch
+                      * friction;
+    }
+
+    /**
+     *
+     * Returns whether the scroller has finished scrolling.
+     *
+     * @return True if the scroller has finished scrolling, false otherwise.
+     */
+    public final boolean isFinished() {
+        return mFinished;
+    }
+
+    /**
+     * Force the finished field to a particular value.
+     *
+     * @param finished The new finished value.
+     */
+    public final void forceFinished(boolean finished) {
+        mFinished = finished;
+    }
+
+    /**
+     * Returns how long the scroll event will take, in milliseconds.
+     *
+     * @return The duration of the scroll in milliseconds.
+     */
+    public final int getDuration() {
+        return mDuration;
+    }
+
+    /**
+     * Returns the current X offset in the scroll.
+     *
+     * @return The new X offset as an absolute distance from the origin.
+     */
+    public final int getCurrX() {
+        return mCurrX;
+    }
+
+    /**
+     * Returns the current Y offset in the scroll.
+     *
+     * @return The new Y offset as an absolute distance from the origin.
+     */
+    public final int getCurrY() {
+        return mCurrY;
+    }
+
+    /**
+     * Returns the current velocity.
+     *
+     * @return The original velocity less the deceleration. Result may be
+     * negative.
+     */
+    public float getCurrVelocity() {
+        return mVelocity - mDeceleration * timePassed() / 2000.0f;
+    }
+
+    /**
+     * Returns the start X offset in the scroll.
+     *
+     * @return The start X offset as an absolute distance from the origin.
+     */
+    public final int getStartX() {
+        return mStartX;
+    }
+
+    /**
+     * Returns the start Y offset in the scroll.
+     *
+     * @return The start Y offset as an absolute distance from the origin.
+     */
+    public final int getStartY() {
+        return mStartY;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final X offset as an absolute distance from the origin.
+     */
+    public final int getFinalX() {
+        return mFinalX;
+    }
+
+    /**
+     * Returns where the scroll will end. Valid only for "fling" scrolls.
+     *
+     * @return The final Y offset as an absolute distance from the origin.
+     */
+    public final int getFinalY() {
+        return mFinalY;
+    }
+
+    /**
+     * Call this when you want to know the new location.  If it returns true,
+     * the animation is not yet finished.  loc will be altered to provide the
+     * new location.
+     */
+    public boolean computeScrollOffset() {
+        if (mFinished) {
+            return false;
+        }
+
+        int timePassed = (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+
+        if (timePassed < mDuration) {
+            switch (mMode) {
+            case SCROLL_MODE:
+                float x = timePassed * mDurationReciprocal;
+
+                if (mInterpolator == null)
+                    x = viscousFluid(x);
+                else
+                    x = mInterpolator.getInterpolation(x);
+
+                mCurrX = mStartX + Math.round(x * mDeltaX);
+                mCurrY = mStartY + Math.round(x * mDeltaY);
+                break;
+            case FLING_MODE:
+                final float t = (float) timePassed / mDuration;
+                final int index = (int) (NB_SAMPLES * t);
+                final float tInf = (float) index / NB_SAMPLES;
+                final float tSup = (float) (index + 1) / NB_SAMPLES;
+                final float dInf = SPLINE[index];
+                final float dSup = SPLINE[index + 1];
+                final float distanceCoef = dInf + (t - tInf) / (tSup - tInf) * (dSup - dInf);
+
+                mCurrX = mStartX + Math.round(distanceCoef * (mFinalX - mStartX));
+                // Pin to mMinX <= mCurrX <= mMaxX
+                mCurrX = Math.min(mCurrX, mMaxX);
+                mCurrX = Math.max(mCurrX, mMinX);
+
+                mCurrY = mStartY + Math.round(distanceCoef * (mFinalY - mStartY));
+                // Pin to mMinY <= mCurrY <= mMaxY
+                mCurrY = Math.min(mCurrY, mMaxY);
+                mCurrY = Math.max(mCurrY, mMinY);
+
+                if (mCurrX == mFinalX && mCurrY == mFinalY) {
+                    mFinished = true;
+                }
+
+                break;
+            }
+        } else {
+            mCurrX = mFinalX;
+            mCurrY = mFinalY;
+            mFinished = true;
+        }
+        return true;
+    }
+
+    /**
+     * Start scrolling by providing a starting point and the distance to travel.
+     * The scroll will use the default value of 250 milliseconds for the
+     * duration.
+     *
+     * @param startX Starting horizontal scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param startY Starting vertical scroll offset in pixels. Positive numbers
+     *        will scroll the content up.
+     * @param dx Horizontal distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     * @param dy Vertical distance to travel. Positive numbers will scroll the
+     *        content up.
+     */
+    public void startScroll(int startX, int startY, int dx, int dy) {
+        startScroll(startX, startY, dx, dy, DEFAULT_DURATION);
+    }
+
+    /**
+     * Start scrolling by providing a starting point and the distance to travel.
+     *
+     * @param startX Starting horizontal scroll offset in pixels. Positive
+     *        numbers will scroll the content to the left.
+     * @param startY Starting vertical scroll offset in pixels. Positive numbers
+     *        will scroll the content up.
+     * @param dx Horizontal distance to travel. Positive numbers will scroll the
+     *        content to the left.
+     * @param dy Vertical distance to travel. Positive numbers will scroll the
+     *        content up.
+     * @param duration Duration of the scroll in milliseconds.
+     */
+    public void startScroll(int startX, int startY, int dx, int dy, int duration) {
+        mMode = SCROLL_MODE;
+        mFinished = false;
+        mDuration = duration;
+        mStartTime = AnimationUtils.currentAnimationTimeMillis();
+        mStartX = startX;
+        mStartY = startY;
+        mFinalX = startX + dx;
+        mFinalY = startY + dy;
+        mDeltaX = dx;
+        mDeltaY = dy;
+        mDurationReciprocal = 1.0f / (float) mDuration;
+    }
+
+    /**
+     * Start scrolling based on a fling gesture. The distance travelled will
+     * depend on the initial velocity of the fling.
+     *
+     * @param startX Starting point of the scroll (X)
+     * @param startY Starting point of the scroll (Y)
+     * @param velocityX Initial velocity of the fling (X) measured in pixels per
+     *        second.
+     * @param velocityY Initial velocity of the fling (Y) measured in pixels per
+     *        second
+     * @param minX Minimum X value. The scroller will not scroll past this
+     *        point.
+     * @param maxX Maximum X value. The scroller will not scroll past this
+     *        point.
+     * @param minY Minimum Y value. The scroller will not scroll past this
+     *        point.
+     * @param maxY Maximum Y value. The scroller will not scroll past this
+     *        point.
+     */
+    public void fling(int startX, int startY, int velocityX, int velocityY,
+            int minX, int maxX, int minY, int maxY) {
+        // Continue a scroll or fling in progress
+        if (mFlywheel && !mFinished) {
+            float oldVel = getCurrVelocity();
+
+            float dx = (float) (mFinalX - mStartX);
+            float dy = (float) (mFinalY - mStartY);
+            float hyp = (float) Math.sqrt(dx * dx + dy * dy);
+
+            float ndx = dx / hyp;
+            float ndy = dy / hyp;
+
+            float oldVelocityX = ndx * oldVel;
+            float oldVelocityY = ndy * oldVel;
+            if (Math.signum(velocityX) == Math.signum(oldVelocityX)
+                    && Math.signum(velocityY) == Math.signum(oldVelocityY)) {
+                velocityX += oldVelocityX;
+                velocityY += oldVelocityY;
+            }
+        }
+
+        mMode = FLING_MODE;
+        mFinished = false;
+
+        float velocity = (float) Math.sqrt(velocityX * velocityX + velocityY * velocityY);
+
+        mVelocity = velocity;
+        final double l = Math.log(START_TENSION * velocity / ALPHA);
+        mDuration = (int) (1000.0 * Math.exp(l / (DECELERATION_RATE - 1.0)));
+        mStartTime = AnimationUtils.currentAnimationTimeMillis();
+        mStartX = startX;
+        mStartY = startY;
+
+        float coeffX = velocity == 0 ? 1.0f : velocityX / velocity;
+        float coeffY = velocity == 0 ? 1.0f : velocityY / velocity;
+
+        int totalDistance =
+                (int) (ALPHA * Math.exp(DECELERATION_RATE / (DECELERATION_RATE - 1.0) * l));
+
+        mMinX = minX;
+        mMaxX = maxX;
+        mMinY = minY;
+        mMaxY = maxY;
+
+        mFinalX = startX + Math.round(totalDistance * coeffX);
+        // Pin to mMinX <= mFinalX <= mMaxX
+        mFinalX = Math.min(mFinalX, mMaxX);
+        mFinalX = Math.max(mFinalX, mMinX);
+
+        mFinalY = startY + Math.round(totalDistance * coeffY);
+        // Pin to mMinY <= mFinalY <= mMaxY
+        mFinalY = Math.min(mFinalY, mMaxY);
+        mFinalY = Math.max(mFinalY, mMinY);
+    }
+
+    static float viscousFluid(float x) {
+        x *= sViscousFluidScale;
+        if (x < 1.0f) {
+            x -= (1.0f - (float) Math.exp(-x));
+        } else {
+            float start = 0.36787944117f;   // 1/e == exp(-1)
+            x = 1.0f - (float) Math.exp(1.0f - x);
+            x = start + x * (1.0f - start);
+        }
+        x *= sViscousFluidNormalize;
+        return x;
+    }
+
+    /**
+     * Stops the animation. Contrary to {@link #forceFinished(boolean)},
+     * aborting the animating cause the scroller to move to the final x and y
+     * position
+     *
+     * @see #forceFinished(boolean)
+     */
+    public void abortAnimation() {
+        mCurrX = mFinalX;
+        mCurrY = mFinalY;
+        mFinished = true;
+    }
+
+    /**
+     * Extend the scroll animation. This allows a running animation to scroll
+     * further and longer, when used with {@link #setFinalX(int)} or {@link #setFinalY(int)}.
+     *
+     * @param extend Additional time to scroll in milliseconds.
+     * @see #setFinalX(int)
+     * @see #setFinalY(int)
+     */
+    public void extendDuration(int extend) {
+        int passed = timePassed();
+        mDuration = passed + extend;
+        mDurationReciprocal = 1.0f / mDuration;
+        mFinished = false;
+    }
+
+    /**
+     * Returns the time elapsed since the beginning of the scrolling.
+     *
+     * @return The elapsed time in milliseconds.
+     */
+    public int timePassed() {
+        return (int) (AnimationUtils.currentAnimationTimeMillis() - mStartTime);
+    }
+
+    /**
+     * Sets the final position (X) for this scroller.
+     *
+     * @param newX The new X offset as an absolute distance from the origin.
+     * @see #extendDuration(int)
+     * @see #setFinalY(int)
+     */
+    public void setFinalX(int newX) {
+        mFinalX = newX;
+        mDeltaX = mFinalX - mStartX;
+        mFinished = false;
+    }
+
+    /**
+     * Sets the final position (Y) for this scroller.
+     *
+     * @param newY The new Y offset as an absolute distance from the origin.
+     * @see #extendDuration(int)
+     * @see #setFinalX(int)
+     */
+    public void setFinalY(int newY) {
+        mFinalY = newY;
+        mDeltaY = mFinalY - mStartY;
+        mFinished = false;
+    }
+
+    /**
+     * @hide
+     */
+    public boolean isScrollingInDirection(float xvel, float yvel) {
+        return !mFinished && Math.signum(xvel) == Math.signum(mFinalX - mStartX)
+                && Math.signum(yvel) == Math.signum(mFinalY - mStartY);
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/SinusoidalInterpolator.java

@@ -0,0 +1,15 @@
+package net.simonvt.menudrawer;
+
+import android.view.animation.Interpolator;
+
+/**
+ * Interpolator which, when drawn from 0 to 1, looks like half a sine-wave. Used for smoother opening/closing when
+ * peeking at the drawer.
+ */
+class SinusoidalInterpolator implements Interpolator {
+
+    @Override
+    public float getInterpolation(float input) {
+        return (float) (0.5f + 0.5f * Math.sin(input * Math.PI - Math.PI / 2.f));
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/SlideDrawable.java

@@ -0,0 +1,187 @@
+package net.simonvt.menudrawer;
+
+import android.graphics.Canvas;
+import android.graphics.ColorFilter;
+import android.graphics.PorterDuff;
+import android.graphics.Rect;
+import android.graphics.Region;
+import android.graphics.drawable.Drawable;
+
+public class SlideDrawable extends Drawable implements Drawable.Callback {
+
+    private Drawable mWrapped;
+    private float mOffset;
+
+    private final Rect mTmpRect = new Rect();
+
+    private boolean mIsRtl;
+
+    public SlideDrawable(Drawable wrapped) {
+        mWrapped = wrapped;
+    }
+
+    public void setOffset(float offset) {
+        mOffset = offset;
+        invalidateSelf();
+    }
+
+    public float getOffset() {
+        return mOffset;
+    }
+
+    void setIsRtl(boolean isRtl) {
+        mIsRtl = isRtl;
+        invalidateSelf();
+    }
+
+    @Override
+    public void draw(Canvas canvas) {
+        mWrapped.copyBounds(mTmpRect);
+        canvas.save();
+        if (mIsRtl) {
+            canvas.translate(1.f / 3 * mTmpRect.width() * mOffset, 0);
+        } else {
+            canvas.translate(1.f / 3 * mTmpRect.width() * -mOffset, 0);
+        }
+        mWrapped.draw(canvas);
+        canvas.restore();
+    }
+
+    @Override
+    public void setChangingConfigurations(int configs) {
+        mWrapped.setChangingConfigurations(configs);
+    }
+
+    @Override
+    public int getChangingConfigurations() {
+        return mWrapped.getChangingConfigurations();
+    }
+
+    @Override
+    public void setDither(boolean dither) {
+        mWrapped.setDither(dither);
+    }
+
+    @Override
+    public void setFilterBitmap(boolean filter) {
+        mWrapped.setFilterBitmap(filter);
+    }
+
+    @Override
+    public void setAlpha(int alpha) {
+        mWrapped.setAlpha(alpha);
+    }
+
+    @Override
+    public void setColorFilter(ColorFilter cf) {
+        mWrapped.setColorFilter(cf);
+    }
+
+    @Override
+    public void setColorFilter(int color, PorterDuff.Mode mode) {
+        mWrapped.setColorFilter(color, mode);
+    }
+
+    @Override
+    public void clearColorFilter() {
+        mWrapped.clearColorFilter();
+    }
+
+    @Override
+    public boolean isStateful() {
+        return mWrapped.isStateful();
+    }
+
+    @Override
+    public boolean setState(int[] stateSet) {
+        return mWrapped.setState(stateSet);
+    }
+
+    @Override
+    public int[] getState() {
+        return mWrapped.getState();
+    }
+
+    @Override
+    public Drawable getCurrent() {
+        return mWrapped.getCurrent();
+    }
+
+    @Override
+    public boolean setVisible(boolean visible, boolean restart) {
+        return super.setVisible(visible, restart);
+    }
+
+    @Override
+    public int getOpacity() {
+        return mWrapped.getOpacity();
+    }
+
+    @Override
+    public Region getTransparentRegion() {
+        return mWrapped.getTransparentRegion();
+    }
+
+    @Override
+    protected boolean onStateChange(int[] state) {
+        mWrapped.setState(state);
+        return super.onStateChange(state);
+    }
+
+    @Override
+    protected void onBoundsChange(Rect bounds) {
+        super.onBoundsChange(bounds);
+        mWrapped.setBounds(bounds);
+    }
+
+    @Override
+    public int getIntrinsicWidth() {
+        return mWrapped.getIntrinsicWidth();
+    }
+
+    @Override
+    public int getIntrinsicHeight() {
+        return mWrapped.getIntrinsicHeight();
+    }
+
+    @Override
+    public int getMinimumWidth() {
+        return mWrapped.getMinimumWidth();
+    }
+
+    @Override
+    public int getMinimumHeight() {
+        return mWrapped.getMinimumHeight();
+    }
+
+    @Override
+    public boolean getPadding(Rect padding) {
+        return mWrapped.getPadding(padding);
+    }
+
+    @Override
+    public ConstantState getConstantState() {
+        return super.getConstantState();
+    }
+
+    @Override
+    public void invalidateDrawable(Drawable who) {
+        if (who == mWrapped) {
+            invalidateSelf();
+        }
+    }
+
+    @Override
+    public void scheduleDrawable(Drawable who, Runnable what, long when) {
+        if (who == mWrapped) {
+            scheduleSelf(what, when);
+        }
+    }
+
+    @Override
+    public void unscheduleDrawable(Drawable who, Runnable what) {
+        if (who == mWrapped) {
+            unscheduleSelf(what);
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/SlidingDrawer.java

@@ -0,0 +1,707 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.view.VelocityTracker;
+
+public class SlidingDrawer extends DraggableDrawer {
+
+    private static final String TAG = "OverlayDrawer";
+
+    SlidingDrawer(Activity activity, int dragMode) {
+        super(activity, dragMode);
+    }
+
+    public SlidingDrawer(Context context) {
+        super(context);
+    }
+
+    public SlidingDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public SlidingDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        super.addView(mMenuContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+        super.addView(mContentContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        int animateTo = 0;
+        switch (getPosition()) {
+            case LEFT:
+            case TOP:
+                animateTo = mMenuSize;
+                break;
+
+            case RIGHT:
+            case BOTTOM:
+                animateTo = -mMenuSize;
+                break;
+        }
+
+        animateOffsetTo(animateTo, 0, animate);
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        animateOffsetTo(0, 0, animate);
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        if (USE_TRANSLATIONS) {
+            switch (getPosition()) {
+                case TOP:
+                case BOTTOM:
+                    mContentContainer.setTranslationY(offsetPixels);
+                    break;
+
+                default:
+                    mContentContainer.setTranslationX(offsetPixels);
+                    break;
+            }
+        } else {
+            switch (getPosition()) {
+                case TOP:
+                case BOTTOM:
+                    mContentContainer.offsetTopAndBottom(offsetPixels - mContentContainer.getTop());
+                    break;
+
+                default:
+                    mContentContainer.offsetLeftAndRight(offsetPixels - mContentContainer.getLeft());
+                    break;
+            }
+        }
+
+        offsetMenu(offsetPixels);
+        invalidate();
+    }
+
+    @Override
+    protected void initPeekScroller() {
+        switch (getPosition()) {
+            case RIGHT:
+            case BOTTOM: {
+                final int dx = -mMenuSize / 3;
+                mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+                break;
+            }
+
+            default: {
+                final int dx = mMenuSize / 3;
+                mPeekScroller.startScroll(0, 0, dx, 0, PEEK_DURATION);
+                break;
+            }
+        }
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        super.onSizeChanged(w, h, oldw, oldh);
+        onOffsetPixelsChanged((int) mOffsetPixels);
+    }
+
+    @Override
+    protected void drawOverlay(Canvas canvas) {
+        final int width = getWidth();
+        final int height = getHeight();
+        final int offsetPixels = (int) mOffsetPixels;
+        final float openRatio = Math.abs(mOffsetPixels) / mMenuSize;
+
+        switch (getPosition()) {
+            case LEFT:
+                mMenuOverlay.setBounds(0, 0, offsetPixels, height);
+                break;
+
+            case RIGHT:
+                mMenuOverlay.setBounds(width + offsetPixels, 0, width, height);
+                break;
+
+            case TOP:
+                mMenuOverlay.setBounds(0, 0, width, offsetPixels);
+                break;
+
+            case BOTTOM:
+                mMenuOverlay.setBounds(0, height + offsetPixels, width, height);
+                break;
+        }
+
+        mMenuOverlay.setAlpha((int) (MAX_MENU_OVERLAY_ALPHA * (1.f - openRatio)));
+        mMenuOverlay.draw(canvas);
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+
+        if (USE_TRANSLATIONS) {
+            mContentContainer.layout(0, 0, width, height);
+        } else {
+            final int offsetPixels = (int) mOffsetPixels;
+            if (getPosition() == Position.LEFT || getPosition() == Position.RIGHT) {
+                mContentContainer.layout(offsetPixels, 0, width + offsetPixels, height);
+            } else {
+                mContentContainer.layout(0, offsetPixels, width, height + offsetPixels);
+            }
+        }
+
+        switch (getPosition()) {
+            case LEFT:
+                mMenuContainer.layout(0, 0, mMenuSize, height);
+                break;
+
+            case RIGHT:
+                mMenuContainer.layout(width - mMenuSize, 0, width, height);
+                break;
+
+            case TOP:
+                mMenuContainer.layout(0, 0, width, mMenuSize);
+                break;
+
+            case BOTTOM:
+                mMenuContainer.layout(0, height - mMenuSize, width, height);
+                break;
+        }
+    }
+
+    /**
+     * Offsets the menu relative to its original position based on the position of the content.
+     *
+     * @param offsetPixels The number of pixels the content if offset.
+     */
+    private void offsetMenu(int offsetPixels) {
+        if (!mOffsetMenu || mMenuSize == 0) {
+            return;
+        }
+
+        final int width = getWidth();
+        final int height = getHeight();
+
+        final int menuSize = mMenuSize;
+        final int sign = (int) (mOffsetPixels / Math.abs(mOffsetPixels));
+        final float openRatio = Math.abs(mOffsetPixels) / menuSize;
+        final int offset = (int) (-0.25f * ((1.0f - openRatio) * menuSize) * sign);
+
+        switch (getPosition()) {
+            case LEFT: {
+                if (USE_TRANSLATIONS) {
+                    if (offsetPixels > 0) {
+                        mMenuContainer.setTranslationX(offset);
+                    } else {
+                        mMenuContainer.setTranslationX(-menuSize);
+                    }
+
+                } else {
+                    mMenuContainer.offsetLeftAndRight(offset - mMenuContainer.getLeft());
+                    mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+                }
+                break;
+            }
+
+            case RIGHT: {
+                if (USE_TRANSLATIONS) {
+                    if (offsetPixels != 0) {
+                        mMenuContainer.setTranslationX(offset);
+                    } else {
+                        mMenuContainer.setTranslationX(menuSize);
+                    }
+
+                } else {
+                    final int oldOffset = mMenuContainer.getRight() - width;
+                    final int offsetBy = offset - oldOffset;
+                    mMenuContainer.offsetLeftAndRight(offsetBy);
+                    mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+                }
+                break;
+            }
+
+            case TOP: {
+                if (USE_TRANSLATIONS) {
+                    if (offsetPixels > 0) {
+                        mMenuContainer.setTranslationY(offset);
+                    } else {
+                        mMenuContainer.setTranslationY(-menuSize);
+                    }
+
+                } else {
+                    mMenuContainer.offsetTopAndBottom(offset - mMenuContainer.getTop());
+                    mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+                }
+                break;
+            }
+
+            case BOTTOM: {
+                if (USE_TRANSLATIONS) {
+                    if (offsetPixels != 0) {
+                        mMenuContainer.setTranslationY(offset);
+                    } else {
+                        mMenuContainer.setTranslationY(menuSize);
+                    }
+
+                } else {
+                    final int oldOffset = mMenuContainer.getBottom() - height;
+                    final int offsetBy = offset - oldOffset;
+                    mMenuContainer.offsetTopAndBottom(offsetBy);
+                    mMenuContainer.setVisibility(offsetPixels == 0 ? INVISIBLE : VISIBLE);
+                }
+                break;
+            }
+        }
+
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
+            throw new IllegalStateException("Must measure with an exact size");
+        }
+
+        final int width = MeasureSpec.getSize(widthMeasureSpec);
+        final int height = MeasureSpec.getSize(heightMeasureSpec);
+
+        if (mOffsetPixels == -1) openMenu(false);
+
+        int menuWidthMeasureSpec;
+        int menuHeightMeasureSpec;
+        switch (getPosition()) {
+            case TOP:
+            case BOTTOM:
+                menuWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+                menuHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec, 0, mMenuSize);
+                break;
+
+            default:
+                // LEFT/RIGHT
+                menuWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, mMenuSize);
+                menuHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        }
+        mMenuContainer.measure(menuWidthMeasureSpec, menuHeightMeasureSpec);
+
+        final int contentWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, width);
+        final int contentHeightMeasureSpec = getChildMeasureSpec(widthMeasureSpec, 0, height);
+        mContentContainer.measure(contentWidthMeasureSpec, contentHeightMeasureSpec);
+
+        setMeasuredDimension(width, height);
+
+        updateTouchAreaSize();
+    }
+
+    private boolean isContentTouch(int x, int y) {
+        boolean contentTouch = false;
+
+        switch (getPosition()) {
+            case LEFT:
+                contentTouch = ViewHelper.getLeft(mContentContainer) < x;
+                break;
+
+            case RIGHT:
+                contentTouch = ViewHelper.getRight(mContentContainer) > x;
+                break;
+
+            case TOP:
+                contentTouch = ViewHelper.getTop(mContentContainer) < y;
+                break;
+
+            case BOTTOM:
+                contentTouch = ViewHelper.getBottom(mContentContainer) > y;
+                break;
+        }
+
+        return contentTouch;
+    }
+
+    protected boolean onDownAllowDrag(int x, int y) {
+        switch (getPosition()) {
+            case LEFT:
+                return (!mMenuVisible && mInitialMotionX <= mTouchSize)
+                        || (mMenuVisible && mInitialMotionX >= mOffsetPixels);
+
+            case RIGHT:
+                final int width = getWidth();
+                final int initialMotionX = (int) mInitialMotionX;
+
+                return (!mMenuVisible && initialMotionX >= width - mTouchSize)
+                        || (mMenuVisible && initialMotionX <= width + mOffsetPixels);
+
+            case TOP:
+                return (!mMenuVisible && mInitialMotionY <= mTouchSize)
+                        || (mMenuVisible && mInitialMotionY >= mOffsetPixels);
+
+            case BOTTOM:
+                final int height = getHeight();
+                return (!mMenuVisible && mInitialMotionY >= height - mTouchSize)
+                        || (mMenuVisible && mInitialMotionY <= height + mOffsetPixels);
+        }
+
+        return false;
+    }
+
+    protected boolean onMoveAllowDrag(int x, int y, float dx, float dy) {
+        switch (getPosition()) {
+            case LEFT:
+                return (!mMenuVisible && mInitialMotionX <= mTouchSize && (dx > 0))
+                        || (mMenuVisible && x >= mOffsetPixels);
+
+            case RIGHT:
+                final int width = getWidth();
+                return (!mMenuVisible && mInitialMotionX >= width - mTouchSize && (dx < 0))
+                        || (mMenuVisible && x <= width + mOffsetPixels);
+
+            case TOP:
+                return (!mMenuVisible && mInitialMotionY <= mTouchSize && (dy > 0))
+                        || (mMenuVisible && y >= mOffsetPixels);
+
+            case BOTTOM:
+                final int height = getHeight();
+                return (!mMenuVisible && mInitialMotionY >= height - mTouchSize && (dy < 0))
+                        || (mMenuVisible && y <= height + mOffsetPixels);
+        }
+
+        return false;
+    }
+
+    protected void onMoveEvent(float dx, float dy) {
+        switch (getPosition()) {
+            case LEFT:
+                setOffsetPixels(Math.min(Math.max(mOffsetPixels + dx, 0), mMenuSize));
+                break;
+
+            case RIGHT:
+                setOffsetPixels(Math.max(Math.min(mOffsetPixels + dx, 0), -mMenuSize));
+                break;
+
+            case TOP:
+                setOffsetPixels(Math.min(Math.max(mOffsetPixels + dy, 0), mMenuSize));
+                break;
+
+            case BOTTOM:
+                setOffsetPixels(Math.max(Math.min(mOffsetPixels + dy, 0), -mMenuSize));
+                break;
+        }
+    }
+
+    protected void onUpEvent(int x, int y) {
+        final int offsetPixels = (int) mOffsetPixels;
+
+        switch (getPosition()) {
+            case LEFT: {
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getXVelocity(mVelocityTracker);
+                    mLastMotionX = x;
+                    animateOffsetTo(initialVelocity > 0 ? mMenuSize : 0, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible && x > offsetPixels) {
+                    closeMenu();
+                }
+                break;
+            }
+
+            case TOP: {
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getYVelocity(mVelocityTracker);
+                    mLastMotionY = y;
+                    animateOffsetTo(initialVelocity > 0 ? mMenuSize : 0, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible && y > offsetPixels) {
+                    closeMenu();
+                }
+                break;
+            }
+
+            case RIGHT: {
+                final int width = getWidth();
+
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getXVelocity(mVelocityTracker);
+                    mLastMotionX = x;
+                    animateOffsetTo(initialVelocity > 0 ? 0 : -mMenuSize, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible && x < width + offsetPixels) {
+                    closeMenu();
+                }
+                break;
+            }
+
+            case BOTTOM: {
+                if (mIsDragging) {
+                    mVelocityTracker.computeCurrentVelocity(1000, mMaxVelocity);
+                    final int initialVelocity = (int) getYVelocity(mVelocityTracker);
+                    mLastMotionY = y;
+                    animateOffsetTo(initialVelocity < 0 ? -mMenuSize : 0, initialVelocity, true);
+
+                    // Close the menu when content is clicked while the menu is visible.
+                } else if (mMenuVisible && y < getHeight() + offsetPixels) {
+                    closeMenu();
+                }
+                break;
+            }
+        }
+    }
+
+    protected boolean checkTouchSlop(float dx, float dy) {
+        switch (getPosition()) {
+            case TOP:
+            case BOTTOM:
+                return Math.abs(dy) > mTouchSlop && Math.abs(dy) > Math.abs(dx);
+
+            default:
+                return Math.abs(dx) > mTouchSlop && Math.abs(dx) > Math.abs(dy);
+        }
+    }
+
+    public boolean onInterceptTouchEvent(MotionEvent ev) {
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (action == MotionEvent.ACTION_UP || action == MotionEvent.ACTION_CANCEL) {
+            mActivePointerId = INVALID_POINTER;
+            mIsDragging = false;
+            if (mVelocityTracker != null) {
+                mVelocityTracker.recycle();
+                mVelocityTracker = null;
+            }
+
+            if (Math.abs(mOffsetPixels) > mMenuSize / 2) {
+                openMenu();
+            } else {
+                closeMenu();
+            }
+
+            return false;
+        }
+
+        if (action == MotionEvent.ACTION_DOWN && mMenuVisible && isCloseEnough()) {
+            setOffsetPixels(0);
+            stopAnimation();
+            endPeek();
+            setDrawerState(STATE_CLOSED);
+            mIsDragging = false;
+        }
+
+        // Always intercept events over the content while menu is visible.
+        if (mMenuVisible) {
+            int index = 0;
+            if (mActivePointerId != INVALID_POINTER) {
+                index = ev.findPointerIndex(mActivePointerId);
+                index = index == -1 ? 0 : index;
+            }
+
+            final int x = (int) ev.getX(index);
+            final int y = (int) ev.getY(index);
+            if (isContentTouch(x, y)) {
+                return true;
+            }
+        }
+
+        if (!mMenuVisible && !mIsDragging && mTouchMode == TOUCH_MODE_NONE) {
+            return false;
+        }
+
+        if (action != MotionEvent.ACTION_DOWN && mIsDragging) {
+            return true;
+        }
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag((int) mLastMotionX, (int) mLastMotionY);
+                mActivePointerId = ev.getPointerId(0);
+
+                if (allowDrag) {
+                    setDrawerState(mMenuVisible ? STATE_OPEN : STATE_CLOSED);
+                    stopAnimation();
+                    endPeek();
+                    mIsDragging = false;
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final int activePointerId = mActivePointerId;
+                if (activePointerId == INVALID_POINTER) {
+                    // If we don't have a valid id, the touch down wasn't on content.
+                    break;
+                }
+
+                final int pointerIndex = ev.findPointerIndex(activePointerId);
+                if (pointerIndex == -1) {
+                    mIsDragging = false;
+                    mActivePointerId = INVALID_POINTER;
+                    endDrag();
+                    closeMenu(true);
+                    return false;
+                }
+
+                final float x = ev.getX(pointerIndex);
+                final float dx = x - mLastMotionX;
+                final float y = ev.getY(pointerIndex);
+                final float dy = y - mLastMotionY;
+
+                if (checkTouchSlop(dx, dy)) {
+                    if (mOnInterceptMoveEventListener != null && (mTouchMode == TOUCH_MODE_FULLSCREEN || mMenuVisible)
+                            && canChildrenScroll((int) dx, (int) dy, (int) x, (int) y)) {
+                        endDrag(); // Release the velocity tracker
+                        requestDisallowInterceptTouchEvent(true);
+                        return false;
+                    }
+
+                    final boolean allowDrag = onMoveAllowDrag((int) x, (int) y, dx, dy);
+
+                    if (allowDrag) {
+                        setDrawerState(STATE_DRAGGING);
+                        mIsDragging = true;
+                        mLastMotionX = x;
+                        mLastMotionY = y;
+                    }
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_POINTER_UP:
+                onPointerUp(ev);
+                mLastMotionX = ev.getX(ev.findPointerIndex(mActivePointerId));
+                mLastMotionY = ev.getY(ev.findPointerIndex(mActivePointerId));
+                break;
+        }
+
+        if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
+        mVelocityTracker.addMovement(ev);
+
+        return mIsDragging;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent ev) {
+        if (!mMenuVisible && !mIsDragging && mTouchMode == TOUCH_MODE_NONE) {
+            return false;
+        }
+        final int action = ev.getAction() & MotionEvent.ACTION_MASK;
+
+        if (mVelocityTracker == null) mVelocityTracker = VelocityTracker.obtain();
+        mVelocityTracker.addMovement(ev);
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN: {
+                mLastMotionX = mInitialMotionX = ev.getX();
+                mLastMotionY = mInitialMotionY = ev.getY();
+                final boolean allowDrag = onDownAllowDrag((int) mLastMotionX, (int) mLastMotionY);
+
+                mActivePointerId = ev.getPointerId(0);
+
+                if (allowDrag) {
+                    stopAnimation();
+                    endPeek();
+                    startLayerTranslation();
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_MOVE: {
+                final int pointerIndex = ev.findPointerIndex(mActivePointerId);
+                if (pointerIndex == -1) {
+                    mIsDragging = false;
+                    mActivePointerId = INVALID_POINTER;
+                    endDrag();
+                    closeMenu(true);
+                    return false;
+                }
+
+                if (!mIsDragging) {
+                    final float x = ev.getX(pointerIndex);
+                    final float dx = x - mLastMotionX;
+                    final float y = ev.getY(pointerIndex);
+                    final float dy = y - mLastMotionY;
+
+                    if (checkTouchSlop(dx, dy)) {
+                        final boolean allowDrag = onMoveAllowDrag((int) x, (int) y, dx, dy);
+
+                        if (allowDrag) {
+                            setDrawerState(STATE_DRAGGING);
+                            mIsDragging = true;
+                            mLastMotionX = x;
+                            mLastMotionY = y;
+                        } else {
+                            mInitialMotionX = x;
+                            mInitialMotionY = y;
+                        }
+                    }
+                }
+
+                if (mIsDragging) {
+                    startLayerTranslation();
+
+                    final float x = ev.getX(pointerIndex);
+                    final float dx = x - mLastMotionX;
+                    final float y = ev.getY(pointerIndex);
+                    final float dy = y - mLastMotionY;
+
+                    mLastMotionX = x;
+                    mLastMotionY = y;
+                    onMoveEvent(dx, dy);
+                }
+                break;
+            }
+
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP: {
+                int index = ev.findPointerIndex(mActivePointerId);
+                index = index == -1 ? 0 : index;
+                final int x = (int) ev.getX(index);
+                final int y = (int) ev.getY(index);
+                onUpEvent(x, y);
+                mActivePointerId = INVALID_POINTER;
+                mIsDragging = false;
+                break;
+            }
+
+            case MotionEvent.ACTION_POINTER_DOWN:
+                final int index = (ev.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
+                        >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
+                mLastMotionX = ev.getX(index);
+                mLastMotionY = ev.getY(index);
+                mActivePointerId = ev.getPointerId(index);
+                break;
+
+            case MotionEvent.ACTION_POINTER_UP:
+                onPointerUp(ev);
+                mLastMotionX = ev.getX(ev.findPointerIndex(mActivePointerId));
+                mLastMotionY = ev.getY(ev.findPointerIndex(mActivePointerId));
+                break;
+        }
+
+        return true;
+    }
+
+    private void onPointerUp(MotionEvent ev) {
+        final int pointerIndex = ev.getActionIndex();
+        final int pointerId = ev.getPointerId(pointerIndex);
+        if (pointerId == mActivePointerId) {
+            final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
+            mLastMotionX = ev.getX(newPointerIndex);
+            mActivePointerId = ev.getPointerId(newPointerIndex);
+            if (mVelocityTracker != null) {
+                mVelocityTracker.clear();
+            }
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/SmoothInterpolator.java

@@ -0,0 +1,12 @@
+package net.simonvt.menudrawer;
+
+import android.view.animation.Interpolator;
+
+class SmoothInterpolator implements Interpolator {
+
+    @Override
+    public float getInterpolation(float t) {
+        t -= 1.0f;
+        return t * t * t * t * t + 1.0f;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/StaticDrawer.java

@@ -0,0 +1,218 @@
+package net.simonvt.menudrawer;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.drawable.Drawable;
+import android.util.AttributeSet;
+
+public class StaticDrawer extends MenuDrawer {
+
+    public StaticDrawer(Context context) {
+        super(context);
+    }
+
+    public StaticDrawer(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public StaticDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    protected void initDrawer(Context context, AttributeSet attrs, int defStyle) {
+        super.initDrawer(context, attrs, defStyle);
+        super.addView(mMenuContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+        super.addView(mContentContainer, -1, new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
+
+        mIsStatic = true;
+    }
+
+    @Override
+    protected void drawOverlay(Canvas canvas) {
+        // NO-OP
+    }
+
+    @Override
+    protected void onOffsetPixelsChanged(int offsetPixels) {
+        // NO-OP
+    }
+
+    @Override
+    protected void onLayout(boolean changed, int l, int t, int r, int b) {
+        final int width = r - l;
+        final int height = b - t;
+
+        switch (getPosition()) {
+            case LEFT:
+                mMenuContainer.layout(0, 0, mMenuSize, height);
+                mContentContainer.layout(mMenuSize, 0, width, height);
+                break;
+
+            case RIGHT:
+                mMenuContainer.layout(width - mMenuSize, 0, width, height);
+                mContentContainer.layout(0, 0, width - mMenuSize, height);
+                break;
+
+            case TOP:
+                mMenuContainer.layout(0, 0, width, mMenuSize);
+                mContentContainer.layout(0, mMenuSize, width, height);
+                break;
+
+            case BOTTOM:
+                mMenuContainer.layout(0, height - mMenuSize, width, height);
+                mContentContainer.layout(0, 0, width, height - mMenuSize);
+                break;
+        }
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        final int widthMode = MeasureSpec.getMode(widthMeasureSpec);
+        final int heightMode = MeasureSpec.getMode(heightMeasureSpec);
+
+        if (widthMode == MeasureSpec.UNSPECIFIED || heightMode == MeasureSpec.UNSPECIFIED) {
+            throw new IllegalStateException("Must measure with an exact size");
+        }
+
+        final int width = MeasureSpec.getSize(widthMeasureSpec);
+        final int height = MeasureSpec.getSize(heightMeasureSpec);
+
+        switch (getPosition()) {
+            case LEFT:
+            case RIGHT: {
+                final int childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY);
+
+                final int menuWidth = mMenuSize;
+                final int menuWidthMeasureSpec = MeasureSpec.makeMeasureSpec(menuWidth, MeasureSpec.EXACTLY);
+
+                final int contentWidth = width - menuWidth;
+                final int contentWidthMeasureSpec = MeasureSpec.makeMeasureSpec(contentWidth, MeasureSpec.EXACTLY);
+
+                mContentContainer.measure(contentWidthMeasureSpec, childHeightMeasureSpec);
+                mMenuContainer.measure(menuWidthMeasureSpec, childHeightMeasureSpec);
+                break;
+            }
+
+            case TOP:
+            case BOTTOM: {
+                final int childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY);
+
+                final int menuHeight = mMenuSize;
+                final int menuHeightMeasureSpec = MeasureSpec.makeMeasureSpec(menuHeight, MeasureSpec.EXACTLY);
+
+                final int contentHeight = height - menuHeight;
+                final int contentHeightMeasureSpec = MeasureSpec.makeMeasureSpec(contentHeight, MeasureSpec.EXACTLY);
+
+                mContentContainer.measure(childWidthMeasureSpec, contentHeightMeasureSpec);
+                mMenuContainer.measure(childWidthMeasureSpec, menuHeightMeasureSpec);
+                break;
+            }
+        }
+
+        setMeasuredDimension(width, height);
+    }
+
+    @Override
+    public void toggleMenu(boolean animate) {
+        // NO-OP
+    }
+
+    @Override
+    public void openMenu(boolean animate) {
+        // NO-OP
+    }
+
+    @Override
+    public void closeMenu(boolean animate) {
+        // NO-OP
+    }
+
+    @Override
+    public boolean isMenuVisible() {
+        return true;
+    }
+
+    @Override
+    public void setMenuSize(int size) {
+        mMenuSize = size;
+        requestLayout();
+        invalidate();
+    }
+
+    @Override
+    public void setOffsetMenuEnabled(boolean offsetMenu) {
+        // NO-OP
+    }
+
+    @Override
+    public boolean getOffsetMenuEnabled() {
+        return false;
+    }
+
+    @Override
+    public void peekDrawer() {
+        // NO-OP
+    }
+
+    @Override
+    public void peekDrawer(long delay) {
+        // NO-OP
+    }
+
+    @Override
+    public void peekDrawer(long startDelay, long delay) {
+        // NO-OP
+    }
+
+    @Override
+    public void setHardwareLayerEnabled(boolean enabled) {
+        // NO-OP
+    }
+
+    @Override
+    public int getTouchMode() {
+        return TOUCH_MODE_NONE;
+    }
+
+    @Override
+    public void setTouchMode(int mode) {
+        // NO-OP
+    }
+
+    @Override
+    public void setTouchBezelSize(int size) {
+        // NO-OP
+    }
+
+    @Override
+    public int getTouchBezelSize() {
+        return 0;
+    }
+
+    @Override
+    public void setSlideDrawable(int drawableRes) {
+        // NO-OP
+    }
+
+    @Override
+    public void setSlideDrawable(Drawable drawable) {
+        // NO-OP
+    }
+
+    @Override
+    public void setupUpIndicator(Activity activity) {
+        // NO-OP
+    }
+
+    @Override
+    public void setDrawerIndicatorEnabled(boolean enabled) {
+        // NO-OP
+    }
+
+    @Override
+    public boolean isDrawerIndicatorEnabled() {
+        return false;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/ViewHelper.java

@@ -0,0 +1,50 @@
+package net.simonvt.menudrawer;
+
+import android.os.Build;
+import android.view.View;
+
+final class ViewHelper {
+
+    private ViewHelper() {
+    }
+
+    public static int getLeft(View v) {
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            return (int) (v.getLeft() + v.getTranslationX());
+        }
+
+        return v.getLeft();
+    }
+
+    public static int getTop(View v) {
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            return (int) (v.getTop() + v.getTranslationY());
+        }
+
+        return v.getTop();
+    }
+
+    public static int getRight(View v) {
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            return (int) (v.getRight() + v.getTranslationX());
+        }
+
+        return v.getRight();
+    }
+
+    public static int getBottom(View v) {
+        if (MenuDrawer.USE_TRANSLATIONS) {
+            return (int) (v.getBottom() + v.getTranslationY());
+        }
+
+        return v.getBottom();
+    }
+
+    public static int getLayoutDirection(View v) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
+            return v.getLayoutDirection();
+        }
+
+        return View.LAYOUT_DIRECTION_LTR;
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/compat/ActionBarHelper.java

@@ -0,0 +1,83 @@
+package net.simonvt.menudrawer.compat;
+
+import android.app.Activity;
+import android.graphics.drawable.Drawable;
+import android.os.Build;
+import android.util.Log;
+
+import java.lang.reflect.Method;
+
+public final class ActionBarHelper {
+
+    private static final String TAG = "ActionBarHelper";
+
+    static final boolean DEBUG = false;
+
+    private Activity mActivity;
+
+    private Object mIndicatorInfo;
+
+    private boolean mUsesCompat;
+
+    public ActionBarHelper(Activity activity) {
+        mActivity = activity;
+
+        try {
+            Class clazz = activity.getClass();
+            Method m = clazz.getMethod("getSupportActionBar");
+            mUsesCompat = true;
+        } catch (NoSuchMethodException e) {
+            if (DEBUG) {
+                Log.e(TAG,
+                        "Activity " + activity.getClass().getSimpleName() + " does not use a compatibility action bar",
+                        e);
+            }
+        }
+
+        mIndicatorInfo = getIndicatorInfo();
+    }
+
+    private Object getIndicatorInfo() {
+        if (mUsesCompat && Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            return ActionBarHelperCompat.getIndicatorInfo(mActivity);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            return ActionBarHelperNative.getIndicatorInfo(mActivity);
+        }
+
+        return null;
+    }
+
+    public void setActionBarUpIndicator(Drawable drawable, int contentDesc) {
+        if (mUsesCompat && Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            ActionBarHelperCompat.setActionBarUpIndicator(mIndicatorInfo, mActivity, drawable, contentDesc);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            ActionBarHelperNative.setActionBarUpIndicator(mIndicatorInfo, mActivity, drawable, contentDesc);
+        }
+    }
+
+    public void setActionBarDescription(int contentDesc) {
+        if (mUsesCompat && Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            ActionBarHelperCompat.setActionBarDescription(mIndicatorInfo, mActivity, contentDesc);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            ActionBarHelperNative.setActionBarDescription(mIndicatorInfo, mActivity, contentDesc);
+        }
+    }
+
+    public Drawable getThemeUpIndicator() {
+        if (mUsesCompat && Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            return ActionBarHelperCompat.getThemeUpIndicator(mIndicatorInfo);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            return ActionBarHelperNative.getThemeUpIndicator(mIndicatorInfo, mActivity);
+        }
+
+        return null;
+    }
+
+    public void setDisplayShowHomeAsUpEnabled(boolean enabled) {
+        if (mUsesCompat && Build.VERSION.SDK_INT < Build.VERSION_CODES.ICE_CREAM_SANDWICH) {
+            ActionBarHelperCompat.setDisplayHomeAsUpEnabled(mIndicatorInfo, enabled);
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB) {
+            ActionBarHelperNative.setDisplayHomeAsUpEnabled(mActivity, enabled);
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/compat/ActionBarHelperCompat.java

@@ -0,0 +1,107 @@
+package net.simonvt.menudrawer.compat;
+
+import android.app.Activity;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import java.lang.reflect.Method;
+
+final class ActionBarHelperCompat {
+
+    private static final String TAG = "ActionBarHelperCompat";
+
+    private ActionBarHelperCompat() {
+    }
+
+    public static void setActionBarUpIndicator(Object info, Activity activity, Drawable drawable, int contentDescRes) {
+        final SetIndicatorInfo sii = (SetIndicatorInfo) info;
+        if (sii.mUpIndicatorView != null) {
+            sii.mUpIndicatorView.setImageDrawable(drawable);
+            final String contentDescription = contentDescRes == 0 ? null : activity.getString(contentDescRes);
+            sii.mUpIndicatorView.setContentDescription(contentDescription);
+        }
+    }
+
+    public static void setActionBarDescription(Object info, Activity activity, int contentDescRes) {
+        final SetIndicatorInfo sii = (SetIndicatorInfo) info;
+        if (sii.mUpIndicatorView != null) {
+            final String contentDescription = contentDescRes == 0 ? null : activity.getString(contentDescRes);
+            sii.mUpIndicatorView.setContentDescription(contentDescription);
+        }
+    }
+
+    public static Drawable getThemeUpIndicator(Object info) {
+        final SetIndicatorInfo sii = (SetIndicatorInfo) info;
+        if (sii.mUpIndicatorView != null) {
+            return sii.mUpIndicatorView.getDrawable();
+        }
+        return null;
+    }
+
+    public static Object getIndicatorInfo(Activity activity) {
+        return new SetIndicatorInfo(activity);
+    }
+
+    public static void setDisplayHomeAsUpEnabled(Object info, boolean enabled) {
+        final SetIndicatorInfo sii = (SetIndicatorInfo) info;
+        if (sii.mHomeAsUpEnabled != null) {
+            try {
+                sii.mHomeAsUpEnabled.invoke(sii.mActionBar, enabled);
+            } catch (Throwable t) {
+                if (ActionBarHelper.DEBUG) {
+                    Log.e(TAG, "Unable to call setHomeAsUpEnabled", t);
+                }
+            }
+        }
+    }
+
+    private static class SetIndicatorInfo {
+
+        public ImageView mUpIndicatorView;
+        public Object mActionBar;
+        public Method mHomeAsUpEnabled;
+
+        SetIndicatorInfo(Activity activity) {
+            try {
+                String appPackage = activity.getPackageName();
+
+                try {
+                    // Attempt to find ActionBarSherlock up indicator
+                    final int homeId = activity.getResources().getIdentifier("abs__home", "id", appPackage);
+                    View v = activity.findViewById(homeId);
+                    ViewGroup parent = (ViewGroup) v.getParent();
+                    final int upId = activity.getResources().getIdentifier("abs__up", "id", appPackage);
+                    mUpIndicatorView = (ImageView) parent.findViewById(upId);
+                } catch (Throwable t) {
+                    if (ActionBarHelper.DEBUG) {
+                        Log.e(TAG, "ABS action bar not found", t);
+                    }
+                }
+
+                if (mUpIndicatorView == null) {
+                    // Attempt to find AppCompat up indicator
+                    final int homeId = activity.getResources().getIdentifier("home", "id", appPackage);
+                    View v = activity.findViewById(homeId);
+                    ViewGroup parent = (ViewGroup) v.getParent();
+                    final int upId = activity.getResources().getIdentifier("up", "id", appPackage);
+                    mUpIndicatorView = (ImageView) parent.findViewById(upId);
+                }
+
+                Class supportActivity = activity.getClass();
+                Method getActionBar = supportActivity.getMethod("getSupportActionBar");
+
+                mActionBar = getActionBar.invoke(activity, null);
+                Class supportActionBar = mActionBar.getClass();
+                mHomeAsUpEnabled = supportActionBar.getMethod("setDisplayHomeAsUpEnabled", Boolean.TYPE);
+
+            } catch (Throwable t) {
+                if (ActionBarHelper.DEBUG) {
+                    Log.e(TAG, "Unable to init SetIndicatorInfo for ABS", t);
+                }
+            }
+        }
+    }
+}

core/menudrawer/src/main/java/net/simonvt/menudrawer/compat/ActionBarHelperNative.java

@@ -0,0 +1,114 @@
+package net.simonvt.menudrawer.compat;
+
+import android.app.ActionBar;
+import android.app.Activity;
+import android.content.res.TypedArray;
+import android.graphics.drawable.Drawable;
+import android.util.Log;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import java.lang.reflect.Method;
+
+final class ActionBarHelperNative {
+
+    private static final String TAG = "ActionBarHelperNative";
+
+    private ActionBarHelperNative() {
+    }
+
+    private static final int[] THEME_ATTRS = new int[] {
+            android.R.attr.homeAsUpIndicator
+    };
+
+    public static void setActionBarUpIndicator(Object info, Activity activity, Drawable drawable, int contentDescRes) {
+
+        final SetIndicatorInfo sii = (SetIndicatorInfo) info;
+        if (sii.setHomeAsUpIndicator != null) {
+            try {
+                final ActionBar actionBar = activity.getActionBar();
+                sii.setHomeAsUpIndicator.invoke(actionBar, drawable);
+                sii.setHomeActionContentDescription.invoke(actionBar, contentDescRes);
+            } catch (Throwable t) {
+                if (ActionBarHelper.DEBUG) Log.e(TAG, "Couldn't set home-as-up indicator via JB-MR2 API", t);
+            }
+        } else if (sii.upIndicatorView != null) {
+            sii.upIndicatorView.setImageDrawable(drawable);
+        } else {
+            if (ActionBarHelper.DEBUG) Log.e(TAG, "Couldn't set home-as-up indicator");
+        }
+    }
+
+    public static void setActionBarDescription(Object info, Activity activity, int contentDescRes) {
+        final SetIndicatorInfo sii = (SetIndicatorInfo) info;
+        if (sii.setHomeAsUpIndicator != null) {
+            try {
+                final ActionBar actionBar = activity.getActionBar();
+                sii.setHomeActionContentDescription.invoke(actionBar, contentDescRes);
+            } catch (Throwable t) {
+                if (ActionBarHelper.DEBUG) Log.e(TAG, "Couldn't set content description via JB-MR2 API", t);
+            }
+        }
+    }
+
+    public static Drawable getThemeUpIndicator(Object info, Activity activity) {
+        final TypedArray a = activity.obtainStyledAttributes(THEME_ATTRS);
+        final Drawable result = a.getDrawable(0);
+        a.recycle();
+        return result;
+    }
+
+    public static Object getIndicatorInfo(Activity activity) {
+        return new SetIndicatorInfo(activity);
+    }
+
+    public static void setDisplayHomeAsUpEnabled(Activity activity, boolean b) {
+        ActionBar actionBar = activity.getActionBar();
+        if (actionBar != null) {
+            actionBar.setDisplayHomeAsUpEnabled(b);
+        }
+    }
+
+    private static class SetIndicatorInfo {
+
+        public Method setHomeAsUpIndicator;
+        public Method setHomeActionContentDescription;
+        public ImageView upIndicatorView;
+
+        SetIndicatorInfo(Activity activity) {
+            try {
+                setHomeAsUpIndicator = ActionBar.class.getDeclaredMethod("setHomeAsUpIndicator", Drawable.class);
+                setHomeActionContentDescription = ActionBar.class.getDeclaredMethod(
+                        "setHomeActionContentDescription", Integer.TYPE);
+
+                // If we got the method we won't need the stuff below.
+                return;
+            } catch (Throwable t) {
+                // Oh well. We'll use the other mechanism below instead.
+            }
+
+            final View home = activity.findViewById(android.R.id.home);
+            if (home == null) {
+                // Action bar doesn't have a known configuration, an OEM messed with things.
+                return;
+            }
+
+            final ViewGroup parent = (ViewGroup) home.getParent();
+            final int childCount = parent.getChildCount();
+            if (childCount != 2) {
+                // No idea which one will be the right one, an OEM messed with things.
+                return;
+            }
+
+            final View first = parent.getChildAt(0);
+            final View second = parent.getChildAt(1);
+            final View up = first.getId() == android.R.id.home ? second : first;
+
+            if (up instanceof ImageView) {
+                // Jackpot! (Probably...)
+                upIndicatorView = (ImageView) up;
+            }
+        }
+    }
+}

core/menudrawer/src/main/res/values/attrs.xml

@@ -0,0 +1,65 @@
+<resources>
+
+    <!-- Reference to a style for the menu drawer. -->
+    <attr name="menuDrawerStyle" format="reference" />
+
+    <!-- Styleables used for styling the menu drawer. -->
+    <declare-styleable name="MenuDrawer">
+
+        <!-- Drawable to use for the background of the content. -->
+        <attr name="mdContentBackground" format="reference" />
+
+        <!-- Drawable to use for the background of the menu. -->
+        <attr name="mdMenuBackground" format="reference" />
+
+        <!-- The size of the menu. -->
+        <attr name="mdMenuSize" format="dimension" />
+
+        <!-- Drawable used as indicator for the active view. -->
+        <attr name="mdActiveIndicator" format="reference" />
+
+        <!-- Defines whether the content will have a dropshadow onto the menu. Default is true. -->
+        <attr name="mdDropShadowEnabled" format="boolean" />
+
+        <!-- The size of the drop shadow. Default is 6dp -->
+        <attr name="mdDropShadowSize" format="dimension" />
+
+        <!-- The color of the drop shadow. Default is #FF000000. -->
+        <attr name="mdDropShadowColor" format="color" />
+
+        <!-- Drawable used for the drop shadow. -->
+        <attr name="mdDropShadow" format="reference" />
+
+        <!-- The touch bezel size. -->
+        <attr name="mdTouchBezelSize" format="dimension" />
+
+        <!-- Whether the indicator should be animated between active views. -->
+        <attr name="mdAllowIndicatorAnimation" format="boolean" />
+
+        <!-- The maximum animation duration -->
+        <attr name="mdMaxAnimationDuration" format="integer" />
+
+        <!-- Drawable that replaces the up indicator -->
+        <attr name="mdSlideDrawable" format="reference" />
+
+        <!-- String to use as the up indicators content description when the drawer is open -->
+        <attr name="mdDrawerOpenUpContentDescription" format="string" />
+
+        <!-- String to use as the up indicators content description when the drawer is closed -->
+        <attr name="mdDrawerClosedUpContentDescription" format="string" />
+
+        <!-- Whether an overlay should be drawn as the drawer is opened and closed -->
+        <attr name="mdDrawOverlay" format="boolean" />
+
+        <!-- The position of the drawer -->
+        <attr name="mdPosition" format="enum">
+            <enum name="left" value="0" />
+            <enum name="top" value="1" />
+            <enum name="right" value="2" />
+            <enum name="bottom" value="3" />
+            <enum name="start" value="4" />
+            <enum name="end" value="5" />
+        </attr>
+    </declare-styleable>
+
+</resources>

core/menudrawer/src/main/res/values/colors.xml

@@ -0,0 +1,6 @@
+<resources>
+
+    <!-- The default background of the menu. -->
+    <color name="md__defaultBackground">#FF555555</color>
+
+</resources>

core/menudrawer/src/main/res/values/ids.xml

@@ -0,0 +1,24 @@
+<resources>
+
+    <!-- ID used when defining the content layout in XML. -->
+    <item name="mdContent" type="id" />
+
+    <!-- ID used when defining the menu layout in XML. -->
+    <item name="mdMenu" type="id" />
+
+    <!-- The ID of the content container. -->
+    <item name="md__content" type="id" />
+
+    <!-- The ID of the menu container. -->
+    <item name="md__menu" type="id" />
+
+    <!-- The ID of the drawer. -->
+    <item name="md__drawer" type="id" />
+
+    <!-- Used with View#setTag(int) to specify a position for the active view. -->
+    <item name="mdActiveViewPosition" type="id" />
+
+    <item name="md__translationX" type="id" />
+
+    <item name="md__translationY" type="id" />
+</resources>

core/menudrawer/src/main/res/values/strings.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:tools="http://schemas.android.com/tools">
+
+    <string name="md__drawerOpenIndicatorDesc" tools:ignore="MissingTranslation">Close drawer</string>
+
+    <string name="md__drawerClosedIndicatorDesc" tools:ignore="MissingTranslation">Open drawer</string>
+
+</resources>

core/menudrawer/src/main/res/values/styles.xml

@@ -0,0 +1,13 @@
+<resources>
+
+    <style name="Widget" />
+
+    <!-- Base theme for the menu drawer. -->
+    <style name="Widget.MenuDrawer">
+        <item name="mdMenuBackground">@color/md__defaultBackground</item>
+        <item name="mdContentBackground">?android:attr/windowBackground</item>
+        <item name="mdDrawerOpenUpContentDescription">@string/md__drawerOpenIndicatorDesc</item>
+        <item name="mdDrawerClosedUpContentDescription">@string/md__drawerClosedIndicatorDesc</item>
+    </style>
+
+</resources>

core/pulltorefresh/build.gradle

@@ -0,0 +1,8 @@
+apply from: bootstrap.androidModule
+
+android {
+    lintOptions {
+        baselineFile file("lint-baseline.xml")
+        abortOnError true
+    }
+}

core/pulltorefresh/lint-baseline.xml

@@ -0,0 +1,326 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<issues format="4" by="lint 2.3.3">
+
+    <issue
+        id="LocaleFolder"
+        message="The locale folder &quot;`he`&quot; should be called &quot;`iw`&quot; instead; see the `java.util.Locale` documentation">
+        <location
+            file="src/main/res/values-he"/>
+    </issue>
+
+    <issue
+        id="OldTargetApi"
+        message="Not targeting the latest versions of Android; compatibility modes apply. Consider testing and updating this version. Consult the `android.os.Build.VERSION_CODES` javadoc for details."
+        errorLine1="    &lt;uses-sdk android:minSdkVersion=&quot;4&quot; android:targetSdkVersion=&quot;16&quot; />"
+        errorLine2="                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="41"/>
+    </issue>
+
+    <issue
+        id="GradleOverrides"
+        message="This `minSdkVersion` value (`4`) is not used; it is always overridden by the value specified in the Gradle build script (`14`)"
+        errorLine1="    &lt;uses-sdk android:minSdkVersion=&quot;4&quot; android:targetSdkVersion=&quot;16&quot; />"
+        errorLine2="              ~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="15"/>
+    </issue>
+
+    <issue
+        id="GradleOverrides"
+        message="This `targetSdkVersion` value (`16`) is not used; it is always overridden by the value specified in the Gradle build script (`22`)"
+        errorLine1="    &lt;uses-sdk android:minSdkVersion=&quot;4&quot; android:targetSdkVersion=&quot;16&quot; />"
+        errorLine2="                                        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/AndroidManifest.xml"
+            line="7"
+            column="41"/>
+    </issue>
+
+    <issue
+        id="Deprecated"
+        message="`android:singleLine` is deprecated: Use `maxLines=&quot;1&quot;` instead"
+        errorLine1="                android:singleLine=&quot;true&quot;"
+        errorLine2="                ~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/res/layout/pull_to_refresh_header_vertical.xml"
+            line="45"
+            column="17"/>
+    </issue>
+
+    <issue
+        id="Deprecated"
+        message="`android:singleLine` is deprecated: Use `maxLines=&quot;1&quot;` instead"
+        errorLine1="                android:singleLine=&quot;true&quot;"
+        errorLine2="                ~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/res/layout/pull_to_refresh_header_vertical.xml"
+            line="53"
+            column="17"/>
+    </issue>
+
+    <issue
+        id="MissingTranslation"
+        message="&quot;`pull_to_refresh_from_bottom_pull_label`&quot; is not translated in &quot;es&quot; (Spanish), &quot;fr&quot; (French), &quot;pt&quot; (Portuguese), &quot;pt-BR&quot; (Portuguese: Brazil)"
+        errorLine1="    &lt;string name=&quot;pull_to_refresh_from_bottom_pull_label&quot;>@string/pull_to_refresh_pull_label&lt;/string>"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/res/values/pull_refresh_strings.xml"
+            line="9"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="MissingTranslation"
+        message="&quot;`pull_to_refresh_from_bottom_release_label`&quot; is not translated in &quot;es&quot; (Spanish), &quot;fr&quot; (French), &quot;pt&quot; (Portuguese), &quot;pt-BR&quot; (Portuguese: Brazil)"
+        errorLine1="    &lt;string name=&quot;pull_to_refresh_from_bottom_release_label&quot;>@string/pull_to_refresh_release_label&lt;/string>"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/res/values/pull_refresh_strings.xml"
+            line="10"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="MissingTranslation"
+        message="&quot;`pull_to_refresh_from_bottom_refreshing_label`&quot; is not translated in &quot;es&quot; (Spanish), &quot;fr&quot; (French), &quot;pt&quot; (Portuguese), &quot;pt-BR&quot; (Portuguese: Brazil)"
+        errorLine1="    &lt;string name=&quot;pull_to_refresh_from_bottom_refreshing_label&quot;>@string/pull_to_refresh_refreshing_label&lt;/string>"
+        errorLine2="            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/res/values/pull_refresh_strings.xml"
+            line="11"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="AddJavascriptInterface"
+        message="`WebView.addJavascriptInterface` should not be called with minSdkVersion &lt; 17 for security reasons: JavaScript can use reflection to manipulate application"
+        errorLine1="  webView.addJavascriptInterface(mJsCallback, JS_INTERFACE_PKG);"
+        errorLine2="          ~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/extras/PullToRefreshWebView2.java"
+            line="90"
+            column="11"/>
+    </issue>
+
+    <issue
+        id="JavascriptInterface"
+        message="None of the methods in the added interface (JsValueCallback) have been annotated with `@android.webkit.JavascriptInterface`; they will not be visible in API 17"
+        errorLine1="  webView.addJavascriptInterface(mJsCallback, JS_INTERFACE_PKG);"
+        errorLine2="          ~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/extras/PullToRefreshWebView2.java"
+            line="90"
+            column="11"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  return VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD &amp;&amp; mOverScrollEnabled"
+        errorLine2="         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshBase.java"
+            line="211"
+            column="10"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshExpandableListView.java"
+            line="54"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshGridView.java"
+            line="54"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshHorizontalScrollView.java"
+            line="53"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshListView.java"
+            line="207"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshScrollView.java"
+            line="52"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.GINGERBREAD) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshWebView.java"
+            line="98"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="ObsoleteSdkInt"
+        message="Unnecessary; SDK_INT is always >= 14"
+        errorLine1="  if (VERSION.SDK_INT >= VERSION_CODES.HONEYCOMB) {"
+        errorLine2="      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/internal/ViewCompat.java"
+            line="44"
+            column="7"/>
+    </issue>
+
+    <issue
+        id="FloatMath"
+        message="Use `java.lang.Math#floor` instead of `android.util.FloatMath#floor()` since it is faster as of API 8"
+        errorLine1="  float exactContentHeight = FloatMath.floor(mRefreshableView.getContentHeight() * mRefreshableView.getScale());"
+        errorLine2="                             ~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshWebView.java"
+            line="115"
+            column="30"/>
+    </issue>
+
+    <issue
+        id="FloatMath"
+        message="Use `java.lang.Math#floor` instead of `android.util.FloatMath#floor()` since it is faster as of API 8"
+        errorLine1="   return (int) Math.max(0, FloatMath.floor(mRefreshableView.getContentHeight() * mRefreshableView.getScale())"
+        errorLine2="                            ~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshWebView.java"
+            line="161"
+            column="29"/>
+    </issue>
+
+    <issue
+        id="IconMissingDensityFolder"
+        message="Missing density variation folders in `src/main/res`: drawable-xxhdpi">
+        <location
+            file="src/main/res"/>
+    </issue>
+
+    <issue
+        id="ViewConstructor"
+        message="Custom view `RotateLoadingLayout` is missing constructor used by tools: `(Context)` or `(Context,AttributeSet)` or `(Context,AttributeSet,int)`"
+        errorLine1="public class RotateLoadingLayout extends LoadingLayout {"
+        errorLine2="             ~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/internal/RotateLoadingLayout.java"
+            line="30"
+            column="14"/>
+    </issue>
+
+    <issue
+        id="ContentDescription"
+        message="[Accessibility] Missing `contentDescription` attribute on image"
+        errorLine1="        &lt;ImageView"
+        errorLine2="        ^">
+        <location
+            file="src/main/res/layout/pull_to_refresh_header_horizontal.xml"
+            line="13"
+            column="9"/>
+    </issue>
+
+    <issue
+        id="ContentDescription"
+        message="[Accessibility] Missing `contentDescription` attribute on image"
+        errorLine1="            &lt;ImageView"
+        errorLine2="            ^">
+        <location
+            file="src/main/res/layout/pull_to_refresh_header_vertical.xml"
+            line="18"
+            column="13"/>
+    </issue>
+
+    <issue
+        id="RtlHardcoded"
+        message="Use &quot;`Gravity.START`&quot; instead of &quot;`Gravity.LEFT`&quot; to ensure correct behavior in right-to-left locales"
+        errorLine1="    lp.gravity = scrollDirection == Orientation.VERTICAL ? Gravity.TOP : Gravity.LEFT;"
+        errorLine2="                                                                                 ~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/internal/LoadingLayout.java"
+            line="92"
+            column="82"/>
+    </issue>
+
+    <issue
+        id="RtlHardcoded"
+        message="Use &quot;`Gravity.END`&quot; instead of &quot;`Gravity.RIGHT`&quot; to ensure correct behavior in right-to-left locales"
+        errorLine1="    lp.gravity = scrollDirection == Orientation.VERTICAL ? Gravity.BOTTOM : Gravity.RIGHT;"
+        errorLine2="                                                                                    ~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/internal/LoadingLayout.java"
+            line="102"
+            column="85"/>
+    </issue>
+
+    <issue
+        id="RtlHardcoded"
+        message="Use &quot;`Gravity.END`&quot; instead of &quot;`Gravity.RIGHT`&quot; to ensure correct behavior in right-to-left locales"
+        errorLine1="   params.gravity = Gravity.TOP | Gravity.RIGHT;"
+        errorLine2="                                          ~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshAdapterViewBase.java"
+            line="344"
+            column="43"/>
+    </issue>
+
+    <issue
+        id="RtlHardcoded"
+        message="Use &quot;`Gravity.END`&quot; instead of &quot;`Gravity.RIGHT`&quot; to ensure correct behavior in right-to-left locales"
+        errorLine1="   params.gravity = Gravity.BOTTOM | Gravity.RIGHT;"
+        errorLine2="                                             ~~~~~">
+        <location
+            file="src/main/java/com/handmark/pulltorefresh/library/PullToRefreshAdapterViewBase.java"
+            line="359"
+            column="46"/>
+    </issue>
+
+    <issue
+        id="RtlHardcoded"
+        message="Use &quot;`start`&quot; instead of &quot;`left`&quot; to ensure correct behavior in right-to-left locales"
+        errorLine1="            android:layout_gravity=&quot;left|center_vertical&quot; >"
+        errorLine2="                                    ~~~~~~~~~~~~~~~~~~~~">
+        <location
+            file="src/main/res/layout/pull_to_refresh_header_vertical.xml"
+            line="16"
+            column="37"/>
+    </issue>
+
+</issues>

core/pulltorefresh/src/main/AndroidManifest.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.handmark.pulltorefresh.library"
+    android:versionCode="2110"
+    android:versionName="2.1.1">
+</manifest>

core/pulltorefresh/src/main/java/com/handmark/pulltorefresh/library/ILoadingLayout.java

@@ -0,0 +1,57 @@
+package com.handmark.pulltorefresh.library;
+
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+
+public interface ILoadingLayout {
+
+	/**
+	 * Set the Last Updated Text. This displayed under the main label when
+	 * Pulling
+	 * 
+	 * @param label - Label to set
+	 */
+	public void setLastUpdatedLabel(CharSequence label);
+
+	/**
+	 * Set the drawable used in the loading layout. This is the same as calling
+	 * <code>setLoadingDrawable(drawable, Mode.BOTH)</code>
+	 * 
+	 * @param drawable - Drawable to display
+	 */
+	public void setLoadingDrawable(Drawable drawable);
+
+	/**
+	 * Set Text to show when the Widget is being Pulled
+	 * <code>setPullLabel(releaseLabel, Mode.BOTH)</code>
+	 * 
+	 * @param pullLabel - CharSequence to display
+	 */
+	public void setPullLabel(CharSequence pullLabel);
+
+	/**
+	 * Set Text to show when the Widget is refreshing
+	 * <code>setRefreshingLabel(releaseLabel, Mode.BOTH)</code>
+	 * 
+	 * @param refreshingLabel - CharSequence to display
+	 */
+	public void setRefreshingLabel(CharSequence refreshingLabel);
+
+	/**
+	 * Set Text to show when the Widget is being pulled, and will refresh when
+	 * released. This is the same as calling
+	 * <code>setReleaseLabel(releaseLabel, Mode.BOTH)</code>
+	 * 
+	 * @param releaseLabel - CharSequence to display
+	 */
+	public void setReleaseLabel(CharSequence releaseLabel);
+
+	/**
+	 * Set's the Sets the typeface and style in which the text should be
+	 * displayed. Please see
+	 * {@link android.widget.TextView#setTypeface(Typeface)
+	 * TextView#setTypeface(Typeface)}.
+	 */
+	public void setTextTypeface(Typeface tf);
+
+}

core/pulltorefresh/src/main/java/com/handmark/pulltorefresh/library/IPullToRefresh.java

@@ -0,0 +1,246 @@
+/*******************************************************************************
+ * Copyright 2011, 2012 Chris Banes.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.handmark.pulltorefresh.library;
+
+import android.view.View;
+import android.view.animation.Interpolator;
+
+import com.handmark.pulltorefresh.library.PullToRefreshBase.Mode;
+import com.handmark.pulltorefresh.library.PullToRefreshBase.OnPullEventListener;
+import com.handmark.pulltorefresh.library.PullToRefreshBase.OnRefreshListener;
+import com.handmark.pulltorefresh.library.PullToRefreshBase.OnRefreshListener2;
+import com.handmark.pulltorefresh.library.PullToRefreshBase.State;
+
+public interface IPullToRefresh<T extends View> {
+
+	/**
+	 * Demos the Pull-to-Refresh functionality to the user so that they are
+	 * aware it is there. This could be useful when the user first opens your
+	 * app, etc. The animation will only happen if the Refresh View (ListView,
+	 * ScrollView, etc) is in a state where a Pull-to-Refresh could occur by a
+	 * user's touch gesture (i.e. scrolled to the top/bottom).
+	 * 
+	 * @return true - if the Demo has been started, false if not.
+	 */
+	public boolean demo();
+
+	/**
+	 * Get the mode that this view is currently in. This is only really useful
+	 * when using <code>Mode.BOTH</code>.
+	 * 
+	 * @return Mode that the view is currently in
+	 */
+	public Mode getCurrentMode();
+
+	/**
+	 * Returns whether the Touch Events are filtered or not. If true is
+	 * returned, then the View will only use touch events where the difference
+	 * in the Y-axis is greater than the difference in the X-axis. This means
+	 * that the View will not interfere when it is used in a horizontal
+	 * scrolling View (such as a ViewPager).
+	 * 
+	 * @return boolean - true if the View is filtering Touch Events
+	 */
+	public boolean getFilterTouchEvents();
+
+	/**
+	 * Returns a proxy object which allows you to call methods on all of the
+	 * LoadingLayouts (the Views which show when Pulling/Refreshing).
+	 * <p />
+	 * You should not keep the result of this method any longer than you need
+	 * it.
+	 * 
+	 * @return Object which will proxy any calls you make on it, to all of the
+	 *         LoadingLayouts.
+	 */
+	public ILoadingLayout getLoadingLayoutProxy();
+
+	/**
+	 * Returns a proxy object which allows you to call methods on the
+	 * LoadingLayouts (the Views which show when Pulling/Refreshing). The actual
+	 * LoadingLayout(s) which will be affected, are chosen by the parameters you
+	 * give.
+	 * <p />
+	 * You should not keep the result of this method any longer than you need
+	 * it.
+	 * 
+	 * @param includeStart - Whether to include the Start/Header Views
+	 * @param includeEnd - Whether to include the End/Footer Views
+	 * @return Object which will proxy any calls you make on it, to the
+	 *         LoadingLayouts included.
+	 */
+	public ILoadingLayout getLoadingLayoutProxy(boolean includeStart, boolean includeEnd);
+
+	/**
+	 * Get the mode that this view has been set to. If this returns
+	 * <code>Mode.BOTH</code>, you can use <code>getCurrentMode()</code> to
+	 * check which mode the view is currently in
+	 * 
+	 * @return Mode that the view has been set to
+	 */
+	public Mode getMode();
+
+	/**
+	 * Get the Wrapped Refreshable View. Anything returned here has already been
+	 * added to the content view.
+	 * 
+	 * @return The View which is currently wrapped
+	 */
+	public T getRefreshableView();
+
+	/**
+	 * Get whether the 'Refreshing' View should be automatically shown when
+	 * refreshing. Returns true by default.
+	 * 
+	 * @return - true if the Refreshing View will be show
+	 */
+	public boolean getShowViewWhileRefreshing();
+
+	/**
+	 * @return - The state that the View is currently in.
+	 */
+	public State getState();
+
+	/**
+	 * Whether Pull-to-Refresh is enabled
+	 * 
+	 * @return enabled
+	 */
+	public boolean isPullToRefreshEnabled();
+
+	/**
+	 * Gets whether Overscroll support is enabled. This is different to
+	 * Android's standard Overscroll support (the edge-glow) which is available
+	 * from GINGERBREAD onwards
+	 * 
+	 * @return true - if both PullToRefresh-OverScroll and Android's inbuilt
+	 *         OverScroll are enabled
+	 */
+	public boolean isPullToRefreshOverScrollEnabled();
+
+	/**
+	 * Returns whether the Widget is currently in the Refreshing mState
+	 * 
+	 * @return true if the Widget is currently refreshing
+	 */
+	public boolean isRefreshing();
+
+	/**
+	 * Returns whether the widget has enabled scrolling on the Refreshable View
+	 * while refreshing.
+	 * 
+	 * @return true if the widget has enabled scrolling while refreshing
+	 */
+	public boolean isScrollingWhileRefreshingEnabled();
+
+	/**
+	 * Mark the current Refresh as complete. Will Reset the UI and hide the
+	 * Refreshing View
+	 */
+	public void onRefreshComplete();
+
+	/**
+	 * Set the Touch Events to be filtered or not. If set to true, then the View
+	 * will only use touch events where the difference in the Y-axis is greater
+	 * than the difference in the X-axis. This means that the View will not
+	 * interfere when it is used in a horizontal scrolling View (such as a
+	 * ViewPager), but will restrict which types of finger scrolls will trigger
+	 * the View.
+	 * 
+	 * @param filterEvents - true if you want to filter Touch Events. Default is
+	 *            true.
+	 */
+	public void setFilterTouchEvents(boolean filterEvents);
+
+	/**
+	 * Set the mode of Pull-to-Refresh that this view will use.
+	 * 
+	 * @param mode - Mode to set the View to
+	 */
+	public void setMode(Mode mode);
+
+	/**
+	 * Set OnPullEventListener for the Widget
+	 * 
+	 * @param listener - Listener to be used when the Widget has a pull event to
+	 *            propogate.
+	 */
+	public void setOnPullEventListener(OnPullEventListener<T> listener);
+
+	/**
+	 * Set OnRefreshListener for the Widget
+	 * 
+	 * @param listener - Listener to be used when the Widget is set to Refresh
+	 */
+	public void setOnRefreshListener(OnRefreshListener<T> listener);
+
+	/**
+	 * Set OnRefreshListener for the Widget
+	 * 
+	 * @param listener - Listener to be used when the Widget is set to Refresh
+	 */
+	public void setOnRefreshListener(OnRefreshListener2<T> listener);
+
+	/**
+	 * Sets whether Overscroll support is enabled. This is different to
+	 * Android's standard Overscroll support (the edge-glow). This setting only
+	 * takes effect when running on device with Android v2.3 or greater.
+	 * 
+	 * @param enabled - true if you want Overscroll enabled
+	 */
+	public void setPullToRefreshOverScrollEnabled(boolean enabled);
+
+	/**
+	 * Sets the Widget to be in the refresh state. The UI will be updated to
+	 * show the 'Refreshing' view, and be scrolled to show such.
+	 */
+	public void setRefreshing();
+
+	/**
+	 * Sets the Widget to be in the refresh state. The UI will be updated to
+	 * show the 'Refreshing' view.
+	 * 
+	 * @param doScroll - true if you want to force a scroll to the Refreshing
+	 *            view.
+	 */
+	public void setRefreshing(boolean doScroll);
+
+	/**
+	 * Sets the Animation Interpolator that is used for animated scrolling.
+	 * Defaults to a DecelerateInterpolator
+	 * 
+	 * @param interpolator - Interpolator to use
+	 */
+	public void setScrollAnimationInterpolator(Interpolator interpolator);
+
+	/**
+	 * By default the Widget disables scrolling on the Refreshable View while
+	 * refreshing. This method can change this behaviour.
+	 * 
+	 * @param scrollingWhileRefreshingEnabled - true if you want to enable
+	 *            scrolling while refreshing
+	 */
+	public void setScrollingWhileRefreshingEnabled(boolean scrollingWhileRefreshingEnabled);
+
+	/**
+	 * A mutator to enable/disable whether the 'Refreshing' View should be
+	 * automatically shown when refreshing.
+	 * 
+	 * @param showView
+	 */
+	public void setShowViewWhileRefreshing(boolean showView);
+
+}

core/pulltorefresh/src/main/java/com/handmark/pulltorefresh/library/LoadingLayoutProxy.java

@@ -0,0 +1,73 @@
+package com.handmark.pulltorefresh.library;
+
+import java.util.HashSet;
+
+import android.graphics.Typeface;
+import android.graphics.drawable.Drawable;
+
+import com.handmark.pulltorefresh.library.internal.LoadingLayout;
+
+public class LoadingLayoutProxy implements ILoadingLayout {
+
+	private final HashSet<LoadingLayout> mLoadingLayouts;
+
+	LoadingLayoutProxy() {
+		mLoadingLayouts = new HashSet<LoadingLayout>();
+	}
+
+	/**
+	 * This allows you to add extra LoadingLayout instances to this proxy. This
+	 * is only necessary if you keep your own instances, and want to have them
+	 * included in any
+	 * {@link PullToRefreshBase#createLoadingLayoutProxy(boolean, boolean)
+	 * createLoadingLayoutProxy(...)} calls.
+	 * 
+	 * @param layout - LoadingLayout to have included.
+	 */
+	public void addLayout(LoadingLayout layout) {
+		if (null != layout) {
+			mLoadingLayouts.add(layout);
+		}
+	}
+
+	@Override
+	public void setLastUpdatedLabel(CharSequence label) {
+		for (LoadingLayout layout : mLoadingLayouts) {
+			layout.setLastUpdatedLabel(label);
+		}
+	}
+
+	@Override
+	public void setLoadingDrawable(Drawable drawable) {
+		for (LoadingLayout layout : mLoadingLayouts) {
+			layout.setLoadingDrawable(drawable);
+		}
+	}
+
+	@Override
+	public void setRefreshingLabel(CharSequence refreshingLabel) {
+		for (LoadingLayout layout : mLoadingLayouts) {
+			layout.setRefreshingLabel(refreshingLabel);
+		}
+	}
+
+	@Override
+	public void setPullLabel(CharSequence label) {
+		for (LoadingLayout layout : mLoadingLayouts) {
+			layout.setPullLabel(label);
+		}
+	}
+
+	@Override
+	public void setReleaseLabel(CharSequence label) {
+		for (LoadingLayout layout : mLoadingLayouts) {
+			layout.setReleaseLabel(label);
+		}
+	}
+
+	public void setTextTypeface(Typeface tf) {
+		for (LoadingLayout layout : mLoadingLayouts) {
+			layout.setTextTypeface(tf);
+		}
+	}
+}

core/pulltorefresh/src/main/java/com/handmark/pulltorefresh/library/OverscrollHelper.java

@@ -0,0 +1,178 @@
+/*******************************************************************************
+ * Copyright 2011, 2012 Chris Banes.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.handmark.pulltorefresh.library;
+
+import android.annotation.TargetApi;
+import android.util.Log;
+import android.view.View;
+
+import com.handmark.pulltorefresh.library.PullToRefreshBase.Mode;
+import com.handmark.pulltorefresh.library.PullToRefreshBase.State;
+
+@TargetApi(9)
+public final class OverscrollHelper {
+
+	static final String LOG_TAG = "OverscrollHelper";
+	static final float DEFAULT_OVERSCROLL_SCALE = 1f;
+
+	/**
+	 * Helper method for Overscrolling that encapsulates all of the necessary
+	 * function.
+	 * <p/>
+	 * This should only be used on AdapterView's such as ListView as it just
+	 * calls through to overScrollBy() with the scrollRange = 0. AdapterView's
+	 * do not have a scroll range (i.e. getScrollY() doesn't work).
+	 * 
+	 * @param view - PullToRefreshView that is calling this.
+	 * @param deltaX - Change in X in pixels, passed through from from
+	 *            overScrollBy call
+	 * @param scrollX - Current X scroll value in pixels before applying deltaY,
+	 *            passed through from from overScrollBy call
+	 * @param deltaY - Change in Y in pixels, passed through from from
+	 *            overScrollBy call
+	 * @param scrollY - Current Y scroll value in pixels before applying deltaY,
+	 *            passed through from from overScrollBy call
+	 * @param isTouchEvent - true if this scroll operation is the result of a
+	 *            touch event, passed through from from overScrollBy call
+	 */
+	public static void overScrollBy(final PullToRefreshBase<?> view, final int deltaX, final int scrollX,
+			final int deltaY, final int scrollY, final boolean isTouchEvent) {
+		overScrollBy(view, deltaX, scrollX, deltaY, scrollY, 0, isTouchEvent);
+	}
+
+	/**
+	 * Helper method for Overscrolling that encapsulates all of the necessary
+	 * function. This version of the call is used for Views that need to specify
+	 * a Scroll Range but scroll back to it's edge correctly.
+	 * 
+	 * @param view - PullToRefreshView that is calling this.
+	 * @param deltaX - Change in X in pixels, passed through from from
+	 *            overScrollBy call
+	 * @param scrollX - Current X scroll value in pixels before applying deltaY,
+	 *            passed through from from overScrollBy call
+	 * @param deltaY - Change in Y in pixels, passed through from from
+	 *            overScrollBy call
+	 * @param scrollY - Current Y scroll value in pixels before applying deltaY,
+	 *            passed through from from overScrollBy call
+	 * @param scrollRange - Scroll Range of the View, specifically needed for
+	 *            ScrollView
+	 * @param isTouchEvent - true if this scroll operation is the result of a
+	 *            touch event, passed through from from overScrollBy call
+	 */
+	public static void overScrollBy(final PullToRefreshBase<?> view, final int deltaX, final int scrollX,
+			final int deltaY, final int scrollY, final int scrollRange, final boolean isTouchEvent) {
+		overScrollBy(view, deltaX, scrollX, deltaY, scrollY, scrollRange, 0, DEFAULT_OVERSCROLL_SCALE, isTouchEvent);
+	}
+
+	/**
+	 * Helper method for Overscrolling that encapsulates all of the necessary
+	 * function. This is the advanced version of the call.
+	 * 
+	 * @param view - PullToRefreshView that is calling this.
+	 * @param deltaX - Change in X in pixels, passed through from from
+	 *            overScrollBy call
+	 * @param scrollX - Current X scroll value in pixels before applying deltaY,
+	 *            passed through from from overScrollBy call
+	 * @param deltaY - Change in Y in pixels, passed through from from
+	 *            overScrollBy call
+	 * @param scrollY - Current Y scroll value in pixels before applying deltaY,
+	 *            passed through from from overScrollBy call
+	 * @param scrollRange - Scroll Range of the View, specifically needed for
+	 *            ScrollView
+	 * @param fuzzyThreshold - Threshold for which the values how fuzzy we
+	 *            should treat the other values. Needed for WebView as it
+	 *            doesn't always scroll back to it's edge. 0 = no fuzziness.
+	 * @param scaleFactor - Scale Factor for overscroll amount
+	 * @param isTouchEvent - true if this scroll operation is the result of a
+	 *            touch event, passed through from from overScrollBy call
+	 */
+	public static void overScrollBy(final PullToRefreshBase<?> view, final int deltaX, final int scrollX,
+			final int deltaY, final int scrollY, final int scrollRange, final int fuzzyThreshold,
+			final float scaleFactor, final boolean isTouchEvent) {
+
+		final int deltaValue, currentScrollValue, scrollValue;
+		switch (view.getPullToRefreshScrollDirection()) {
+			case HORIZONTAL:
+				deltaValue = deltaX;
+				scrollValue = scrollX;
+				currentScrollValue = view.getScrollX();
+				break;
+			case VERTICAL:
+			default:
+				deltaValue = deltaY;
+				scrollValue = scrollY;
+				currentScrollValue = view.getScrollY();
+				break;
+		}
+
+		// Check that OverScroll is enabled and that we're not currently
+		// refreshing.
+		if (view.isPullToRefreshOverScrollEnabled() && !view.isRefreshing()) {
+			final Mode mode = view.getMode();
+
+			// Check that Pull-to-Refresh is enabled, and the event isn't from
+			// touch
+			if (mode.permitsPullToRefresh() && !isTouchEvent && deltaValue != 0) {
+				final int newScrollValue = (deltaValue + scrollValue);
+
+				if (PullToRefreshBase.DEBUG) {
+					Log.d(LOG_TAG, "OverScroll. DeltaX: " + deltaX + ", ScrollX: " + scrollX + ", DeltaY: " + deltaY
+							+ ", ScrollY: " + scrollY + ", NewY: " + newScrollValue + ", ScrollRange: " + scrollRange
+							+ ", CurrentScroll: " + currentScrollValue);
+				}
+
+				if (newScrollValue < (0 - fuzzyThreshold)) {
+					// Check the mode supports the overscroll direction, and
+					// then move scroll
+					if (mode.showHeaderLoadingLayout()) {
+						// If we're currently at zero, we're about to start
+						// overscrolling, so change the state
+						if (currentScrollValue == 0) {
+							view.setState(State.OVERSCROLLING);
+						}
+
+						view.setHeaderScroll((int) (scaleFactor * (currentScrollValue + newScrollValue)));
+					}
+				} else if (newScrollValue > (scrollRange + fuzzyThreshold)) {
+					// Check the mode supports the overscroll direction, and
+					// then move scroll
+					if (mode.showFooterLoadingLayout()) {
+						// If we're currently at zero, we're about to start
+						// overscrolling, so change the state
+						if (currentScrollValue == 0) {
+							view.setState(State.OVERSCROLLING);
+						}
+
+						view.setHeaderScroll((int) (scaleFactor * (currentScrollValue + newScrollValue - scrollRange)));
+					}
+				} else if (Math.abs(newScrollValue) <= fuzzyThreshold
+						|| Math.abs(newScrollValue - scrollRange) <= fuzzyThreshold) {
+					// Means we've stopped overscrolling, so scroll back to 0
+					view.setState(State.RESET);
+				}
+			} else if (isTouchEvent && State.OVERSCROLLING == view.getState()) {
+				// This condition means that we were overscrolling from a fling,
+				// but the user has touched the View and is now overscrolling
+				// from touch instead. We need to just reset.
+				view.setState(State.RESET);
+			}
+		}
+	}
+
+	static boolean isAndroidOverScrollEnabled(View view) {
+		return view.getOverScrollMode() != View.OVER_SCROLL_NEVER;
+	}
+}

core/pulltorefresh/src/main/java/com/handmark/pulltorefresh/library/PullToRefreshAdapterViewBase.java

@@ -0,0 +1,475 @@
+/*******************************************************************************
+ * Copyright 2011, 2012 Chris Banes.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *******************************************************************************/
+package com.handmark.pulltorefresh.library;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.ViewParent;
+import android.widget.AbsListView;
+import android.widget.AbsListView.OnScrollListener;
+import android.widget.Adapter;
+import android.widget.AdapterView;
+import android.widget.AdapterView.OnItemClickListener;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.ListAdapter;
+
+import com.handmark.pulltorefresh.library.internal.EmptyViewMethodAccessor;
+import com.handmark.pulltorefresh.library.internal.IndicatorLayout;
+
+public abstract class PullToRefreshAdapterViewBase<T extends AbsListView> extends PullToRefreshBase<T> implements
+		OnScrollListener {
+
+	private static FrameLayout.LayoutParams convertEmptyViewLayoutParams(ViewGroup.LayoutParams lp) {
+		FrameLayout.LayoutParams newLp = null;
+
+		if (null != lp) {
+			newLp = new FrameLayout.LayoutParams(lp);
+
+			if (lp instanceof LinearLayout.LayoutParams) {
+				newLp.gravity = ((LinearLayout.LayoutParams) lp).gravity;
+			} else {
+				newLp.gravity = Gravity.CENTER;
+			}
+		}
+
+		return newLp;
+	}
+
+	private boolean mLastItemVisible;
+	private OnScrollListener mOnScrollListener;
+	private OnLastItemVisibleListener mOnLastItemVisibleListener;
+	private View mEmptyView;
+
+	private IndicatorLayout mIndicatorIvTop;
+	private IndicatorLayout mIndicatorIvBottom;
+
+	private boolean mShowIndicator;
+	private boolean mScrollEmptyView = true;
+
+	public PullToRefreshAdapterViewBase(Context context) {
+		super(context);
+		mRefreshableView.setOnScrollListener(this);
+	}
+
+	public PullToRefreshAdapterViewBase(Context context, AttributeSet attrs) {
+		super(context, attrs);
+		mRefreshableView.setOnScrollListener(this);
+	}
+
+	public PullToRefreshAdapterViewBase(Context context, Mode mode) {
+		super(context, mode);
+		mRefreshableView.setOnScrollListener(this);
+	}
+
+	public PullToRefreshAdapterViewBase(Context context, Mode mode, AnimationStyle animStyle) {
+		super(context, mode, animStyle);
+		mRefreshableView.setOnScrollListener(this);
+	}
+
+	/**
+	 * Gets whether an indicator graphic should be displayed when the View is in
+	 * a state where a Pull-to-Refresh can happen. An example of this state is
+	 * when the Adapter View is scrolled to the top and the mode is set to
+	 * {@link Mode#PULL_FROM_START}. The default value is <var>true</var> if
+	 * {@link PullToRefreshBase#isPullToRefreshOverScrollEnabled()
+	 * isPullToRefreshOverScrollEnabled()} returns false.
+	 * 
+	 * @return true if the indicators will be shown
+	 */
+	public boolean getShowIndicator() {
+		return mShowIndicator;
+	}
+
+	public final void onScroll(final AbsListView view, final int firstVisibleItem, final int visibleItemCount,
+			final int totalItemCount) {
+
+		if (DEBUG) {
+			Log.d(LOG_TAG, "First Visible: " + firstVisibleItem + ". Visible Count: " + visibleItemCount
+					+ ". Total Items:" + totalItemCount);
+		}
+
+		/**
+		 * Set whether the Last Item is Visible. lastVisibleItemIndex is a
+		 * zero-based index, so we minus one totalItemCount to check
+		 */
+		if (null != mOnLastItemVisibleListener) {
+			mLastItemVisible = (totalItemCount > 0) && (firstVisibleItem + visibleItemCount >= totalItemCount - 1);
+		}
+
+		// If we're showing the indicator, check positions...
+		if (getShowIndicatorInternal()) {
+			updateIndicatorViewsVisibility();
+		}
+
+		// Finally call OnScrollListener if we have one
+		if (null != mOnScrollListener) {
+			mOnScrollListener.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);
+		}
+	}
+
+	public final void onScrollStateChanged(final AbsListView view, final int state) {
+		/**
+		 * Check that the scrolling has stopped, and that the last item is
+		 * visible.
+		 */
+		if (state == OnScrollListener.SCROLL_STATE_IDLE && null != mOnLastItemVisibleListener && mLastItemVisible) {
+			mOnLastItemVisibleListener.onLastItemVisible();
+		}
+
+		if (null != mOnScrollListener) {
+			mOnScrollListener.onScrollStateChanged(view, state);
+		}
+	}
+
+	/**
+	 * Pass-through method for {@link PullToRefreshBase#getRefreshableView()
+	 * getRefreshableView()}.
+	 * {@link AdapterView#setAdapter(android.widget.Adapter)}
+	 * setAdapter(adapter)}. This is just for convenience!
+	 * 
+	 * @param adapter - Adapter to set
+	 */
+	public void setAdapter(ListAdapter adapter) {
+		((AdapterView<ListAdapter>) mRefreshableView).setAdapter(adapter);
+	}
+
+	/**
+	 * Sets the Empty View to be used by the Adapter View.
+	 * <p/>
+	 * We need it handle it ourselves so that we can Pull-to-Refresh when the
+	 * Empty View is shown.
+	 * <p/>
+	 * Please note, you do <strong>not</strong> usually need to call this method
+	 * yourself. Calling setEmptyView on the AdapterView will automatically call
+	 * this method and set everything up. This includes when the Android
+	 * Framework automatically sets the Empty View based on it's ID.
+	 * 
+	 * @param newEmptyView - Empty View to be used
+	 */
+	public final void setEmptyView(View newEmptyView) {
+		FrameLayout refreshableViewWrapper = getRefreshableViewWrapper();
+
+		if (null != newEmptyView) {
+			// New view needs to be clickable so that Android recognizes it as a
+			// target for Touch Events
+			newEmptyView.setClickable(true);
+
+			ViewParent newEmptyViewParent = newEmptyView.getParent();
+			if (null != newEmptyViewParent && newEmptyViewParent instanceof ViewGroup) {
+				((ViewGroup) newEmptyViewParent).removeView(newEmptyView);
+			}
+
+			// We need to convert any LayoutParams so that it works in our
+			// FrameLayout
+			FrameLayout.LayoutParams lp = convertEmptyViewLayoutParams(newEmptyView.getLayoutParams());
+			if (null != lp) {
+				refreshableViewWrapper.addView(newEmptyView, lp);
+			} else {
+				refreshableViewWrapper.addView(newEmptyView);
+			}
+		}
+
+		if (mRefreshableView instanceof EmptyViewMethodAccessor) {
+			((EmptyViewMethodAccessor) mRefreshableView).setEmptyViewInternal(newEmptyView);
+		} else {
+			mRefreshableView.setEmptyView(newEmptyView);
+		}
+		mEmptyView = newEmptyView;
+	}
+
+	/**
+	 * Pass-through method for {@link PullToRefreshBase#getRefreshableView()
+	 * getRefreshableView()}.
+	 * {@link AdapterView#setOnItemClickListener(OnItemClickListener)
+	 * setOnItemClickListener(listener)}. This is just for convenience!
+	 * 
+	 * @param listener - OnItemClickListener to use
+	 */
+	public void setOnItemClickListener(OnItemClickListener listener) {
+		mRefreshableView.setOnItemClickListener(listener);
+	}
+
+	public final void setOnLastItemVisibleListener(OnLastItemVisibleListener listener) {
+		mOnLastItemVisibleListener = listener;
+	}
+
+	public final void setOnScrollListener(OnScrollListener listener) {
+		mOnScrollListener = listener;
+	}
+
+	public final void setScrollEmptyView(boolean doScroll) {
+		mScrollEmptyView = doScroll;
+	}
+
+	/**
+	 * Sets whether an indicator graphic should be displayed when the View is in
+	 * a state where a Pull-to-Refresh can happen. An example of this state is
+	 * when the Adapter View is scrolled to the top and the mode is set to
+	 * {@link Mode#PULL_FROM_START}
+	 * 
+	 * @param showIndicator - true if the indicators should be shown.
+	 */
+	public void setShowIndicator(boolean showIndicator) {
+		mShowIndicator = showIndicator;
+
+		if (getShowIndicatorInternal()) {
+			// If we're set to Show Indicator, add/update them
+			addIndicatorViews();
+		} else {
+			// If not, then remove then
+			removeIndicatorViews();
+		}
+	}
+
+	;
+
+	@Override
+	protected void onPullToRefresh() {
+		super.onPullToRefresh();
+
+		if (getShowIndicatorInternal()) {
+			switch (getCurrentMode()) {
+				case PULL_FROM_END:
+					mIndicatorIvBottom.pullToRefresh();
+					break;
+				case PULL_FROM_START:
+					mIndicatorIvTop.pullToRefresh();
+					break;
+				default:
+					// NO-OP
+					break;
+			}
+		}
+	}
+
+	protected void onRefreshing(boolean doScroll) {
+		super.onRefreshing(doScroll);
+
+		if (getShowIndicatorInternal()) {
+			updateIndicatorViewsVisibility();
+		}
+	}
+
+	@Override
+	protected void onReleaseToRefresh() {
+		super.onReleaseToRefresh();
+
+		if (getShowIndicatorInternal()) {
+			switch (getCurrentMode()) {
+				case PULL_FROM_END:
+					mIndicatorIvBottom.releaseToRefresh();
+					break;
+				case PULL_FROM_START:
+					mIndicatorIvTop.releaseToRefresh();
+					break;
+				default:
+					// NO-OP
+					break;
+			}
+		}
+	}
+
+	@Override
+	protected void onReset() {
+		super.onReset();
+
+		if (getShowIndicatorInternal()) {
+			updateIndicatorViewsVisibility();
+		}
+	}
+
+	@Override
+	protected void handleStyledAttributes(TypedArray a) {
+		// Set Show Indicator to the XML value, or default value
+		mShowIndicator = a.getBoolean(R.styleable.PullToRefresh_ptrShowIndicator, !isPullToRefreshOverScrollEnabled());
+	}
+
+	protected boolean isReadyForPullStart() {
+		return isFirstItemVisible();
+	}
+
+	protected boolean isReadyForPullEnd() {
+		return isLastItemVisible();
+	}
+
+	@Override
+	protected void onScrollChanged(int l, int t, int oldl, int oldt) {
+		super.onScrollChanged(l, t, oldl, oldt);
+		if (null != mEmptyView && !mScrollEmptyView) {
+			mEmptyView.scrollTo(-l, -t);
+		}
+	}
+
+	@Override
+	protected void updateUIForMode() {
+		super.updateUIForMode();
+
+		// Check Indicator Views consistent with new Mode
+		if (getShowIndicatorInternal()) {
+			addIndicatorViews();
+		} else {
+			removeIndicatorViews();
+		}
+	}
+
+	private void addIndicatorViews() {
+		Mode mode = getMode();
+		FrameLayout refreshableViewWrapper = getRefreshableViewWrapper();
+
+		if (mode.showHeaderLoadingLayout() && null == mIndicatorIvTop) {
+			// If the mode can pull down, and we don't have one set already
+			mIndicatorIvTop = new IndicatorLayout(getContext(), Mode.PULL_FROM_START);
+			FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
+					ViewGroup.LayoutParams.WRAP_CONTENT);
+			params.rightMargin = getResources().getDimensionPixelSize(R.dimen.indicator_right_padding);
+			params.gravity = Gravity.TOP | Gravity.RIGHT;
+			refreshableViewWrapper.addView(mIndicatorIvTop, params);
+
+		} else if (!mode.showHeaderLoadingLayout() && null != mIndicatorIvTop) {
+			// If we can't pull down, but have a View then remove it
+			refreshableViewWrapper.removeView(mIndicatorIvTop);
+			mIndicatorIvTop = null;
+		}
+
+		if (mode.showFooterLoadingLayout() && null == mIndicatorIvBottom) {
+			// If the mode can pull down, and we don't have one set already
+			mIndicatorIvBottom = new IndicatorLayout(getContext(), Mode.PULL_FROM_END);
+			FrameLayout.LayoutParams params = new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT,
+					ViewGroup.LayoutParams.WRAP_CONTENT);
+			params.rightMargin = getResources().getDimensionPixelSize(R.dimen.indicator_right_padding);
+			params.gravity = Gravity.BOTTOM | Gravity.RIGHT;
+			refreshableViewWrapper.addView(mIndicatorIvBottom, params);
+
+		} else if (!mode.showFooterLoadingLayout() && null != mIndicatorIvBottom) {
+			// If we can't pull down, but have a View then remove it
+			refreshableViewWrapper.removeView(mIndicatorIvBottom);
+			mIndicatorIvBottom = null;
+		}
+	}
+
+	private boolean getShowIndicatorInternal() {
+		return mShowIndicator && isPullToRefreshEnabled();
+	}
+
+	private boolean isFirstItemVisible() {
+		final Adapter adapter = mRefreshableView.getAdapter();
+
+		if (null == adapter || adapter.isEmpty()) {
+			if (DEBUG) {
+				Log.d(LOG_TAG, "isFirstItemVisible. Empty View.");
+			}
+			return true;
+
+		} else {
+
+			/**
+			 * This check should really just be:
+			 * mRefreshableView.getFirstVisiblePosition() == 0, but PtRListView
+			 * internally use a HeaderView which messes the positions up. For
+			 * now we'll just add one to account for it and rely on the inner
+			 * condition which checks getTop().
+			 */
+			if (mRefreshableView.getFirstVisiblePosition() <= 1) {
+				final View firstVisibleChild = mRefreshableView.getChildAt(0);
+				if (firstVisibleChild != null) {
+					return firstVisibleChild.getTop() >= mRefreshableView.getTop();
+				}
+			}
+		}
+
+		return false;
+	}
+
+	private boolean isLastItemVisible() {
+		final Adapter adapter = mRefreshableView.getAdapter();
+
+		if (null == adapter || adapter.isEmpty()) {
+			if (DEBUG) {
+				Log.d(LOG_TAG, "isLastItemVisible. Empty View.");
+			}
+			return true;
+		} else {
+			final int lastItemPosition = mRefreshableView.getCount() - 1;
+			final int lastVisiblePosition = mRefreshableView.getLastVisiblePosition();
+
+			if (DEBUG) {
+				Log.d(LOG_TAG, "isLastItemVisible. Last Item Position: " + lastItemPosition + " Last Visible Pos: "
+						+ lastVisiblePosition);
+			}
+
+			/**
+			 * This check should really just be: lastVisiblePosition ==
+			 * lastItemPosition, but PtRListView internally uses a FooterView
+			 * which messes the positions up. For me we'll just subtract one to
+			 * account for it and rely on the inner condition which checks
+			 * getBottom().
+			 */
+			if (lastVisiblePosition >= lastItemPosition - 1) {
+				final int childIndex = lastVisiblePosition - mRefreshableView.getFirstVisiblePosition();
+				final View lastVisibleChild = mRefreshableView.getChildAt(childIndex);
+				if (lastVisibleChild != null) {
+					return lastVisibleChild.getBottom() <= mRefreshableView.getBottom();
+				}
+			}
+		}
+
+		return false;
+	}
+
+	private void removeIndicatorViews() {
+		if (null != mIndicatorIvTop) {
+			getRefreshableViewWrapper().removeView(mIndicatorIvTop);
+			mIndicatorIvTop = null;
+		}
+
+		if (null != mIndicatorIvBottom) {
+			getRefreshableViewWrapper().removeView(mIndicatorIvBottom);
+			mIndicatorIvBottom = null;
+		}
+	}
+
+	private void updateIndicatorViewsVisibility() {
+		if (null != mIndicatorIvTop) {
+			if (!isRefreshing() && isReadyForPullStart()) {
+				if (!mIndicatorIvTop.isVisible()) {
+					mIndicatorIvTop.show();
+				}
+			} else {
+				if (mIndicatorIvTop.isVisible()) {
+					mIndicatorIvTop.hide();
+				}
+			}
+		}
+
+		if (null != mIndicatorIvBottom) {
+			if (!isRefreshing() && isReadyForPullEnd()) {
+				if (!mIndicatorIvBottom.isVisible()) {
+					mIndicatorIvBottom.show();
+				}
+			} else {
+				if (mIndicatorIvBottom.isVisible()) {
+					mIndicatorIvBottom.hide();
+				}
+			}
+		}
+	}
+}