new icons and settings.

Use transparent status bar color

Closes #2203

See merge request fdroid/fdroidclient!1029

.gitattributes

@@ -0,0 +1 @@
+*.gpg           binary

.gitignore

@@ -16,7 +16,6 @@ build.xml
 # Gradle files
 .gradle/
 build/
-gradle.properties
 
 # Local configuration file (sdk path, etc)
 local.properties
@@ -43,3 +42,8 @@ extern/*/*/libs/
 
 # Tests
 junit-report.xml
+
+# Screen dumps from Android Studio/DDMS
+captures/
+
+/fdroid/

.gitlab-ci.yml

@@ -1,90 +1,142 @@
-image: fdroid/ci:client-20161023
+stages:
+  - test
+  - deploy
 
-cache:
-  paths:
-    - .gradle/wrapper
-    - .gradle/caches
-
-before_script:
-  - export GRADLE_USER_HOME=$PWD/.gradle
-  - printf 'y\n\n' | android --verbose update sdk --no-ui
-     --filter extra-android-m2repository
-
-test:
-  script:
-    - ./gradlew assemble -PdisablePreDex
-    # always report on lint errors to the build log
-    - sed -i -e 's,textReport .*,textReport true,' app/build.gradle
-    - ./gradlew lint -PdisablePreDex
-    - ./gradlew test -PdisablePreDex || {
-          for log in app/build/reports/*ests/*/*ml; do
-              echo "read $log here:";
-              cat "$log" | curl --silent -F 'clbin=<-' https://clbin.com;
-          done;
-          exit 1;
-      }
-
-connected10:
-  variables:
-    AVD_SDK: "10"
-  script:
-    - emulator64-arm -avd fcl-test-$AVD_SDK -no-skin -no-audio -no-window &
-    - ./tools/wait-for-emulator
-    - adb shell input keyevent 82 &
-    - export EXITVALUE=0
-    - ./gradlew connectedCheck -PdisablePreDex || {
-        adb -e logcat -d '*:E';
-        echo "get the full logcat here:";
-        adb -e logcat -d | curl --silent -F 'clbin=<-' https://clbin.com;
-        export EXITVALUE=1;
-      }
-    - for log in app/build/reports/*ests/*/*ml
-                 app/build/outputs/*results*/connected/*.xml; do
-        echo "read $log here:";
-        cat "$log" | curl --silent -F 'clbin=<-' https://clbin.com;
-      done
-  allow_failure: true
-
-connected24:
-  variables:
-    AVD_SDK: "24"
-  script:
-    - emulator64-x86 -avd fcl-test-$AVD_SDK -no-skin -no-audio -no-window &
-    - ./tools/wait-for-emulator
-    - adb shell input keyevent 82 &
-    - export EXITVALUE=0
-    - ./gradlew connectedCheck -PdisablePreDex || {
-        adb -e logcat -d '*:E';
-        echo "get the full logcat here:";
-        adb -e logcat -d | curl --silent -F 'clbin=<-' https://clbin.com;
-        export EXITVALUE=1;
-      }
-    - for log in app/build/reports/*ests/*/*ml
-                 app/build/outputs/*results*/connected/*.xml; do
-        echo "read $log here:";
-        cat "$log" | curl --silent -F 'clbin=<-' https://clbin.com;
-      done
-    - exit $EXITVALUE
-
-pmd:
-  script:
-    - ./gradlew pmd -PdisablePreDex
-
-checkstyle:
-  script:
-    - ./gradlew checkstyle -PdisablePreDex
-
-tools:
+.base:
+  image: registry.gitlab.com/fdroid/ci-images-client:latest
   before_script:
-    - echo "ignored, no gradle needed"
-  script:
-    - cd app
-    - ./tools/langs-list-check.py
-    - ./tools/check-string-format.py
+    - export GRADLE_USER_HOME=$PWD/.gradle
+    - export ANDROID_COMPILE_SDK=`sed -n 's,.*compileSdkVersion\s*\([0-9][0-9]*\).*,\1,p' app/build.gradle`
+    - alias sdkmanager="sdkmanager --no_https"
+    - echo y | sdkmanager "platforms;android-${ANDROID_COMPILE_SDK}" > /dev/null
+    # limit RAM usage for all gradle runs
+    - export maxmem=$(expr $(sed -n 's,^MemAvailable:[^0-9]*\([0-9][0-9]*\)[^0-9]*$,\1,p' /proc/meminfo) / 1024 / 2 / 1024 \* 1024)
+    - printf "\norg.gradle.jvmargs=-Xmx${maxmem}m -XX:MaxPermSize=${maxmem}m\norg.gradle.daemon=false\norg.gradle.parallel=false\n" >> gradle.properties
   after_script:
-    - echo "ignored, no gradle needed"
-
-after_script:
     # this file changes every time but should not be cached
     - rm -f $GRADLE_USER_HOME/caches/modules-2/modules-2.lock
     - rm -fr $GRADLE_USER_HOME/caches/*/plugin-resolution/
+  cache:
+    paths:
+      - .gradle/wrapper
+      - .gradle/caches
+
+.test-template: &test-template
+  extends: .base
+  stage: test
+  artifacts:
+    name: "${CI_PROJECT_PATH}_${CI_JOB_STAGE}_${CI_COMMIT_REF_NAME}_${CI_COMMIT_SHA}"
+    paths:
+      - kernel.log
+      - logcat.txt
+      - app/core*
+      - app/*.log
+      - app/build/reports
+      - app/build/outputs/*ml
+      - app/build/outputs/apk
+    expire_in: 1 week
+    when: on_failure
+  after_script:
+    - echo "Download debug artifacts from https://gitlab.com/${CI_PROJECT_PATH}/-/jobs"
+
+# Run the most important first. Then we can decide whether to ignore
+# the style tests if the rest of the more meaningful tests pass.
+test_lint_pmd_checkstyle:
+  <<: *test-template
+  script:
+    - export EXITVALUE=0
+    - function set_error() { export EXITVALUE=1; printf "\x1b[31mERROR `history|tail -2|head -1|cut -b 6-500`\x1b[0m\n"; }
+    - ./gradlew assemble
+    # always report on lint errors to the build log
+    - sed -i -e 's,textReport .*,textReport true,' app/build.gradle
+    - ./gradlew testFullDebugUnitTest || set_error
+    - ./gradlew lint || set_error
+    - ./gradlew pmd || set_error
+    - ./gradlew checkstyle || set_error
+    - ./tools/check-format-strings.py || set_error
+    - ./tools/check-fastlane-whitespace.py || set_error
+    - ./tools/remove-unused-and-blank-translations.py || set_error
+    - echo "These are unused or blank translations that should be removed:"
+    - git --no-pager diff --ignore-all-space --name-only --exit-code app/src/*/res/values*/strings.xml || set_error
+    - exit $EXITVALUE
+
+errorprone:
+  extends: .base
+  stage: test
+  script:
+    - apt-get update
+    - apt-get install -t stretch-backports openjdk-11-jdk-headless
+    - update-java-alternatives --set java-1.11.0-openjdk-amd64
+    - export JAVA_HOME=/usr/lib/jvm/java-1.11.0-openjdk-amd64
+    - cat config/errorprone.gradle >> app/build.gradle
+    - ./gradlew -Dorg.gradle.dependency.verification=lenient assembleDebug
+
+# Run the tests in the emulator.  Each step is broken out to run on
+# its own since the CI runner can have limited RAM, and the emulator
+# can take a while to start.
+#
+# once these prove stable, the task should be switched to
+# connectedCheck to test all the build flavors
+.connected-template: &connected-template
+  extends: .base
+  script:
+    - ./gradlew assembleFullDebug
+    - export AVD_SDK=`echo $CI_JOB_NAME | awk '{print $2}'`
+    - export AVD_TAG=`echo $CI_JOB_NAME | awk '{print $3}'`
+    - export AVD_ARCH=`echo $CI_JOB_NAME | awk '{print $4}'`
+    - export AVD_PACKAGE="system-images;android-${AVD_SDK};${AVD_TAG};${AVD_ARCH}"
+    - echo $AVD_PACKAGE
+
+    - alias sdkmanager
+    - ls -l ~/.android
+
+    - adb start-server
+    - start-emulator
+    - wait-for-emulator
+    - adb devices
+    - adb shell input keyevent 82 &
+    - ./gradlew installFullDebug
+    - adb shell am start -n org.fdroid.fdroid.debug/org.fdroid.fdroid.views.main.MainActivity
+    - if [ $AVD_SDK -lt 25 ] || ! emulator -accel-check; then
+          export FLAG=-Pandroid.testInstrumentationRunnerArguments.notAnnotation=androidx.test.filters.LargeTest;
+      fi
+    - ./gradlew connectedFullDebugAndroidTest $FLAG
+
+no-accel 22 default x86:
+  <<: *test-template
+  <<: *connected-template
+
+.kvm-template: &kvm-template
+  tags:
+    - fdroid
+    - kvm
+  only:
+    variables:
+      - $RUN_KVM_JOBS
+  <<: *test-template
+  <<: *connected-template
+
+kvm 29 microg x86_64:
+  <<: *kvm-template
+
+deploy_nightly:
+  extends: .base
+  stage: deploy
+  only:
+    - master
+  script:
+    - test -z "$DEBUG_KEYSTORE" && exit 0
+    - sed -i
+        's,<string name="app_name">.*</string>,<string name="app_name">F-Nightly</string>,'
+        app/src/main/res/values*/strings.xml
+    # add this nightly repo as a enabled repo
+    - sed -i -e '/<\/string-array>/d' -e '/<\/resources>/d' app/src/main/res/values/default_repos.xml
+    - echo "<item>${CI_PROJECT_PATH}-nightly</item>" >> app/src/main/res/values/default_repos.xml
+    - echo "<item>${CI_PROJECT_URL}-nightly/raw/master/fdroid/repo</item>" >> app/src/main/res/values/default_repos.xml
+    - cat config/nightly-repo/repo.xml >> app/src/main/res/values/default_repos.xml
+    - export DB=`sed -n 's,.*DB_VERSION *= *\([0-9][0-9]*\).*,\1,p' app/src/main/java/org/fdroid/fdroid/data/DBHelper.java`
+    - export versionCode=`printf '%d%05d' $DB $(date '+%s'| cut -b4-8)`
+    - sed -i "s,^\(\s*versionCode\)  *[0-9].*,\1 $versionCode," app/build.gradle
+    # build the APKs!
+    - ./gradlew assembleDebug
+    - fdroid nightly -v

.weblate

@@ -0,0 +1,3 @@
+[weblate]
+url = https://hosted.weblate.org/api/
+translation = f-droid/f-droid

Android.mk

@@ -10,7 +10,7 @@ fdroid_root  := $(LOCAL_PATH)
 fdroid_dir   := app
 fdroid_out   := $(PWD)/$(OUT_DIR)/target/common/obj/APPS/$(LOCAL_MODULE)_intermediates
 fdroid_build := $(fdroid_root)/$(fdroid_dir)/build
-fdroid_apk   := build/outputs/apk/$(fdroid_dir)-release-unsigned.apk
+fdroid_apk   := build/outputs/apk/full/release/$(fdroid_dir)-full-release-unsigned.apk
 
 $(fdroid_root)/$(fdroid_dir)/$(fdroid_apk):
 	rm -Rf $(fdroid_build)

CHANGELOG.md

@@ -1,4 +1,586 @@
-### 0.102 (2016-??-??)
+### 1.13-alpha1 (2021-06-02)
+
+* Stop repeated updates of Trichrome Library
+
+* More changes to follow Material Design (@proletarius101)
+
+* Improve OpenCollective badge (@ConnyDuck)
+
+### 1.13-alpha0 (2021-04-22)
+
+* Theme support tied to built-in Android themes (@proletarius101)
+
+* New top banner notifications: "No Internet" and "No Data or WiFi enabled"
+
+* Improved handling of USB-OTG and SD Card repos and mirrors
+
+### 1.12.1 (2021-04-12)
+
+* Fix trove4j verification error
+
+### 1.12 (2021-04-06)
+
+* Sync translations
+
+### 1.12-alpha3 (2021-03-10)
+
+* Opt-in F-Droid Metrics
+
+### 1.12-alpha2 (2021-03-03)
+
+* Overhaul clean up of cached files
+
+* Support updating "shared library packages" like Trichrome (@uldiniad)
+
+### 1.12-alpha1 (2021-02-25)
+
+* Add extra sanitation to search terms to prevent vulnerabilities.
+
+* Fix Nearby Swap's close button (@proletarius101)
+
+* Bump to compileSdkVersion 29 to support Java8
+
+* Set up WorkManager on demand to avoid slowing down starts
+
+* Prefer system keys when APKs are signed by them (@glennmen)
+
+### 1.12-alpha0 (2021-02-08)
+
+* App description localization now fully respects lists of languages in Android
+  Language Settings
+
+* Latest Tab lists results based on the Language Settings
+
+* Latest Tab now shows results ordered newest first (@TheLastProject @IzzySoft)
+
+* Theme support modernized and tied to the built-in Android themes (@proletarius101)
+
+* Search results greatly improved (@Tvax @gcbrown76)
+
+* Let Android efficiently schedule background cache cleanup operations (@Isira-Seneviratne)
+
+* Overhaul repo URL parsing for reliable repo adding (@projectgus)
+
+### 1.11 (2020-12-29)
+
+* Improved linkifying of URLs in app descriptions
+
+* Improved handling of SDCards and USG-OTG in Nearby
+
+* Modernized code and switched PNGs to vectors (thanks @isira-seneviratne!)
+
+* Recognize longer repo URLs to support GitCDN/RawGit/etc mirrors
+
+### 1.10 (2020-10-20)
+
+* Improved language selection with multiple locales
+  (thanks @spacecowboy and @bubu!)
+
+### 1.10-alpha1 (2020-09-29)
+
+* use notification channels for fine-grained control (@Isira-Seneviratne)
+
+### 1.10-alpha0 (2020-07-20)
+
+* Latest Tab will show better results on non-English devices
+
+* updates to core libraries (Jackson, androidx, gradle, etc)
+
+* use Gradle's new dependency verification
+
+* polish whitelabeling support
+
+### 1.9 (2020-06-25)
+
+* Removed "Android App Link" support since it cannot work with
+  F-Droid, and it was triggering DNS leaks.
+
+* Archive Repos are now lower priority than the Repo (higher on the
+  Manage Repos screen), fixing issues where it looked for icons,
+  screenshots and other information in the Archive rather than the
+  Repo itself.
+
+* Fixed hopefully all occurrences where F-Droid client couldn't show an icon.
+  The remaining cases of missing icons are now caused either by 
+  icons not included in upstream repo or by temporary network failures.
+  (After updating this requires one additional repo update to take effect.)
+
+* Fixed a problem where repository updates would never trigger
+  when either "Over Data" or "Over Wifi" were disabled.
+
+* Support OpenCollective donation option and highlight 
+  free software donation platforms
+
+* Fix for when the app update button wasn't showing up or working 
+  in some cases (thanks @di72nn)
+
+* Stop cropping feature header image (thanks @ByteHamster!)
+
+* Make navigation bar match dark mode (thanks @MatthieuB!)
+
+* Cleaned out obsolete code (thanks @Isira-Seneviratne!)
+
+### 1.8-alpha2 (2020-02-04)
+
+* stop showing Unknown Sources with Privileged Extension on Android 10 #1833
+
+* add standard ripple effect to links on app details activity
+
+* fix displaying default icon for apps without icons
+
+### 1.8-alpha1 (2020-01-10)
+
+* handle Android 10 permission config to stop Unknown Sources prompts
+
+* keyboard opens when search is cleared
+
+* translation sync with Android strings
+
+* force common repo domains to HTTPS (GitLab, GitHub, Amazon)
+
+### 1.8-alpha0 (2019-11-20)
+
+* fix seekbar preference on recent Android versions (thanks @dkanada)
+
+* handle API 29 split-permissions: fine location now implies coarse location
+
+* define backup rules to avoid saving the swap repo
+
+### 1.7.1 (2019-07-31)
+
+* fix crashes from ACRA report emails
+
+### 1.7 (2019-07-06)
+
+* fix crash in Panic Settings
+
+* catch random crashes related to WifiApControl
+
+### 1.7-alpha2 (2019-06-18)
+
+* USB OTG flash drives can be used as nearby repos and mirrors 
+
+### 1.7-alpha1 (2019-06-14)
+
+* overhauled nearby swap using the device's hotspot AP
+
+* add new panic responses: app uninstalls and reset repos to default
+
+* fix proxy support on first start
+
+### 1.7-alpha0 (2019-05-20)
+
+* major refactor of "Nearby" UI code, to prepare for rewriting guts
+
+* show "undo" after swiping away items from the Updates tab (thanks @Hocuri!)
+
+* fix ETag handling when connecting to nginx mirrors #1737
+
+* fix issues with "Latest" display caused by mishandling time zones #1757
+
+* ignore all unimportant crashes in background services
+
+* do not use Privileged Extension if it was disabled in Settings
+
+### 1.6.2 (2019-05-20)
+
+* fixed issue where cached indexes were wrongly redownloaded (#1737),
+  thanks to @amiraliakbari for tracking it down!
+
+* fixed wrong string for the translated title of the Updates Tab (#1785)
+
+* fixed crashes on very low memory when starting
+
+### 1.6.1 (2019-05-10)
+
+* Updated translations
+
+* fixed button size issues #1678
+
+* stopped random background crashes
+
+### 1.6 (2019-04-10)
+
+* update F-Droid after all other updates (#1556)
+
+* Improve adding repos from the clipboard (e.g. Firefox Klar)
+
+* swap usability improvements
+
+* many crash fixes in swap and background services
+
+### 1.6-alpha2 (2019-03-28)
+
+* Latest Tab now highlights apps that provide descriptions,
+  translations, screenshots
+
+* Auto-download from mirrors, to speed up downloads and reduce load on
+  f-droid.org
+
+* More efficient download caching (per-repo; across different
+  webservers #1708)
+
+* Fix problems canceling downloads (#1727, #1736, #1742)
+
+* Fix downloading OBB files from repos (#1403)
+
+### 1.6-alpha1 (2019-02-20)
+
+* add switches in RepoDetails to disable any or all mirrors (#1696)
+
+* choose random mirror for each package/APK download
+
+* make all APK downloads be cached per-repo, not per-mirror
+
+* handle Apache and Nginx ETags when checking if index is current (#1708)
+
+### 1.6-alpha0 (2019-02-15)
+
+* handle implied READ_EXTERNAL_STORAGE permissions, which trigger a
+  permissions prompt on installs with Privileged Extension (#1702)
+
+* sanitize index data to reduce the threats from the server
+
+* set Read Timeout to trigger mirror use when reads are slow
+
+* fix missing icons for those who do not use WiFi (#1592)
+
+* use separate titles for Updates pref and Updates tab, so that they
+  can be better translated
+
+* UI fixes from @ConnyDuck (#1636, #1618)
+
+### 1.5.1 (2019-01-07)
+
+* Removed incomplete translations that were accidentally added in 1.5
+
+* Fix screenshot background on dark themes (#1618)
+
+### 1.5 (2018-12-26)
+
+* Nearby swap bug fixes and improvements
+
+* update language and translations about Nearby and swap
+
+* Fix displaying of icons for self-built apps (#1108)
+
+### 1.5-alpha2 (2018-12-21)
+
+* support swapping via SD Cards
+
+* display versionCode in expanded Versions list entries in Expert Mode
+
+### 1.5-alpha1 (2018-12-12)
+
+* UX and language cleanup of App Details
+
+### 1.5-alpha0 (2018-10-19)
+
+* add repos via additional_repos.xml from ROM, OEM, Vendor.
+
+### 1.4 (2018-09-12)
+
+* polish up new "Versions" list and other UI fixes
+
+### 1.4-alpha1 (2018-08-30)
+
+* huge overhaul of the "Versions" list in the App Details screen, and
+  many other UI improvements, thanks to new contributor @wsdfhjxc
+
+* fixes to allow keyboard/d-pad navigation in more places, thanks to
+  new contributor @doeffinger
+
+### 1.4-alpha0 (2018-08-17)
+
+* show "Open" button when media is installed and viewable
+
+* retry index downloads from mirrors
+
+* add Share button to "Installed Apps" to export CSV list
+
+* add clickable list of APKs to the swap HTML index page 
+
+### 1.3.1 (2018-08-07)
+
+* big overhaul of core nearby/swap plumbing
+
+* TLSv1.3 support, when the device supports it
+
+### 1.3 (2018-07-31)
+
+* large overhaul to make status updates more reliable
+
+* fixed many bugs around the wrong button showing
+
+### 1.3-alpha5 (2018-07-21)
+
+* overhaul install button logic to avoid false presses
+
+* improved first time run experience
+
+* export install/uninstall history
+
+* more whitelabeling improvements
+
+### 1.3-alpha4 (2018-07-13)
+
+* fix Data/WiFi preferences to properly schedule Updats
+
+* fix Install/Uninstall events for clearer feedback
+
+* track pending installs properly, stop fake repeating updates
+
+* add support for Repo Push Requests when using Index V1
+
+* support NoSourceSince anti-feature
+
+* share menu item for repos
+
+* fix a few crasher bugs
+
+### 1.3-alpha3 (2018-06-27)
+
+* fix bug that disabled Privileged Extension
+
+* prevent crash loop after rapid install/uninstall cycling
+
+* add expert option to send debug version/UUID on each HTTP download
+
+* allow user to disable ACRA entirely with a preference
+
+* basic Install History viewer, available only when logging is enabled
+
+### 1.3-alpha2 (2018-06-25)
+
+* Settings improvements
+
+* new Expert Setting for disabling all notifications
+
+* huge improvements for custom "whitelabel" F-Droid versions
+
+### 1.3-alpha1 (2018-06-15)
+
+* improved Settings for controlling data usage
+
+* support push install/uninstall requests in index-v1
+
+### 1.3-alpha0 (2018-04-25)
+
+* more battery conscious background operation on Android 5.0 and newer
+
+* make Anti-Features list in App Details clickable
+
+* new Settings for controlling data usage
+
+* switch Settings to Material style
+
+* bumped minimum supported version to Android 4.0 (14)
+
+### 1.2.2 (2018-04-23)
+
+* fix crasher bug on devices running on Android 4.2 or older #1424
+
+### 1.2.1 (2018-04-18)
+
+* improved automatic mirror selection
+
+* more swap/nearby bug fixes and improvements
+
+### 1.2 (2018-04-13)
+
+* lots of swap/nearby bug fixes and improvements
+
+* fix one cause of reoccuring update notifications (#1271)
+
+* make F-Droid recognize fdroid nightly URLs from GitLab
+
+### 1.2-alpha1 (2018-04-06)
+
+* fix Privileged Extension install with apps with uses-permision-sdk-23
+
+* automatically trim or delete cache when storage space is low
+
+* improved performance on low memory devices
+
+* make all downloads respect "Only on Wi-Fi" preference
+
+### 1.2-alpha0 (2018-03-30)
+
+* add custom mirrors to any repo by clicking links, scanning QR codes, etc.
+
+* reduce memory usage when device is running low
+
+### 1.1 (2018-03-21)
+
+* fix some problems with items Updates reappearing
+
+* fix failback install method when permissions aren't in sync #1310
+
+### 1.1-alpha4 (2018-03-09)
+
+* fix the most popular ACRA crash reports
+
+* UI layout improvements
+
+* warn users when scanning QR with camera without autofocus
+
+### 1.1-alpha3 (2018-02-13)
+
+* add sort button to Search view: alpha or most recent
+
+* fix bugs: #1305 #1306 #1325
+
+* add more detail to ACRA crash reports
+
+### 1.1-alpha2 (2018-02-06)
+
+* reload index after system locale change or OS upgrade
+
+* add "panic responder" support
+
+### 1.1-alpha1 (2018-01-26)
+
+* provision new repos via a provisioning file
+
+* "Android App Links" handling aka "Digital Asset Links"
+
+* new privacy prefs: disable screenshots; exit on panic
+
+### 1.1-alpha0 (2017-11-09)
+
+* automatically choose between official repo mirrors
+
+* fullscreen, swipeable app screenshot navigation
+
+* new preference to prevent screenshots/recents
+
+* fix crasher bug #1203
+
+### 1.0.1 (2017-10-23)
+
+* fixed index update failure on Android 5.0 (#1014)
+
+### 1.0 (2017-10-10)
+
+* Completely overhauled workflow for updating apps
+
+* Fully translatable app summaries and descriptions
+
+* "What's New" section to show changes in current release
+
+* Screenshots and feature graphics
+
+* Support installing media, OTA, ZIP, etc. files
+
+* Improved protection against tracking (HTTP ETag, TLS, etc.)
+
+* Fully background updates with Privileged Extension
+
+* Highlight donations to app developers
+
+* Much faster index updates
+
+### 1.0-alpha5 (2017-10-04)
+
+* Fix bug that prevented translations from showing up on Android >= 7.0 (#987)
+
+* Fix DB upgrade crash from 1.0-alpha3 --> 1.0-alpha4 (#1181)
+
+### 1.0-alpha4 (2017-09-27)
+
+* Added swipe gestures to the Updates tab
+
+* Display warnings with actions in Updates tab for KnownVulns
+
+* Translation updates
+
+* Dark UI fixes
+
+### 1.0-alpha3 (2017-09-12)
+
+* Big UI performance improvements, especially with archive enabled
+
+* Fixed crasher bugs
+
+### 1.0-alpha2 (2017-09-04)
+
+* Prevent HTTP ETag from being used as a tracking cookie
+
+* Improved screenshots layout
+
+* Properly clean up temp and cached files
+
+* Dark mode fixes
+
+### 1.0-alpha1 (2017-07-18)
+
+* Fix bug removing apps from repos (#568)
+
+* Much faster index updates
+
+### 1.0-alpha0 (2017-07-08)
+
+* Support installing media, OTA, ZIP, etc. files
+
+* Fully support APKs signed by multiple signing keys
+
+* Tibetan translation
+
+* Remove related apps and categories after disabling repo
+
+### 0.104 (2017-06-16)
+
+* Support apps with APKs signed by more than one key
+
+* Fix F-Droid update notifications that never go away
+
+### 0.103.2 (2017-05-31)
+
+* Fix problematic updates and notifications (#1013)
+
+* Language and stability updates
+
+### 0.103.1 (2017-05-12)
+
+* Various stability fixes
+
+* Bits of text no longer randomly switch to English
+
+* Fix send F-Droid via Bluetooth on Android 7.x
+
+### 0.103 (2017-05-02)
+
+* Complete overhaul of the user experience
+
+* Complete support for localization, including app descriptions
+
+* Support for screenshots, graphics, and "What's New" texts
+
+* Stable support for F-Droid Privileged Extension
+
+### 0.102.3 (2017-04-01)
+
+* Fix issue with installing from the wrong repo (#909)
+
+* Allow F-Droid to update Privileged Extension (#911)
+
+* Ignore errors that are likely due to filesystem corruption (#855)
+
+* Improve installs/uninstalls with Privileged Extension on 7.x
+
+### 0.102.2 (2017-03-14)
+
+* Fix installing with Privileged Extension on 7.x
+
+* Detect app updates via sytem OTA updates (#819)
+
+### 0.102.1 (2017-02-24)
+
+* Detect installed/uninstalled state more reliably (#854)
+
+* Ensure dark theme gets applied everywhere (#750)
+
+### 0.102 (2016-11-28)
 
 * Optionally keep install history
 
@@ -14,7 +596,7 @@
 
 * Support for Android 2.2 is dropped, 2.3.3 or later is now required
 
-* Fixed APK Cache bugs, requiring the cache time be reset to 1 day
+* Fixed APK Cache bugs, requiring the cache time be reset to one day
 
 * Use Privileged Extension by default if installed
 
@@ -28,7 +610,7 @@
 
 * Fix crash if an app has a short description
 
-* Fix background crash in the wifi state change swap service
+* Fix background crash in the Wi-Fi state change swap service
 
 * Fix crash if there is a problem listing the cached files to delete
 
@@ -78,7 +660,7 @@
 
 * Fix crash when adding malformed URIs as repos
 
-* Fix Android.mk build when the output dir is a relative path
+* Fix Android.mk build when the output dir. is a relative path
 
 ### 0.98 (2016-02-01)
 
@@ -142,7 +724,7 @@
 
 * Move the repo index update to a notification
 
-* Handle apk downloads without a dialog
+* Handle APK downloads without a dialog
 
 * Don't let users try to uninstall system apps that haven't been updated
 
@@ -185,14 +767,14 @@
   and now easy to set up with root privileges
 
 * Speed up and simplify repo update process by streaming the data out of the
-  jar file directly
+  JAR file directly
 
 * Can now manually add swap repo via "Repositories" screen
 
 * Using NFC during swap now initiates a proper swap, rather than redirecting to
   the "Repositories" screen
 
-* Drop ant support to greatly simplify the build process and its maintenance
+* Drop Ant support to greatly simplify the build process and its maintenance
 
 ### 0.92 (2015-06-08)
 
@@ -200,7 +782,7 @@
 
 * Update Universal-Image-Loader to 1.9.4
 
-* Make Apk downloads progress be measured in kilobytes instead of bytes
+* Make APK downloads progress be measured in kilobytes instead of bytes
 
 * Add missing Sardinian language to the preferences
 
@@ -213,9 +795,9 @@
   since it's not needed to use our own external app directory
 
 * Fix a crash occuring if the user triggered a repo update that got rid of
-  more than 450 apks at once
+  more than 450 APKs at once
 
-* Properly cache apk files on the SD card if configured this way
+* Properly cache APK files on the SD card if configured this way
 
 * Drop support for unsigned repos in favour of signed ones and TOFU support
 
@@ -229,7 +811,7 @@
 
 * Don't crash if links on descriptions cannot be handled by any application
 
-* Support building as part of a ROM via an Android.mk using gradle
+* Support building as part of a ROM via an Android.mk using Gradle
 
 ### 0.88 (2015-04-28)
 
@@ -239,7 +821,7 @@
 * User interface language can now be changed from inside the F-Droid
   preferences without changing the system language (locale)
 
-* Fix an issue where xml files could pile up in the data directory
+* Fix an issue where XML files could pile up in the data directory
 
 * Improve app and search link handling while also adding supporting for Amazon
   and Google Play links
@@ -249,12 +831,12 @@
 
 * Show a message to the user when there are no apps to display.
 
-* Swapping is now two way. Connecting to a swap on one device will
-  initiate a swap on the other device.
+* Swapping is now two-way. Connecting to a swap on one device will
+  initiate a swap on the other device
 
 * Small UI fixes to avoid overlapping text and improve app version ellipsizing
 
-* Split up search terms when querying the app database - "fire fox" now
+* Split up search terms when querying the app database—"fire fox" now
   matches FireFox
 
 * Ignore trailing paces in search terms introduced by some input methods
@@ -271,7 +853,7 @@
 
 * Fix issue that caused the installed state label to sometimes not be updated
 
-* Support for future devices with more than two cpu architectures
+* Support for future devices with more than two CPU architectures
 
 * Show when packages are installed but not via F-Droid (mismatching signature)
 
@@ -300,7 +882,7 @@
 
 * Update Universal-Image-Loader and the Support libraries
 
-* Switch the directory structure to better suit building with gradle
+* Switch the directory structure to better suit building with Gradle
 
 * Translation updates
 
@@ -322,14 +904,14 @@
 * HTTP Proxy support in Preferences
 
 * Directly send installed apps to other devices via Bluetooth and Android Beam
-  (NFC+Bluetooth), also compatible with Samsung/HTC S-Beam
+  (NFC+Bluetooth), also compatible with Samsung/HTC S Beam
 
 * Initial support for root and system installers, allowing the client to
-  install apks directly on its own
+  install APKs directly on its own
 
 * Increased performance when updating from repository with many apps
 
-* Switch to Appcompat from the Support library
+* Switch to AppCompat from the Support library
 
 * Fix some crashes
 
@@ -368,7 +950,7 @@
 * Send F-Droid via Bluetooth to any device that supports receiving APKs via
   Bluetooth (stock Android blocks APKs, most ROMs allow them)
 
-* NFC support: beam repo configs from the repo detail view (Android 4.0+),
+* NFC support: Beam repo configs from the repo detail view (Android 4.0+),
   beam the F-Droid.apk from F-Droid's main screen (Android 4.1+)
 
 * Support for repositories using self-signed HTTPS certificates through
@@ -382,7 +964,7 @@
 
 * Major internal changes to enable F-Droid to handle repos with thousands
   of apps without slowing down too much. These internal changes will also make
-  new features easier to implement.
+  new features easier to implement
 
 * Various fixes to layout issues introduced in 0.58
 
@@ -396,7 +978,7 @@
 
 * Tweaked some layouts, especially the app lists and their compact layout
 
-* App lists now show more useful version information: current version names,
+* App lists now show more useful version information: Current version names,
   rather than number of versions available
 
 * Reduce scroll lag in app lists by caching views in a ViewHolder
@@ -412,21 +994,21 @@
   can see what the checkbox preferences actually mean and what the edit and
   list preferences are set at
 
-* Support for dogecoin donation method added (wow)
+* Support for Dogecoin donation method added (wow)
 
-* Don't keep app icons older than 30 days on disc cache
+* Don't keep app icons older than 30 days in disc cache
 
-* Always include incompatible apks in memory to avoid issues with apps
-  seemingly not having any apks available
+* Always include incompatible APKs in memory to avoid issues with apps
+  seemingly not having any APKs available
 
 * Fixed a crash when trying to access a non-existing app
 
 * F-Droid registers with Android to receive F-Droid URIs https://\*/fdroid/repo
   and fdroidrepos://
 
-* support including signing key fingerprint in repo URIs
+* Support including signing key fingerprint in repo URIs
 
-* when adding new repos that include the fingerprint, check to see whether
+* When adding new repos that include the fingerprint, check to see whether
   that repo exists in F-Droid already, and if the fingerprints match
 
 * Other minor bug fixes
@@ -437,12 +1019,12 @@
 
 * Fixed problems with category selection and permission lists on Android 2.X devices.
 
-* Lots of translation updates, including new Norwegian translation.
+* Lots of translation updates, including new Norwegian translation
 
 ### 0.54 (2013-11-05)
 
 * New options on the App Details screen to ignore all future updates for that
-  particular app, or ignore just the current update.
+  particular app, or ignore just the current update
 
 * Apps with Anti-features are no longer hidden, and the corresponding
   preferences to unhide them are removed. Instead they are clearly marked on the
@@ -451,7 +1033,7 @@
 * Apps with incompatible native code architecture requirements are now correctly
   filtered.
 
-* A bug that prevented update notifications from appearing has been fixed.
+* A bug that prevented update notifications from appearing has been fixed
 
 * Theming support, with Light and Dark themes.
 
@@ -460,29 +1042,29 @@
   installation.
 
 * All app donation options have been grouped into a submenu, and Litecoin
-  donation support has been added.
+  donation support has been added
 
-* App filter settings now take effect immediately.
+* App filter settings now take effect immediately
 
-* Apk native code ABIs are now shown in expert mode.
+* APK native code ABIs are now shown in expert mode
 
-* Search uris for market://search and fdroid.search: are  now handled.
+* Search URIs for market://search and fdroid.search: are now handled
 
-* A problem with ActionBar Up navigation on some devices has been fixed.
+* A problem with ActionBar Up navigation on some devices has been fixed
 
-* Other minor bug fixes, and adjustments to spacings and layouts.
+* Other minor bug fixes, and adjustments to spacings and layouts
 
-* Lots of translation updates.
+* Lots of translation updates
 
 ### 0.50 (2013-08-20)
 
 * New basic app sharing functionality
 
-* Handle f-droid.org web repo as well as market:// app uris
+* Handle f-droid.org web repo as well as market:// app URIs
 
 * Search by just typing on main screen and search results screen
 
-* Flattr and Bitcoin donation methods added
+* Flattr and bitcoin donation methods added
 
 * Noticeable speedups when returning from installs and uninstalls
 

CONTRIBUTING.md

@@ -26,14 +26,16 @@ track of modifications and fuzzy translations. Applying translations manually
 skips all of the fixes and checks, and overrides the fuzzy state of strings.
 
 Note that you cannot change the English strings on Weblate. If you have any
-suggestions on how to improve them, open a merge request like you would if you
-were making code changes. This way the changes can be reviewed before the
-source strings on Weblate are changed.
+suggestions on how to improve them, open an issue or merge request like you
+would if you were making code changes. This way the changes can be reviewed
+before the source strings on Weblate are changed.
+
 
 ## Code Style
 
-We follow the [Android Java style](https://source.android.com/source/code-style.html).
-Some key points:
+We follow the default Android Studio code formatter (e.g. `Ctrl-Alt-L`).  This
+should be more or less the same as [Android Java
+style](https://source.android.com/source/code-style.html).  Some key points:
 
 * Four space indentation
 * UTF-8 source files
@@ -45,65 +47,35 @@ Some key points:
 * Braces are always used after if, for and while
 
 The current code base doesn't follow it entirely, but new code should follow
-it. We enforce some of these, but not all, via checkstyle.
+it. We enforce some of these, but not all, via `./gradlew checkstyle`.
 
-## Debugging
-
-To get all the logcat messages by F-Droid, you can run:
-
-    adb logcat | grep `adb shell ps | grep org.fdroid.fdroid | cut -c10-15`
-
-## Building tips
-
-* Use gradle with `--daemon` if you are going to build F-Droid multiple times.
-* If you get a message like `Could not find com.android.support:support-...`,
-  make sure that you have the latest Android support maven repository.
-* When building as part of AOSP with `Android.mk`, make sure you have a
-  recent version of Gradle installed as `gradlew` will not be used.
 
 ## Running the test suite
 
+Before pushing commits to a merge request, make sure this passes:
+
+    ./gradlew checkstyle pmd lint
+
 In order to run the F-Droid test suite, you will need to have either a real device
 connected via `adb`, or an emulator running. Then, execute the following from the
 command line:
 
     ./gradlew check
 
-Note that the CI already runs the tests on an emulator, so you don't
-necessarily have to do this yourself if you open a merge request as the tests
-will get run.
+Many important tests require a device or emulator, but do not work in GitLab CI.
+That mean they need to be run locally, and that is usually easiest in Android
+Studio rather than the command line.
 
-## Versioning
+For a quick way to run a specific JUnit/Robolectric test:
 
-Each stable version follows the `X.Y` pattern. Hotfix releases - i.e. when a
-stable has an important bug that needs immediate fixing - will follow the
-`X.Y.Z` pattern.
+    ./gradlew testFullDebugUnitTest --tests *LocaleSelectionTest*
 
-Before each stable release, a number of alpha releases will be released. They
-will follow the pattern `X.Y-alphaN`, where `N` is the current alpha number.
-These will usually include changes and new features that have not been tested
-enough for a stable release, so use at your own risk. Testers and reporters
-are very welcome.
+For a quick way to run a specific emulator test:
 
-The version codes use a number of digits per each of these keys: `XXXYYYZNN`.
-So for example, 1.3.1 would be `1003150` and 0.95-alpha13 would be `95013`
-(leading zeros are omitted).
+	./gradlew connectedFullDebugAndroidTest \
+        -Pandroid.testInstrumentationRunnerArguments.class=org.fdroid.fdroid.MainActivityExpressoTest
 
-Note that we use a trailing `50` for actual stable releases, so alphas are
-limited to `-alpha49`.
 
-This is an example of a release process for **0.95**:
+## Making releases
 
-* We are currently at stable **0.94**
-* **0.95-alpha1** is released
-* **0.95-alpha2** is released
-* **0.95-alpha3** is released
-* `stable-v0.95` is branched and frozen
-* **0.95** is released
-* A bug is reported on the stable release and fixed
-* **0.95.1** is released with only that fix
-
-As soon as a stable is tagged, master will move on to `-alpha0` on the next
-version. This is a temporary measure - until `-alpha1` is released - so that
-moving from stable to master doesn't require a downgrade. `-alpha0` versions
-will not be tagged nor released.
+See https://gitlab.com/fdroid/wiki/-/wikis/Internal/Release-Process#fdroidclient

FUNDING.yml

@@ -0,0 +1,11 @@
+---
+liberapay: F-Droid-Data
+open_collective: F-Droid
+github:
+    - f-droid
+    - eighthave
+custom:
+    - https://f-droid.org/donate/
+    - https://www.hellotux.com/f-droid
+    - https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=E2FCXCT6837GL
+    - https://blockchain.info/address/15u8aAPK4jJ5N8wpWJ5gutAyyeHtKX5i18

README.md

@@ -1,6 +1,6 @@
 # F-Droid Client
 
-[![build status](https://gitlab.com/fdroid/fdroidclient/badges/master/build.svg)](https://gitlab.com/fdroid/fdroidclient/builds)
+[![build status](https://gitlab.com/fdroid/fdroidclient/badges/master/pipeline.svg)](https://gitlab.com/fdroid/fdroidclient/-/jobs)
 [![Translation status](https://hosted.weblate.org/widgets/f-droid/-/svg-badge.svg)](https://hosted.weblate.org/engage/f-droid/)
 
 Client for [F-Droid](https://f-droid.org), the Free Software repository system
@@ -23,7 +23,7 @@ issues, translate the app into your language or help with development.
 ## IRC
 
 We are on `#fdroid` and `#fdroid-dev` on Freenode. We hold weekly dev meetings
-on `#fdroid-dev` on Tuesdays at 20h UTC, which usually last half an hour.
+on `#fdroid-dev` on Thursdays at 11:30h UTC, which usually last half an hour.
 
 ## FAQ
 
@@ -38,9 +38,7 @@ to what Google Play does.
 
 This used to be the case, but no longer is. Now the [Privileged
 Extension](https://gitlab.com/fdroid/privileged-extension) is the one that should be placed in
-the system. It can be bundled with a ROM or installed via a zip, or
-alternatively F-Droid can install it as a system app using root.
-
+the system. It can be bundled with a ROM or installed via a zip.
 ## License
 
 This program is Free Software: You can use, study share and improve it at your
@@ -59,3 +57,11 @@ Other icons are from the
 [Material Design Icon set](https://github.com/google/material-design-icons)
 released under an
 [Attribution 4.0 International license](https://creativecommons.org/licenses/by/4.0/).
+
+
+## Translation
+
+Everything can be translated.  See
+[Translation and Localization](https://f-droid.org/docs/Translation_and_Localization)
+for more info.
+[![translation status](https://hosted.weblate.org/widgets/f-droid/-/f-droid/multi-auto.svg)](https://hosted.weblate.org/engage/f-droid/?utm_source=widget)

app/build.gradle

@@ -1,182 +1,99 @@
 apply plugin: 'com.android.application'
-apply plugin: 'witness'
 apply plugin: 'checkstyle'
 apply plugin: 'pmd'
 
-/* gets the version name from the latest Git tag, stripping the leading v off */
+/* gets the version name from the latest Git tag */
 def getVersionName = { ->
     def stdout = new ByteArrayOutputStream()
     exec {
         commandLine 'git', 'describe', '--tags', '--always'
         standardOutput = stdout
     }
-    return stdout.toString().trim().substring(1)
+    return stdout.toString().trim()
 }
 
-repositories {
-    jcenter()
-}
+def isCi = "true" == System.getenv("CI")
+def preDexEnabled = "true" == System.getProperty("pre-dex", "true")
 
-dependencies {
-    compile 'com.android.support:support-v4:24.2.1'
-    compile 'com.android.support:appcompat-v7:24.2.1'
-    compile 'com.android.support:support-annotations:24.2.1'
-
-    compile 'com.nostra13.universalimageloader:universal-image-loader:1.9.5'
-    compile 'com.google.zxing:core:3.2.1'
-    compile 'eu.chainfire:libsuperuser:1.0.0.201602271131'
-    compile 'cc.mvdan.accesspoint:library:0.2.0'
-    compile 'info.guardianproject.netcipher:netcipher:2.0.0-alpha1'
-    compile 'commons-io:commons-io:2.5'
-    compile 'commons-net:commons-net:3.5'
-    compile 'org.openhab.jmdns:jmdns:3.4.2'
-    compile('ch.acra:acra:4.9.1') {
-        exclude module: 'support-v4'
-        exclude module: 'support-annotations'
-    }
-    compile 'io.reactivex:rxjava:1.1.0'
-    compile 'io.reactivex:rxandroid:0.23.0'
-
-    testCompile 'junit:junit:4.12'
-
-    testCompile "org.robolectric:robolectric:3.1.2"
-
-    testCompile "org.mockito:mockito-core:1.10.19"
-
-    androidTestCompile 'com.android.support:support-annotations:24.2.1'
-    androidTestCompile 'com.android.support.test:runner:0.5'
-    androidTestCompile 'com.android.support.test:rules:0.5'
-}
-
-if (!hasProperty('sourceDeps')) {
-
-    repositories {
-        // This is here until we sort out all dependencies from mavenCentral/jcenter. Once all of
-        // the dependencies below have been sorted out, this can be removed.
-        flatDir {
-            dirs 'libs/binaryDeps'
-        }
-    }
-
-    dependencies {
-        compile 'com.madgag.spongycastle:pkix:1.53.0.0'
-        compile 'com.madgag.spongycastle:prov:1.53.0.0'
-        compile 'com.madgag.spongycastle:core:1.53.0.0'
-
-        // Upstream doesn't have a binary on mavenCentral/jcenter yet:
-        // https://github.com/kolavar/android-support-v4-preferencefragment/issues/13
-        compile(name: 'support-v4-preferencefragment-release', ext: 'aar')
-
-        // Fork for F-Droid, including support for https. Not merged into upstream
-        // yet (seems to be a little unsupported as of late), so not using mavenCentral/jcenter.
-        compile(name: 'nanohttpd-2.1.0')
-
-        // Upstream doesn't have a binary on mavenCentral, and it is an SVN repo on
-        // Google Code.  We include this code directly in this repo, and have made
-        // modifications that should be pushed to anyone who wants to maintain it.
-        compile(name: 'zipsigner')
-    }
-
-    // Only do the libraries imported from maven repositories. Our own libraries
-    // (like privileged-api-lib) and the prebuilt jars already checked into the
-    // source code don't need to be here.
-    // generate using: `gradle -q calculateChecksums | sort -V`
-    dependencyVerification {
-        verify = [
-                'cc.mvdan.accesspoint:library:0837b38adb48b66bb1385adb6ade8ecce7002ad815c55abf13517c82193458ea',
-                'ch.acra:acra:d2762968c448757a7d6acc9f141881d9632f664988e9723ece33b5f7c79f3bc9',
-                'commons-io:commons-io:a10418348d234968600ccb1d988efcbbd08716e1d96936ccc1880e7d22513474',
-                'commons-net:commons-net:c25b0da668b3c5649f002d504def22d1b4cb30d206f05428d2fe168fa1a901c2',
-                'com.android.support:animated-vector-drawable:5aa30f578e1daefb26bef0ce06414266fbb4cdf5d4259f42a92c7bd83dcd81b4',
-                'com.android.support:appcompat-v7:ead7ac8011fb40676df8adc2856cae934edab55fc4444654c0ac6ea443736088',
-                'com.android.support:support-annotations:1e4d471c5378b283d95abfb128e7ed3c6b3cb19bb6f0c317a9b75e48e99365ff',
-                'com.android.support:support-compat:8e4fe0078b68073e8f5bcb52aa5b6407fd456d47c51aa0f8e8d1e23c69da06c1',
-                'com.android.support:support-core-ui:ecc9184b7f438980e1c4a08b089d62dbc53ff90091f442d91fec27322a02c73c',
-                'com.android.support:support-core-utils:0fbc508e41dd6e8c634f310ee88452aaf8f48b6a843a369b115130b80d2fc05f',
-                'com.android.support:support-fragment:d8030f0bf0f64214a29dc4e14d5ccd225e59f66ed15eb37f3a5022e773dd1fda',
-                'com.android.support:support-media-compat:fa29a23eadd685631584b2c0c624a36e3bb79a33e257b00304501ad682fa2be3',
-                'com.android.support:support-v4:cac2956f5c4bb363cc0ba824ac16ea2a687d1c305d434416a34772a5f9375ed7',
-                'com.android.support:support-vector-drawable:6ee37a7f7b93c1df1294e6f6f97df3724ac989fcda0549faf677001085330548',
-                'com.google.zxing:core:b4d82452e7a6bf6ec2698904b332431717ed8f9a850224f295aec89de80f2259',
-                'com.madgag.spongycastle:core:9b6b7ac856b91bcda2ede694eccd26cefb0bf0b09b89f13cda05b5da5ff68c6b',
-                'com.madgag.spongycastle:pkix:6aba9b2210907a3d46dd3dcac782bb3424185290468d102d5207ebdc9796a905',
-                'com.madgag.spongycastle:prov:029f26cd6b67c06ffa05702d426d472c141789001bcb15b7262ed86c868e5643',
-                'com.nostra13.universalimageloader:universal-image-loader:dbd5197ffec3a8317533190870a7c00ff3750dd6a31241448c6a5522d51b65b4',
-                'eu.chainfire:libsuperuser:018344ff19ee94d252c14b4a503ee8b519184db473a5af83513f5837c413b128',
-                'info.guardianproject.netcipher:netcipher:eeeb5d0d95ccfe176b4296cbd71a9a24c6efb0bab5c4025a8c6bc36abdddfc75',
-                'io.reactivex:rxandroid:35c1a90f8c1f499db3c1f3d608e1f191ac8afddb10c02dd91ef04c03a0a4bcda',
-                'io.reactivex:rxjava:2c162afd78eba217cdfee78b60e85d3bfb667db61e12bc95e3cf2ddc5beeadf6',
-                'org.openhab.jmdns:jmdns:7a4b34b5606bbd2aff7fdfe629edcb0416fccd367fb59a099f210b9aba4f0bce',
-        ]
-    }
-
-} else {
-
-    logger.info "Setting up *source* dependencies for F-Droid (because you passed in the -PsourceDeps argument to gradle while building)."
-
-    dependencies {
-        compile(project(':extern:support-v4-preferencefragment')) {
-            exclude module: 'support-v4'
-        }
-        compile project(':extern:nanohttpd:core')
-        compile project(':extern:zipsigner')
-    }
-
-    task binaryDeps(type: Copy, dependsOn: ':app:prepareReleaseDependencies') {
-
-        enabled = project.hasProperty('sourceDeps')
-        description = "Copies .jar and .aar files from subproject dependencies in extern/ to app/libs. Requires the sourceDeps property to be set (\"gradle -PsourceDeps binaryDeps\")"
-
-        from('../extern/') {
-            include 'support-v4-preferencefragment/build/outputs/aar/support-v4-preferencefragment-release.aar'
-            include 'nanohttpd/core/build/libs/nanohttpd-2.1.0.jar'
-            include 'zipsigner/build/libs/zipsigner.jar'
-        }
-
-        into 'libs/binaryDeps'
-        includeEmptyDirs false
-
-        eachFile { FileCopyDetails details ->
-            // Don't copy to a sub folder such as libs/binaryDeps/Project/build/outputs/aar/project.aar, but
-            // rather libs/binaryDeps/project.aar.
-            details.path = details.name
-        }
-    }
-}
+def fullApplicationId = "org.fdroid.fdroid"
+def basicApplicationId = "org.fdroid.basic"
+// yes, this actually needs both quotes https://stackoverflow.com/a/41391841
+def privilegedExtensionApplicationId = '"org.fdroid.fdroid.privileged"'
 
 android {
-    compileSdkVersion 24
-    buildToolsVersion '25.0.0'
-    useLibrary 'org.apache.http.legacy'
+    compileSdkVersion 30
+
+    defaultConfig {
+        versionCode 1013001
+        versionName getVersionName()
+
+        testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
+        minSdkVersion 24
+        //noinspection ExpiredTargetSdkVersion
+        targetSdkVersion 28
+        /*
+          The Android Testing Support Library collects analytics to continuously improve the testing
+          experience. More specifically, it uploads a hash of the package name of the application
+          under test for each invocation. If you do not wish to upload this data, you can opt-out by
+          passing the following argument to the test runner: disableAnalytics "true".
+         */
+        testInstrumentationRunnerArguments disableAnalytics: 'true'
+        vectorDrawables.useSupportLibrary = true
+    }
 
     buildTypes {
         // use proguard on debug too since we have unknowingly broken
         // release builds before.
         all {
             minifyEnabled true
-            useProguard true
             shrinkResources true
+            buildConfigField "String", "PRIVILEGED_EXTENSION_PACKAGE_NAME", privilegedExtensionApplicationId
+            buildConfigField "String", "ACRA_REPORT_EMAIL", '"reports@f-droid.org"' // String needs both quotes
             proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
             testProguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro', 'src/androidTest/proguard-rules.pro'
         }
+        debug {
+            applicationIdSuffix ".debug"
+            resValue "string", "applicationId", fullApplicationId + applicationIdSuffix
+            versionNameSuffix "-debug"
+            println 'buildTypes.debug defaultConfig.versionCode ' + defaultConfig.versionCode
+        }
+    }
+
+    flavorDimensions "base"
+    productFlavors {
+        full {
+            dimension "base"
+            applicationId fullApplicationId
+            resValue "string", "applicationId", fullApplicationId
+        }
+        basic {
+            dimension "base"
+            applicationId basicApplicationId
+            resValue "string", "applicationId", basicApplicationId
+        }
     }
 
     compileOptions {
         compileOptions.encoding = "UTF-8"
-
-        // Use Java 1.7, requires minSdk 8
-        sourceCompatibility JavaVersion.VERSION_1_7
-        targetCompatibility JavaVersion.VERSION_1_7
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
     }
 
-    defaultConfig {
-        versionCode 102002
-        versionName getVersionName()
-        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    aaptOptions {
+        cruncherEnabled = false
+    }
+
+    dexOptions {
+        // Improve build server performance by allowing disabling of pre-dexing
+        // see http://tools.android.com/tech-docs/new-build-system/tips#TOC-Improving-Build-Server-performance
+        // Skip pre-dexing when running on CI or when disabled via -Dpre-dex=false.
+        preDexLibraries = preDexEnabled && !isCi
     }
 
     testOptions {
         unitTests {
+            includeAndroidResources = true
             // prevent tests from dying on android.util.Log calls
             returnDefaultValues = true
             all {
@@ -185,6 +102,10 @@ android {
                     events "skipped", "failed", "standardOut", "standardError"
                     showStandardStreams = true
                 }
+                systemProperty 'robolectric.dependency.repo.url', 'https://repo1.maven.org/maven2'
+
+                // hack to avoid memory leak crashes
+                forkEvery = 1
             }
         }
     }
@@ -207,13 +128,7 @@ android {
         xmlReport false
         textReport false
 
-        // Our translations are crowd-sourced
-        disable 'MissingTranslation'
-
-        // to make CI fail on errors until this is fixed https://github.com/rtyley/spongycastle/issues/7
-        warning 'InvalidPackage'
-
-        error 'AppCompatMethod', 'NestedScrolling', 'StringFormatCount', 'UnsafeProtectedBroadcastReceiver'
+        lintConfig file("lint.xml")
     }
 
     packagingOptions {
@@ -226,6 +141,59 @@ android {
     }
 }
 
+dependencies {
+    implementation 'androidx.appcompat:appcompat:1.3.0'
+    implementation 'androidx.preference:preference:1.1.1'
+    implementation 'androidx.gridlayout:gridlayout:1.0.0'
+    implementation 'androidx.recyclerview:recyclerview:1.1.0'
+    implementation 'androidx.cardview:cardview:1.0.0'
+    implementation 'androidx.vectordrawable:vectordrawable:1.1.0'
+    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
+    implementation 'androidx.palette:palette:1.0.0'
+    implementation 'androidx.work:work-runtime:2.4.0'
+
+    implementation 'com.google.android.material:material:1.3.0'
+
+    implementation 'com.nostra13.universalimageloader:universal-image-loader:1.9.5'
+    implementation 'com.google.zxing:core:3.3.3'
+    implementation 'info.guardianproject.netcipher:netcipher:2.2.0-alpha'
+    implementation 'info.guardianproject.panic:panic:1.0'
+    implementation 'commons-io:commons-io:2.6'
+    implementation 'commons-net:commons-net:3.6'
+    implementation 'ch.acra:acra:4.9.1'
+    implementation 'com.hannesdorfmann:adapterdelegates3:3.0.1'
+
+    implementation 'io.reactivex.rxjava3:rxandroid:3.0.0'
+    implementation 'io.reactivex.rxjava3:rxjava:3.0.9'
+
+    implementation 'com.fasterxml.jackson.core:jackson-core:2.11.1'
+    implementation 'com.fasterxml.jackson.core:jackson-annotations:2.11.1'
+    implementation 'com.fasterxml.jackson.core:jackson-databind:2.11.1'
+
+    implementation 'org.bouncycastle:bcprov-jdk15on:1.65'
+    fullImplementation 'org.bouncycastle:bcpkix-jdk15on:1.65'
+    fullImplementation 'cc.mvdan.accesspoint:library:0.2.0'
+    fullImplementation 'org.jmdns:jmdns:3.5.5'
+    fullImplementation 'org.nanohttpd:nanohttpd:2.3.1'
+
+    testImplementation 'androidx.test:core:1.3.0'
+    testImplementation 'junit:junit:4.13.1'
+    testImplementation 'org.robolectric:robolectric:4.3'
+    testImplementation 'org.mockito:mockito-core:3.3.3'
+    testImplementation 'org.hamcrest:hamcrest:2.2'
+    testImplementation 'org.bouncycastle:bcprov-jdk15on:1.65'
+
+    androidTestImplementation 'androidx.arch.core:core-testing:2.1.0'
+    androidTestImplementation 'androidx.test:core:1.3.0'
+    androidTestImplementation 'androidx.test:runner:1.3.0'
+    androidTestImplementation 'androidx.test:rules:1.3.0'
+    androidTestImplementation 'androidx.test:monitor:1.3.0'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.2'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'
+    androidTestImplementation 'androidx.test.uiautomator:uiautomator:2.2.0'
+    androidTestImplementation 'androidx.work:work-testing:2.4.0'
+}
+
 checkstyle {
     toolVersion = '7.2'
 }
@@ -239,7 +207,7 @@ task checkstyle(type: Checkstyle) {
 }
 
 pmd {
-    toolVersion = '5.5.1'
+    toolVersion = '6.20.0'
     consoleOutput = true
 }
 
@@ -260,35 +228,3 @@ task pmdTest(type: Pmd) {
 }
 
 task pmd(dependsOn: [pmdMain, pmdTest]) {}
-
-// This person took the example code below from another blogpost online, however
-// I lost the reference to it:
-// http://stackoverflow.com/questions/23297562/gradle-javadoc-and-android-documentation
-android.applicationVariants.all { variant ->
-
-    task("generate${variant.name}Javadoc", type: Javadoc) {
-        title = "$name $version API"
-        description "Generates Javadoc for F-Droid."
-        source = variant.javaCompile.source
-
-        def sdkDir
-        Properties properties = new Properties()
-        File localProps = project.rootProject.file('local.properties')
-        if (localProps.exists()) {
-            properties.load(localProps.newDataInputStream())
-            sdkDir = properties.getProperty('sdk.dir')
-        } else {
-            sdkDir = System.getenv('ANDROID_HOME')
-        }
-        if (!sdkDir) {
-            throw new ProjectConfigurationException("Cannot find android sdk. Make sure sdk.dir is defined in local.properties or the environment variable ANDROID_HOME is set.", null)
-        }
-
-        ext.androidJar = "${sdkDir}/platforms/${android.compileSdkVersion}/android.jar"
-        classpath = files(variant.javaCompile.classpath.files) + files(ext.androidJar)
-        options.links("http://docs.oracle.com/javase/7/docs/api/");
-        options.links("http://d.android.com/reference/");
-        exclude '**/BuildConfig.java'
-        exclude '**/R.java'
-    }
-}

app/lint.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<lint>
+    <!-- Our translations are crowd-sourced -->
+    <issue id="MissingTranslation" severity="ignore"/>
+
+    <!-- to make CI fail on errors until this is fixed
+         https://github.com/rtyley/spongycastle/issues/7 -->
+    <issue id="InvalidPackage" severity="warning"/>
+
+    <issue id="ImpliedQuantity" severity="error"/>
+    <issue id="DefaultLocale" severity="error"/>
+    <issue id="SimpleDateFormat" severity="error"/>
+    <issue id="NewApi" severity="error"/>
+    <issue id="InlinedApi" severity="error"/>
+
+    <!-- These are important to us, so promote from warning to error -->
+    <issue id="UnusedResources" severity="error">
+        <ignore path="src/main/res/drawable/category_**.png" />
+        <ignore path="src/main/res/values/dimens.xml"/>
+        <ignore path="src/main/res/values/styles.xml"/>
+        <ignore path="src/full/res/values/styles.xml"/>
+        <!-- keep a single strings.xml for all build flavors -->
+        <ignore path="src/main/res/values**/strings.xml"/>
+    </issue>
+    <issue id="AppCompatMethod" severity="error"/>
+    <issue id="NestedScrolling" severity="error"/>
+    <issue id="Typos" severity="error"/>
+    <issue id="StringFormatCount" severity="error"/>
+    <issue id="UnsafeProtectedBroadcastReceiver" severity="error"/>
+    <issue id="GetInstance" severity="error"/>
+    <issue id="PackageManagerGetSignatures" severity="error"/>
+    <issue id="HardwareIds" severity="error"/>
+    <issue id="TrustAllX509TrustManager" severity="error">
+      <!-- these come from included libraries -->
+        <ignore path="org/apache/commons/net/ftp/FTPSTrustManager.class"/>
+        <ignore path="org/bouncycastle/est/jcajce/JcaJceUtils$1.class"/>
+        <ignore path="org/bouncycastle/est/jcajce/JcaJceUtils$2.class"/>
+        <ignore path="org/apache/commons/net/util/TrustManagerUtils$TrustManager.class"/>
+    </issue>
+
+    <issue id="PluralsCandidate" severity="error"/>
+    <issue id="HardcodedText" severity="error"/>
+    <issue id="RtlCompat" severity="error"/>
+    <issue id="RtlEnabled" severity="error"/>
+
+    <!-- both the correct and deprecated locales need to be present for
+         them to be recognized on all devices -->
+    <issue id="LocaleFolder" severity="error">
+        <ignore path="src/main/res/values-he"/>
+        <ignore path="src/main/res/values-id"/>
+    </issue>
+
+    <issue id="SetWorldReadable" severity="error">
+        <ignore path="src/main/java/org/fdroid/fdroid/installer/ApkFileProvider.java"/>
+    </issue>
+
+    <issue id="ProtectedPermissions" severity="error">
+        <ignore path="src/debug/AndroidManifest.xml"/>
+        <ignore path="src/full/AndroidManifest.xml"/>
+    </issue>
+
+    <!-- these should be fixed, but it'll be a chunk of work -->
+    <issue id="SetTextI18n" severity="error">
+        <ignore path="src/main/java/org/fdroid/fdroid/views/AppDetailsRecyclerViewAdapter.java"/>
+        <ignore path="src/main/java/org/fdroid/fdroid/views/apps/AppListItemController.java"/>
+    </issue>
+</lint>

app/proguard-rules.pro

@@ -4,12 +4,16 @@
 -keep class org.fdroid.fdroid.** {*;}
 -dontskipnonpubliclibraryclassmembers
 -dontwarn android.test.**
--dontwarn com.android.support.test.**
 
 -dontwarn javax.naming.**
--dontnote android.support.**
+-dontwarn org.slf4j.**
+-dontnote org.apache.http.**
+-dontnote android.net.http.**
 -dontnote **ILicensingService
 
+# Needed for espresso https://stackoverflow.com/a/21706087
+-dontwarn org.xmlpull.v1.**
+
 # StrongHttpsClient and its support classes are totally unused, so the
 # ch.boye.httpclientandroidlib.** classes are also unneeded
 -dontwarn info.guardianproject.netcipher.client.**
@@ -19,7 +23,7 @@
 # removed, proguard will strip classes which are required, which may result in
 # crashes.
 -keep class kellinwood.security.zipsigner.** {*;}
--keep class org.spongycastle.** {*;}
+-keep class org.bouncycastle.** {*;}
 
 # This keeps class members used for SystemInstaller IPC.
 #   Reference: https://gitlab.com/fdroid/fdroidclient/issues/79
@@ -27,20 +31,17 @@
     public *;
 }
 
-# Samsung Android 4.2 bug
-# https://code.google.com/p/android/issues/detail?id=78377
--keepnames class !android.support.v7.internal.view.menu.**, ** {*;}
-
--keep public class android.support.v7.widget.** {*;}
--keep public class android.support.v7.internal.widget.** {*;}
-
--keep public class * extends android.support.v4.view.ActionProvider {
-    public <init>(android.content.Context);
+-keepattributes *Annotation*,EnclosingMethod,Signature
+-keepnames class com.fasterxml.jackson.** { *; }
+-dontwarn com.fasterxml.jackson.databind.ext.**
+-keep class org.codehaus.** { *; }
+-keepclassmembers public final enum org.codehaus.jackson.annotate.JsonAutoDetect$Visibility {
+public static final org.codehaus.jackson.annotate.JsonAutoDetect$Visibility *; }
+-keep public class your.class.** {
+  *;
 }
 
-# The rxjava library depends on sun.misc.Unsafe, which is unavailable on Android
-# The rxjava team is aware of this, and mention in the docs that they only use
-# the unsafe functionality if the platform supports it.
-#  - https://github.com/ReactiveX/RxJava/issues/1415#issuecomment-48390883
-#  - https://github.com/ReactiveX/RxJava/blob/1.x/src/main/java/rx/internal/util/unsafe/UnsafeAccess.java#L23
--dontwarn rx.internal.util.**
+# This is necessary so that RemoteWorkManager can be initialized (also marked with @Keep)
+-keep class androidx.work.multiprocess.RemoteWorkManagerClient {
+    public <init>(...);
+}

app/src/androidTest/AndroidManifest.xml

@@ -1,23 +1,24 @@
 <?xml version="1.0" encoding="utf-8"?>
+
 <!-- package name must be unique so suffix with "tests" so package loader doesn't ignore us -->
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="org.fdroid.fdroid.tests"
-          android:versionCode="1"
-          android:versionName="1.0">
+    xmlns:tools="http://schemas.android.com/tools"
+    package="org.fdroid.fdroid.tests"
+    android:versionCode="1"
+    android:versionName="1.0">
+
+    <uses-sdk tools:overrideLibrary="android_libs.ub_uiautomator" />
+
     <!-- We add an application tag here just so that we can indicate that
          this package needs to link against the android.test library,
          which is needed when building test cases. -->
     <application>
-        <uses-library android:name="android.test.runner"/>
+        <uses-library
+            android:name="android.test.runner"
+            android:required="false" />
     </application>
-    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
-    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
-    <!--
-    This declares that this application uses the instrumentation test runner targeting
-    the package of org.fdroid.fdroid.  To run the tests use the command:
-    "adb shell am instrument -w org.fdroid.fdroid.tests/android.test.InstrumentationTestRunner"
-    -->
-    <instrumentation android:name="com.zutubi.android.junitreport.JUnitReportTestRunner"
-                     android:targetPackage="org.fdroid.fdroid"
-                     android:label="Tests for org.fdroid.fdroid" />
+
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+
 </manifest>

app/src/androidTest/assets/extendedPerms.xml

@@ -68,7 +68,7 @@
             </permissions>
             <uses-permission name="android.permission.GET_ACCOUNTS" maxSdkVersion="22" />
             <uses-permission name="android.permission.READ_EXTERNAL_STORAGE" maxSdkVersion="18" />
-            <uses-permission name="android.permission.WRITE_EXTERNAL_STORAGE" maxSdkVersion="18" />
+            <uses-permission name="android.permission.WRITE_EXTERNAL_STORAGE" />
             <uses-permission name="android.permission.AUTHENTICATE_ACCOUNTS" maxSdkVersion="22" />
             <uses-permission name="android.permission.MANAGE_ACCOUNTS" maxSdkVersion="22" />
         </package>
@@ -85,7 +85,7 @@
             <targetSdkVersion>23</targetSdkVersion>
             <added>2016-06-26</added>
             <permissions>
-                org.dmfs.permission.READ_TASKS,READ_EXTERNAL_STORAGE,WRITE_CONTACTS,GET_ACCOUNTS,AUTHENTICATE_ACCOUNTS,WRITE_EXTERNAL_STORAGE,READ_CALENDAR,ACCESS_WIFI_STATE,org.dmfs.permission.WRITE_TASKS,ACCESS_NETWORK_STATE,WRITE_CALENDAR,READ_CONTACTS,READ_SYNC_SETTINGS,INTERNET,MANAGE_ACCOUNTS,WRITE_SYNC_SETTINGS
+                org.dmfs.permission.READ_TASKS,WRITE_CONTACTS,GET_ACCOUNTS,AUTHENTICATE_ACCOUNTS,WRITE_EXTERNAL_STORAGE,READ_CALENDAR,ACCESS_WIFI_STATE,org.dmfs.permission.WRITE_TASKS,ACCESS_NETWORK_STATE,WRITE_CALENDAR,READ_CONTACTS,READ_SYNC_SETTINGS,INTERNET,MANAGE_ACCOUNTS,WRITE_SYNC_SETTINGS
             </permissions>
         </package>
         <package>

app/src/androidTest/java/org/fdroid/fdroid/AssetUtils.java

@@ -1,8 +1,8 @@
 package org.fdroid.fdroid;
 
 import android.content.Context;
-import android.support.annotation.Nullable;
 import android.util.Log;
+import androidx.annotation.Nullable;
 
 import java.io.File;
 import java.io.FileOutputStream;
@@ -16,6 +16,9 @@ public class AssetUtils {
 
     private static final String TAG = "Utils";
 
+    /**
+     * This requires {@link Context} from {@link android.app.Instrumentation#getContext()}
+     */
     @Nullable
     public static File copyAssetToDir(Context context, String assetName, File directory) {
         File tempFile = null;
@@ -28,6 +31,7 @@ public class AssetUtils {
             output = new FileOutputStream(tempFile);
             Utils.copy(input, output);
         } catch (IOException e) {
+            Log.e(TAG, "Check the context is from Instrumentation.getContext()");
             fail(e.getMessage());
         } finally {
             Utils.closeQuietly(output);

app/src/androidTest/java/org/fdroid/fdroid/CleanCacheServiceTest.java

@@ -1,65 +0,0 @@
-package org.fdroid.fdroid;
-
-import android.app.Instrumentation;
-import android.support.test.InstrumentationRegistry;
-import android.support.test.runner.AndroidJUnit4;
-
-import org.apache.commons.io.FileUtils;
-import org.fdroid.fdroid.compat.FileCompatTest;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import java.io.File;
-import java.io.IOException;
-
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-
-@RunWith(AndroidJUnit4.class)
-public class CleanCacheServiceTest {
-
-    public static final String TAG = "CleanCacheServiceTest";
-
-    @Test
-    public void testClearOldFiles() throws IOException, InterruptedException {
-        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
-        File tempDir = FileCompatTest.getWriteableDir(instrumentation);
-        assertTrue(tempDir.isDirectory());
-        assertTrue(tempDir.canWrite());
-
-        File dir = new File(tempDir, "F-Droid-test.clearOldFiles");
-        FileUtils.deleteQuietly(dir);
-        assertTrue(dir.mkdirs());
-        assertTrue(dir.isDirectory());
-
-        File first = new File(dir, "first");
-        first.deleteOnExit();
-
-        File second = new File(dir, "second");
-        second.deleteOnExit();
-
-        assertFalse(first.exists());
-        assertFalse(second.exists());
-
-        assertTrue(first.createNewFile());
-        assertTrue(first.exists());
-
-        Thread.sleep(7000);
-        assertTrue(second.createNewFile());
-        assertTrue(second.exists());
-
-        CleanCacheService.clearOldFiles(dir, 3000);  // check all in dir
-        assertFalse(first.exists());
-        assertTrue(second.exists());
-
-        Thread.sleep(7000);
-        CleanCacheService.clearOldFiles(second, 3000);  // check just second file
-        assertFalse(first.exists());
-        assertFalse(second.exists());
-
-        // make sure it doesn't freak out on a non-existant file
-        File nonexistant = new File(tempDir, "nonexistant");
-        CleanCacheService.clearOldFiles(nonexistant, 1);
-        CleanCacheService.clearOldFiles(null, 1);
-    }
-}

app/src/androidTest/java/org/fdroid/fdroid/LocalizationTest.java

@@ -0,0 +1,222 @@
+package org.fdroid.fdroid;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.content.res.AssetManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import android.text.TextUtils;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.lang.reflect.Field;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IllegalFormatException;
+import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Runs through all of the translated strings and tests them with the same format
+ * values that the source strings expect.  This is to ensure that the formats in
+ * the translations are correct in number and in type (e.g. {@code s} or {@code s}.
+ * It reads the source formats and then builds {@code formats} to represent the
+ * position and type of the formats.  Then it runs through all of the translations
+ * with formats of the correct number and type.
+ */
+@RunWith(AndroidJUnit4.class)
+public class LocalizationTest {
+    public static final String TAG = "LocalizationTest";
+
+    private final Pattern androidFormat = Pattern.compile("(%[a-z0-9]\\$?[a-z]?)");
+    private final Locale[] locales = Locale.getAvailableLocales();
+    private final HashSet<String> localeNames = new HashSet<>(locales.length);
+
+    private AssetManager assets;
+    private Configuration config;
+    private Resources resources;
+
+    @Before
+    public void setUp() {
+        for (Locale locale : Languages.LOCALES_TO_TEST) {
+            localeNames.add(locale.toString());
+        }
+        for (Locale locale : locales) {
+            localeNames.add(locale.toString());
+        }
+
+        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+        Context context = instrumentation.getTargetContext();
+        assets = context.getAssets();
+        config = context.getResources().getConfiguration();
+        config.locale = Locale.ENGLISH;
+        // Resources() requires DisplayMetrics, but they are only needed for drawables
+        resources = new Resources(assets, new DisplayMetrics(), config);
+    }
+
+    @Test
+    public void testLoadAllPlural() throws IllegalAccessException {
+        Field[] fields = R.plurals.class.getDeclaredFields();
+
+        HashMap<String, String> haveFormats = new HashMap<>();
+        for (Field field : fields) {
+            //Log.i(TAG, field.getName());
+            int resId = field.getInt(int.class);
+            CharSequence string = resources.getQuantityText(resId, 4);
+            //Log.i(TAG, field.getName() + ": '" + string + "'");
+            Matcher matcher = androidFormat.matcher(string);
+            int matches = 0;
+            char[] formats = new char[5];
+            while (matcher.find()) {
+                String match = matcher.group(0);
+                char formatType = match.charAt(match.length() - 1);
+                switch (match.length()) {
+                    case 2:
+                        formats[matches] = formatType;
+                        matches++;
+                        break;
+                    case 4:
+                        formats[Integer.parseInt(match.substring(1, 2)) - 1] = formatType;
+                        break;
+                    case 5:
+                        formats[Integer.parseInt(match.substring(1, 3)) - 1] = formatType;
+                        break;
+                    default:
+                        throw new IllegalStateException(field.getName() + " has bad format: " + match);
+                }
+            }
+            haveFormats.put(field.getName(), new String(formats).trim());
+        }
+
+        for (Locale locale : locales) {
+            config.locale = locale;
+            // Resources() requires DisplayMetrics, but they are only needed for drawables
+            resources = new Resources(assets, new DisplayMetrics(), config);
+            for (Field field : fields) {
+                String formats = null;
+                try {
+                    int resId = field.getInt(int.class);
+                    for (int quantity = 0; quantity < 567; quantity++) {
+                        resources.getQuantityString(resId, quantity);
+                    }
+
+                    formats = haveFormats.get(field.getName());
+                    switch (formats) {
+                        case "d":
+                            resources.getQuantityString(resId, 1, 1);
+                            break;
+                        case "s":
+                            resources.getQuantityString(resId, 1, "ONE");
+                            break;
+                        case "ds":
+                            resources.getQuantityString(resId, 2, 1, "TWO");
+                            break;
+                        default:
+                            if (!TextUtils.isEmpty(formats)) {
+                                throw new IllegalStateException("Pattern not included in tests: " + formats);
+                            }
+                    }
+                } catch (IllegalFormatException | Resources.NotFoundException e) {
+                    Log.i(TAG, locale + " " + field.getName());
+                    throw new IllegalArgumentException("Bad '" + formats + "' format in " + locale + " "
+                            + field.getName() + ": " + e.getMessage());
+                }
+            }
+        }
+    }
+
+    @Test
+    public void testLoadAllStrings() throws IllegalAccessException {
+        Field[] fields = R.string.class.getDeclaredFields();
+
+        HashMap<String, String> haveFormats = new HashMap<>();
+        for (Field field : fields) {
+            String string = resources.getString(field.getInt(int.class));
+            Matcher matcher = androidFormat.matcher(string);
+            int matches = 0;
+            char[] formats = new char[5];
+            while (matcher.find()) {
+                String match = matcher.group(0);
+                char formatType = match.charAt(match.length() - 1);
+                switch (match.length()) {
+                    case 2:
+                        formats[matches] = formatType;
+                        matches++;
+                        break;
+                    case 4:
+                        formats[Integer.parseInt(match.substring(1, 2)) - 1] = formatType;
+                        break;
+                    case 5:
+                        formats[Integer.parseInt(match.substring(1, 3)) - 1] = formatType;
+                        break;
+                    default:
+                        throw new IllegalStateException(field.getName() + " has bad format: " + match);
+                }
+            }
+            haveFormats.put(field.getName(), new String(formats).trim());
+        }
+
+        for (Locale locale : locales) {
+            config.locale = locale;
+            // Resources() requires DisplayMetrics, but they are only needed for drawables
+            resources = new Resources(assets, new DisplayMetrics(), config);
+            for (Field field : fields) {
+                int resId = field.getInt(int.class);
+                resources.getString(resId);
+
+                String formats = haveFormats.get(field.getName());
+                try {
+                    switch (formats) {
+                        case "d":
+                            resources.getString(resId, 1);
+                            break;
+                        case "dd":
+                            resources.getString(resId, 1, 2);
+                            break;
+                        case "ds":
+                            resources.getString(resId, 1, "TWO");
+                            break;
+                        case "dds":
+                            resources.getString(resId, 1, 2, "THREE");
+                            break;
+                        case "sds":
+                            resources.getString(resId, "ONE", 2, "THREE");
+                            break;
+                        case "s":
+                            resources.getString(resId, "ONE");
+                            break;
+                        case "ss":
+                            resources.getString(resId, "ONE", "TWO");
+                            break;
+                        case "sss":
+                            resources.getString(resId, "ONE", "TWO", "THREE");
+                            break;
+                        case "ssss":
+                            resources.getString(resId, "ONE", "TWO", "THREE", "FOUR");
+                            break;
+                        case "ssd":
+                            resources.getString(resId, "ONE", "TWO", 3);
+                            break;
+                        case "sssd":
+                            resources.getString(resId, "ONE", "TWO", "THREE", 4);
+                            break;
+                        default:
+                            if (!TextUtils.isEmpty(formats)) {
+                                throw new IllegalStateException("Pattern not included in tests: " + formats);
+                            }
+                    }
+                } catch (Exception e) {
+                    Log.i(TAG, locale + " " + field.getName());
+                    throw new IllegalArgumentException("Bad format in '" + locale + "' '" + field.getName() + "': "
+                            + e.getMessage());
+                }
+            }
+        }
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/MainActivityEspressoTest.java

@@ -0,0 +1,303 @@
+package org.fdroid.fdroid;
+
+import android.Manifest;
+import android.app.ActivityManager;
+import android.app.Instrumentation;
+import android.content.Context;
+import android.os.Build;
+
+import androidx.core.content.ContextCompat;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.filters.LargeTest;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.espresso.IdlingPolicies;
+import androidx.test.espresso.ViewInteraction;
+import androidx.test.rule.ActivityTestRule;
+import androidx.test.rule.GrantPermissionRule;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.uiautomator.UiDevice;
+import androidx.test.uiautomator.UiObject;
+import androidx.test.uiautomator.UiObjectNotFoundException;
+import androidx.test.uiautomator.UiSelector;
+import android.util.Log;
+import android.view.View;
+import org.fdroid.fdroid.views.StatusBanner;
+import org.fdroid.fdroid.views.main.MainActivity;
+import org.hamcrest.Matchers;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import static androidx.test.espresso.Espresso.onView;
+import static androidx.test.espresso.action.ViewActions.click;
+import static androidx.test.espresso.action.ViewActions.swipeDown;
+import static androidx.test.espresso.action.ViewActions.swipeLeft;
+import static androidx.test.espresso.action.ViewActions.swipeRight;
+import static androidx.test.espresso.action.ViewActions.swipeUp;
+import static androidx.test.espresso.action.ViewActions.typeText;
+import static androidx.test.espresso.assertion.ViewAssertions.doesNotExist;
+import static androidx.test.espresso.assertion.ViewAssertions.matches;
+import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static androidx.test.espresso.matcher.ViewMatchers.withContentDescription;
+import static androidx.test.espresso.matcher.ViewMatchers.withId;
+import static androidx.test.espresso.matcher.ViewMatchers.withText;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.not;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assume.assumeTrue;
+
+@LargeTest
+@RunWith(AndroidJUnit4.class)
+public class MainActivityEspressoTest {
+    public static final String TAG = "MainActivityEspressoTest";
+
+    /**
+     * Emulators older than {@code android-25} seem to fail at running Espresso tests.
+     * <p>
+     * ARM emulators are too slow to run these tests in a useful way.  The sad
+     * thing is that it would probably work if Android didn't put up the ANR
+     * "Process system isn't responding" on boot each time.  There seems to be no
+     * way to increase the ANR timeout.
+     */
+    private static boolean canRunEspresso() {
+        if (Build.VERSION.SDK_INT < 25
+                || (Build.SUPPORTED_ABIS[0].startsWith("arm") && isEmulator())) {
+            Log.e(TAG, "SKIPPING TEST: ARM emulators are too slow to run these tests in a useful way");
+            return false;
+        }
+        return true;
+    }
+
+    @BeforeClass
+    public static void classSetUp() {
+        IdlingPolicies.setIdlingResourceTimeout(10, TimeUnit.MINUTES);
+        IdlingPolicies.setMasterPolicyTimeout(10, TimeUnit.MINUTES);
+        if (!canRunEspresso()) {
+            return;
+        }
+        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+        try {
+            UiDevice.getInstance(instrumentation)
+                    .executeShellCommand("pm grant "
+                            + instrumentation.getTargetContext().getPackageName()
+                            + " android.permission.SET_ANIMATION_SCALE");
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        SystemAnimations.disableAll(ApplicationProvider.getApplicationContext());
+
+        // dismiss the ANR or any other system dialogs that might be there
+        UiObject button = new UiObject(new UiSelector().text("Wait").enabled(true));
+        try {
+            button.click();
+        } catch (UiObjectNotFoundException e) {
+            Log.d(TAG, e.getLocalizedMessage());
+        }
+        new UiWatchers().registerAnrAndCrashWatchers();
+
+        Context context = instrumentation.getTargetContext();
+        ActivityManager.MemoryInfo mi = new ActivityManager.MemoryInfo();
+        ActivityManager activityManager = ContextCompat.getSystemService(context, ActivityManager.class);
+        activityManager.getMemoryInfo(mi);
+        long percentAvail = mi.availMem / mi.totalMem;
+        Log.i(TAG, "RAM: " + mi.availMem + " / " + mi.totalMem + " = " + percentAvail);
+    }
+
+    @AfterClass
+    public static void classTearDown() {
+        SystemAnimations.enableAll(ApplicationProvider.getApplicationContext());
+    }
+
+    public static boolean isEmulator() {
+        return Build.FINGERPRINT.startsWith("generic")
+                || Build.FINGERPRINT.startsWith("unknown")
+                || Build.MODEL.contains("google_sdk")
+                || Build.MODEL.contains("Emulator")
+                || Build.MODEL.contains("Android SDK built for x86")
+                || Build.MANUFACTURER.contains("Genymotion")
+                || (Build.BRAND.startsWith("generic") && Build.DEVICE.startsWith("generic"))
+                || "google_sdk".equals(Build.PRODUCT);
+    }
+
+    @Before
+    public void setUp() {
+        assumeTrue(canRunEspresso());
+    }
+
+    /**
+     * Placate {@link android.os.StrictMode}
+     *
+     * @see <a href="https://github.com/aosp-mirror/platform_frameworks_base/commit/6f3a38f3afd79ed6dddcef5c83cb442d6749e2ff"> Run finalizers before counting for StrictMode</a>
+     */
+    @After
+    public void tearDown() {
+        System.gc();
+        System.runFinalization();
+        System.gc();
+    }
+
+    @Rule
+    public ActivityTestRule<MainActivity> activityTestRule =
+            new ActivityTestRule<>(MainActivity.class);
+
+    @Rule
+    public GrantPermissionRule accessCoarseLocationPermissionRule = GrantPermissionRule.grant(
+            Manifest.permission.ACCESS_COARSE_LOCATION);
+
+    @Rule
+    public GrantPermissionRule writeExternalStoragePermissionRule = GrantPermissionRule.grant(
+            Manifest.permission.WRITE_EXTERNAL_STORAGE);
+
+    @Test
+    public void bottomNavFlavorCheck() {
+        onView(withText(R.string.main_menu__updates)).check(matches(isDisplayed()));
+        onView(withText(R.string.menu_settings)).check(matches(isDisplayed()));
+        onView(withText("THIS SHOULD NOT SHOW UP ANYWHERE!!!")).check(doesNotExist());
+
+        assertTrue(BuildConfig.FLAVOR.startsWith("full") || BuildConfig.FLAVOR.startsWith("basic"));
+
+        if (BuildConfig.FLAVOR.startsWith("basic")) {
+            onView(withText(R.string.main_menu__latest_apps)).check(matches(isDisplayed()));
+            onView(withText(R.string.main_menu__categories)).check(doesNotExist());
+            onView(withText(R.string.main_menu__swap_nearby)).check(doesNotExist());
+        }
+
+        if (BuildConfig.FLAVOR.startsWith("full")) {
+            onView(withText(R.string.main_menu__latest_apps)).check(matches(isDisplayed()));
+            onView(withText(R.string.main_menu__categories)).check(matches(isDisplayed()));
+            onView(withText(R.string.main_menu__swap_nearby)).check(matches(isDisplayed()));
+        }
+    }
+
+    @LargeTest
+    @Test
+    public void showSettings() {
+        ViewInteraction settingsBottonNavButton = onView(
+                allOf(withText(R.string.menu_settings), isDisplayed()));
+        settingsBottonNavButton.perform(click());
+        onView(withText(R.string.preference_manage_installed_apps)).check(matches(isDisplayed()));
+        if (BuildConfig.FLAVOR.startsWith("basic") && BuildConfig.APPLICATION_ID.endsWith(".debug")) {
+            // TODO fix me by sorting out the flavor applicationId for debug builds in app/build.gradle
+            Log.i(TAG, "Skipping the remainder of showSettings test because it just crashes on basic .debug builds");
+            return;
+        }
+        ViewInteraction manageInstalledAppsButton = onView(
+                allOf(withText(R.string.preference_manage_installed_apps), isDisplayed()));
+        manageInstalledAppsButton.perform(click());
+        onView(withText(R.string.installed_apps__activity_title)).check(matches(isDisplayed()));
+        onView(withContentDescription(R.string.abc_action_bar_up_description)).perform(click());
+
+        onView(withText(R.string.menu_manage)).perform(click());
+        onView(withContentDescription(R.string.abc_action_bar_up_description)).perform(click());
+
+        manageInstalledAppsButton.perform(click());
+        onView(withText(R.string.installed_apps__activity_title)).check(matches(isDisplayed()));
+        onView(withContentDescription(R.string.abc_action_bar_up_description)).perform(click());
+
+        onView(withText(R.string.menu_manage)).perform(click());
+        onView(withContentDescription(R.string.abc_action_bar_up_description)).perform(click());
+
+        onView(withText(R.string.about_title)).perform(click());
+        onView(withId(R.id.version)).check(matches(isDisplayed()));
+        onView(withId(R.id.ok_button)).perform(click());
+
+        onView(withId(android.R.id.list_container)).perform(swipeUp()).perform(swipeUp()).perform(swipeUp());
+    }
+
+    @LargeTest
+    @Test
+    public void showUpdates() {
+        ViewInteraction updatesBottonNavButton = onView(allOf(withText(R.string.main_menu__updates), isDisplayed()));
+        updatesBottonNavButton.perform(click());
+        onView(withText(R.string.main_menu__updates)).check(matches(isDisplayed()));
+    }
+
+    @LargeTest
+    @Test
+    public void startSwap() {
+        if (!BuildConfig.FLAVOR.startsWith("full")) {
+            return;
+        }
+        ViewInteraction nearbyBottonNavButton = onView(
+                allOf(withText(R.string.main_menu__swap_nearby), isDisplayed()));
+        nearbyBottonNavButton.perform(click());
+        ViewInteraction findPeopleButton = onView(
+                allOf(withId(R.id.find_people_button), withText(R.string.nearby_splash__find_people_button),
+                        isDisplayed()));
+        findPeopleButton.perform(click());
+        onView(withText(R.string.swap_send_fdroid)).check(matches(isDisplayed()));
+    }
+
+    @LargeTest
+    @Test
+    public void showCategories() {
+        if (!BuildConfig.FLAVOR.startsWith("full")) {
+            return;
+        }
+        onView(allOf(withText(R.string.menu_settings), isDisplayed())).perform(click());
+        onView(allOf(withText(R.string.main_menu__categories), isDisplayed())).perform(click());
+        onView(allOf(withId(R.id.swipe_to_refresh), isDisplayed()))
+                .perform(swipeDown())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeDown())
+                .perform(swipeDown())
+                .perform(swipeRight())
+                .perform(swipeLeft())
+                .perform(swipeLeft())
+                .perform(swipeLeft())
+                .perform(swipeLeft())
+                .perform(click());
+    }
+
+    @LargeTest
+    @Test
+    public void showLatest() {
+        if (!BuildConfig.FLAVOR.startsWith("full")) {
+            return;
+        }
+        onView(Matchers.<View>instanceOf(StatusBanner.class)).check(matches(not(isDisplayed())));
+        onView(allOf(withText(R.string.menu_settings), isDisplayed())).perform(click());
+        onView(allOf(withText(R.string.main_menu__latest_apps), isDisplayed())).perform(click());
+        onView(allOf(withId(R.id.swipe_to_refresh), isDisplayed()))
+                .perform(swipeDown())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeUp())
+                .perform(swipeDown())
+                .perform(swipeUp())
+                .perform(swipeDown())
+                .perform(swipeDown())
+                .perform(swipeDown())
+                .perform(swipeDown())
+                .perform(click());
+    }
+
+    @LargeTest
+    @Test
+    public void showSearch() {
+        onView(allOf(withText(R.string.menu_settings), isDisplayed())).perform(click());
+        onView(withId(R.id.fab_search)).check(doesNotExist());
+        if (!BuildConfig.FLAVOR.startsWith("full")) {
+            return;
+        }
+        onView(allOf(withText(R.string.main_menu__latest_apps), isDisplayed())).perform(click());
+        onView(allOf(withId(R.id.fab_search), isDisplayed())).perform(click());
+        onView(withId(R.id.sort)).check(matches(isDisplayed()));
+        onView(allOf(withId(R.id.search), isDisplayed()))
+                .perform(click())
+                .perform(typeText("test"));
+        onView(allOf(withId(R.id.sort), isDisplayed())).perform(click());
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/Netstat.java

@@ -0,0 +1,372 @@
+package org.fdroid.fdroid;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Replacer for the netstat utility, by reading the /proc filesystem it can find out the
+ * open connections of the system
+ * From http://www.ussg.iu.edu/hypermail/linux/kernel/0409.1/2166.html :
+ * It will first list all listening TCP sockets, and next list all established
+ * TCP connections. A typical entry of /proc/net/tcp would look like this (split
+ * up into 3 parts because of the length of the line):
+ * <p>
+ * 46: 010310AC:9C4C 030310AC:1770 01
+ * | | | | | |--> connection state
+ * | | | | |------> remote TCP port number
+ * | | | |-------------> remote IPv4 address
+ * | | |--------------------> local TCP port number
+ * | |---------------------------> local IPv4 address
+ * |----------------------------------> number of entry
+ * <p>
+ * 00000150:00000000 01:00000019 00000000
+ * | | | | |--> number of unrecovered RTO timeouts
+ * | | | |----------> number of jiffies until timer expires
+ * | | |----------------> timer_active (see below)
+ * | |----------------------> receive-queue
+ * |-------------------------------> transmit-queue
+ * <p>
+ * 1000 0 54165785 4 cd1e6040 25 4 27 3 -1
+ * | | | | | | | | | |--> slow start size threshold,
+ * | | | | | | | | | or -1 if the treshold
+ * | | | | | | | | | is >= 0xFFFF
+ * | | | | | | | | |----> sending congestion window
+ * | | | | | | | |-------> (ack.quick<<1)|ack.pingpong
+ * | | | | | | |---------> Predicted tick of soft clock
+ * | | | | | | (delayed ACK control data)
+ * | | | | | |------------> retransmit timeout
+ * | | | | |------------------> location of socket in memory
+ * | | | |-----------------------> socket reference count
+ * | | |-----------------------------> inode
+ * | |----------------------------------> unanswered 0-window probes
+ * |---------------------------------------------> uid
+ *
+ * @author Ciprian Dobre
+ */
+public class Netstat {
+
+    /**
+     * Possible values for states in /proc/net/tcp
+     */
+    private static final String[] STATES = {
+            "ESTBLSH", "SYNSENT", "SYNRECV", "FWAIT1", "FWAIT2", "TMEWAIT",
+            "CLOSED", "CLSWAIT", "LASTACK", "LISTEN", "CLOSING", "UNKNOWN",
+    };
+    /**
+     * Pattern used when parsing through /proc/net/tcp
+     */
+    private static final Pattern NET_PATTERN = Pattern.compile(
+            "\\d+:\\s+([\\dA-F]+):([\\dA-F]+)\\s+([\\dA-F]+):([\\dA-F]+)\\s+([\\dA-F]+)\\s+" +
+                    "[\\dA-F]+:[\\dA-F]+\\s+[\\dA-F]+:[\\dA-F]+\\s+[\\dA-F]+\\s+([\\d]+)\\s+[\\d]+\\s+([\\d]+)");
+
+    /**
+     * Utility method that converts an address from a hex representation as founded in /proc to String representation
+     */
+    private static String getAddress(final String hexa) {
+        try {
+            // first let's convert the address to Integer
+            final long v = Long.parseLong(hexa, 16);
+            // in /proc the order is little endian and java uses big endian order we also need to invert the order
+            final long adr = (v >>> 24) | (v << 24) |
+                    ((v << 8) & 0x00FF0000) | ((v >> 8) & 0x0000FF00);
+            // and now it's time to output the result
+            return ((adr >> 24) & 0xff) + "." + ((adr >> 16) & 0xff) + "." + ((adr >> 8) & 0xff) + "." + (adr & 0xff);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            return "0.0.0.0";  // NOPMD
+        }
+    }
+
+    private static int getInt16(final String hexa) {
+        try {
+            return Integer.parseInt(hexa, 16);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            return -1;
+        }
+    }
+
+    /*
+    private static String getPName(final int pid) {
+        final Pattern pattern = Pattern.compile("Name:\\s*(\\S+)");
+        try {
+            BufferedReader in = new BufferedReader(new FileReader("/proc/" + pid + "/status"));
+            String line;
+            while ((line = in.readLine()) != null) {
+                final Matcher matcher = pattern.matcher(line);
+                if (matcher.find()) {
+                    return matcher.group(1);
+                }
+            }
+            in.close();
+        } catch (Throwable t) {
+            // ignored
+        }
+        return "UNKNOWN";
+    }
+    */
+
+    /**
+     * Method used to question for the connections currently openned
+     *
+     * @return The list of connections (as Connection objects)
+     */
+    public static List<Connection> getConnections() {
+
+        final ArrayList<Connection> net = new ArrayList<>();
+
+        // read from /proc/net/tcp the list of currently openned socket connections
+        try {
+            BufferedReader in = new BufferedReader(new FileReader("/proc/net/tcp"));
+            String line;
+            while ((line = in.readLine()) != null) { // NOPMD
+                Matcher matcher = NET_PATTERN.matcher(line);
+                if (matcher.find()) {
+                    final Connection c = new Connection();
+                    c.setProtocol(Connection.TCP_CONNECTION);
+                    net.add(c);
+                    final String localPortHexa = matcher.group(2);
+                    final String remoteAddressHexa = matcher.group(3);
+                    final String remotePortHexa = matcher.group(4);
+                    final String statusHexa = matcher.group(5);
+                    //final String uid = matcher.group(6);
+                    //final String inode = matcher.group(7);
+                    c.setLocalPort(getInt16(localPortHexa));
+                    c.setRemoteAddress(getAddress(remoteAddressHexa));
+                    c.setRemotePort(getInt16(remotePortHexa));
+                    try {
+                        c.setStatus(STATES[Integer.parseInt(statusHexa, 16) - 1]);
+                    } catch (Exception ex) {
+                        c.setStatus(STATES[11]); // unknown
+                    }
+                    c.setPID(-1); // unknown
+                    c.setPName("UNKNOWN");
+                }
+            }
+            in.close();
+        } catch (Throwable t) { // NOPMD
+            // ignored
+        }
+
+        // read from /proc/net/udp the list of currently openned socket connections
+        try {
+            BufferedReader in = new BufferedReader(new FileReader("/proc/net/udp"));
+            String line;
+            while ((line = in.readLine()) != null) { // NOPMD
+                Matcher matcher = NET_PATTERN.matcher(line);
+                if (matcher.find()) {
+                    final Connection c = new Connection();
+                    c.setProtocol(Connection.UDP_CONNECTION);
+                    net.add(c);
+                    final String localPortHexa = matcher.group(2);
+                    final String remoteAddressHexa = matcher.group(3);
+                    final String remotePortHexa = matcher.group(4);
+                    final String statusHexa = matcher.group(5);
+                    //final String uid = matcher.group(6);
+                    //final String inode = matcher.group(7);
+                    c.setLocalPort(getInt16(localPortHexa));
+                    c.setRemoteAddress(getAddress(remoteAddressHexa));
+                    c.setRemotePort(getInt16(remotePortHexa));
+                    try {
+                        c.setStatus(STATES[Integer.parseInt(statusHexa, 16) - 1]);
+                    } catch (Exception ex) {
+                        c.setStatus(STATES[11]); // unknown
+                    }
+                    c.setPID(-1); // unknown
+                    c.setPName("UNKNOWN");
+                }
+            }
+            in.close();
+        } catch (Throwable t) { // NOPMD
+            // ignored
+        }
+
+        // read from /proc/net/raw the list of currently openned socket connections
+        try {
+            BufferedReader in = new BufferedReader(new FileReader("/proc/net/raw"));
+            String line;
+            while ((line = in.readLine()) != null) { // NOPMD
+                Matcher matcher = NET_PATTERN.matcher(line);
+                if (matcher.find()) {
+                    final Connection c = new Connection();
+                    c.setProtocol(Connection.RAW_CONNECTION);
+                    net.add(c);
+                    //final String localAddressHexa = matcher.group(1);
+                    final String localPortHexa = matcher.group(2);
+                    final String remoteAddressHexa = matcher.group(3);
+                    final String remotePortHexa = matcher.group(4);
+                    final String statusHexa = matcher.group(5);
+                    //final String uid = matcher.group(6);
+                    //final String inode = matcher.group(7);
+                    c.setLocalPort(getInt16(localPortHexa));
+                    c.setRemoteAddress(getAddress(remoteAddressHexa));
+                    c.setRemotePort(getInt16(remotePortHexa));
+                    try {
+                        c.setStatus(STATES[Integer.parseInt(statusHexa, 16) - 1]);
+                    } catch (Exception ex) {
+                        c.setStatus(STATES[11]); // unknown
+                    }
+                    c.setPID(-1); // unknown
+                    c.setPName("UNKNOWN");
+                }
+            }
+            in.close();
+        } catch (Throwable t) { // NOPMD
+            // ignored
+        }
+        return net;
+    }
+
+    /**
+     * Informations about a given connection
+     *
+     * @author Ciprian Dobre
+     */
+    public static class Connection {
+
+        /**
+         * Types of connection protocol
+         ***/
+        public static final byte TCP_CONNECTION = 0;
+        public static final byte UDP_CONNECTION = 1;
+        public static final byte RAW_CONNECTION = 2;
+        /**
+         * <code>serialVersionUID</code>
+         */
+        private static final long serialVersionUID = 1988671591829311032L;
+        /**
+         * The protocol of the connection (can be tcp, udp or raw)
+         */
+        protected byte protocol;
+
+        /**
+         * The owner of the connection (username)
+         */
+        protected String powner;
+
+        /**
+         * The pid of the owner process
+         */
+        protected int pid;
+
+        /**
+         * The name of the program owning the connection
+         */
+        protected String pname;
+
+        /**
+         * Local port
+         */
+        protected int localPort;
+
+        /**
+         * Remote address of the connection
+         */
+        protected String remoteAddress;
+
+        /**
+         * Remote port
+         */
+        protected int remotePort;
+
+        /**
+         * Status of the connection
+         */
+        protected String status;
+
+        public final byte getProtocol() {
+            return protocol;
+        }
+
+        public final void setProtocol(final byte protocol) {
+            this.protocol = protocol;
+        }
+
+        public final String getProtocolAsString() {
+            switch (protocol) {
+                case TCP_CONNECTION:
+                    return "TCP";
+                case UDP_CONNECTION:
+                    return "UDP";
+                case RAW_CONNECTION:
+                    return "RAW";
+            }
+            return "UNKNOWN";
+        }
+
+        public final String getPOwner() {
+            return powner;
+        }
+
+        public final void setPOwner(final String owner) {
+            this.powner = owner;
+        }
+
+        public final int getPID() {
+            return pid;
+        }
+
+        public final void setPID(final int pid) {
+            this.pid = pid;
+        }
+
+        public final String getPName() {
+            return pname;
+        }
+
+        public final void setPName(final String pname) {
+            this.pname = pname;
+        }
+
+        public final int getLocalPort() {
+            return localPort;
+        }
+
+        public final void setLocalPort(final int localPort) {
+            this.localPort = localPort;
+        }
+
+        public final String getRemoteAddress() {
+            return remoteAddress;
+        }
+
+        public final void setRemoteAddress(final String remoteAddress) {
+            this.remoteAddress = remoteAddress;
+        }
+
+        public final int getRemotePort() {
+            return remotePort;
+        }
+
+        public final void setRemotePort(final int remotePort) {
+            this.remotePort = remotePort;
+        }
+
+        public final String getStatus() {
+            return status;
+        }
+
+        public final void setStatus(final String status) {
+            this.status = status;
+        }
+
+        public String toString() {
+            StringBuffer buf = new StringBuffer();
+            buf.append("[Prot=").append(getProtocolAsString());
+            buf.append(",POwner=").append(powner);
+            buf.append(",PID=").append(pid);
+            buf.append(",PName=").append(pname);
+            buf.append(",LPort=").append(localPort);
+            buf.append(",RAddress=").append(remoteAddress);
+            buf.append(",RPort=").append(remotePort);
+            buf.append(",Status=").append(status);
+            buf.append("]");
+            return buf.toString();
+        }
+
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/SystemAnimations.java

@@ -0,0 +1,62 @@
+package org.fdroid.fdroid;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.IBinder;
+import android.util.Log;
+
+import java.lang.reflect.Method;
+
+/**
+ * @see <a href="https://artemzin.com/blog/easiest-way-to-give-set_animation_scale-permission-for-your-ui-tests-on-android/>EASIEST WAY TO GIVE SET_ANIMATION_SCALE PERMISSION FOR YOUR UI TESTS ON ANDROID</a>
+ * @see <a href="https://gist.github.com/xrigau/11284124>Disable animations for Espresso tests</a>
+ */
+class SystemAnimations {
+    public static final String TAG = "SystemAnimations";
+
+    private static final float DISABLED = 0.0f;
+    private static final float DEFAULT = 1.0f;
+
+    static void disableAll(Context context) {
+        int permStatus = context.checkCallingOrSelfPermission(Manifest.permission.SET_ANIMATION_SCALE);
+        if (permStatus == PackageManager.PERMISSION_GRANTED) {
+            Log.i(TAG, "Manifest.permission.SET_ANIMATION_SCALE PERMISSION_GRANTED");
+            setSystemAnimationsScale(DISABLED);
+        } else {
+            Log.i(TAG, "Disabling Manifest.permission.SET_ANIMATION_SCALE failed: " + permStatus);
+        }
+    }
+
+    static void enableAll(Context context) {
+        int permStatus = context.checkCallingOrSelfPermission(Manifest.permission.SET_ANIMATION_SCALE);
+        if (permStatus == PackageManager.PERMISSION_GRANTED) {
+            Log.i(TAG, "Manifest.permission.SET_ANIMATION_SCALE PERMISSION_GRANTED");
+            setSystemAnimationsScale(DEFAULT);
+        } else {
+            Log.i(TAG, "Enabling Manifest.permission.SET_ANIMATION_SCALE failed: " + permStatus);
+        }
+    }
+
+    private static void setSystemAnimationsScale(float animationScale) {
+        try {
+            Class<?> windowManagerStubClazz = Class.forName("android.view.IWindowManager$Stub");
+            Method asInterface = windowManagerStubClazz.getDeclaredMethod("asInterface", IBinder.class);
+            Class<?> serviceManagerClazz = Class.forName("android.os.ServiceManager");
+            Method getService = serviceManagerClazz.getDeclaredMethod("getService", String.class);
+            Class<?> windowManagerClazz = Class.forName("android.view.IWindowManager");
+            Method setAnimationScales = windowManagerClazz.getDeclaredMethod("setAnimationScales", float[].class);
+            Method getAnimationScales = windowManagerClazz.getDeclaredMethod("getAnimationScales");
+
+            IBinder windowManagerBinder = (IBinder) getService.invoke(null, "window");
+            Object windowManagerObj = asInterface.invoke(null, windowManagerBinder);
+            float[] currentScales = (float[]) getAnimationScales.invoke(windowManagerObj);
+            for (int i = 0; i < currentScales.length; i++) {
+                currentScales[i] = animationScale;
+            }
+            setAnimationScales.invoke(windowManagerObj, new Object[]{currentScales});
+        } catch (Exception e) {
+            Log.e(TAG, "Could not change animation scale to " + animationScale + " :'(");
+        }
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/UiWatchers.java

@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2013 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 org.fdroid.fdroid;
+
+import androidx.test.uiautomator.UiDevice;
+import androidx.test.uiautomator.UiObject;
+import androidx.test.uiautomator.UiObjectNotFoundException;
+import androidx.test.uiautomator.UiSelector;
+import androidx.test.uiautomator.UiWatcher;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@SuppressWarnings("MemberName")
+public class UiWatchers {
+    private static final String LOG_TAG = UiWatchers.class.getSimpleName();
+    private final List<String> mErrors = new ArrayList<String>();
+
+    /**
+     * We can use the UiDevice registerWatcher to register a small script to be executed when the
+     * framework is waiting for a control to appear. Waiting may be the cause of an unexpected
+     * dialog on the screen and it is the time when the framework runs the registered watchers.
+     * This is a sample watcher looking for ANR and crashes. it closes it and moves on. You should
+     * create your own watchers and handle error logging properly for your type of tests.
+     */
+    public void registerAnrAndCrashWatchers() {
+        UiDevice.getInstance().registerWatcher("ANR", new UiWatcher() {
+            @Override
+            public boolean checkForCondition() {
+                UiObject window = new UiObject(new UiSelector().className(
+                        "com.android.server.am.AppNotRespondingDialog"));
+                String errorText = null;
+                if (window.exists()) {
+                    try {
+                        errorText = window.getText();
+                    } catch (UiObjectNotFoundException e) {
+                        Log.e(LOG_TAG, "dialog gone?", e);
+                    }
+                    onAnrDetected(errorText);
+                    postHandler("Wait");
+                    return true; // triggered
+                }
+                return false; // no trigger
+            }
+        });
+        // class names may have changed
+        UiDevice.getInstance().registerWatcher("ANR2", new UiWatcher() {
+            @Override
+            public boolean checkForCondition() {
+                UiObject window = new UiObject(new UiSelector().packageName("android")
+                        .textContains("isn't responding."));
+                if (window.exists()) {
+                    String errorText = null;
+                    try {
+                        errorText = window.getText();
+                    } catch (UiObjectNotFoundException e) {
+                        Log.e(LOG_TAG, "dialog gone?", e);
+                    }
+                    onAnrDetected(errorText);
+                    postHandler("Wait");
+                    return true; // triggered
+                }
+                return false; // no trigger
+            }
+        });
+        UiDevice.getInstance().registerWatcher("CRASH", new UiWatcher() {
+            @Override
+            public boolean checkForCondition() {
+                UiObject window = new UiObject(new UiSelector().className(
+                        "com.android.server.am.AppErrorDialog"));
+                if (window.exists()) {
+                    String errorText = null;
+                    try {
+                        errorText = window.getText();
+                    } catch (UiObjectNotFoundException e) {
+                        Log.e(LOG_TAG, "dialog gone?", e);
+                    }
+                    onCrashDetected(errorText);
+                    postHandler("OK");
+                    return true; // triggered
+                }
+                return false; // no trigger
+            }
+        });
+        UiDevice.getInstance().registerWatcher("CRASH2", new UiWatcher() {
+            @Override
+            public boolean checkForCondition() {
+                UiObject window = new UiObject(new UiSelector().packageName("android")
+                        .textContains("has stopped"));
+                if (window.exists()) {
+                    String errorText = null;
+                    try {
+                        errorText = window.getText();
+                    } catch (UiObjectNotFoundException e) {
+                        Log.e(LOG_TAG, "dialog gone?", e);
+                    }
+                    onCrashDetected(errorText);
+                    postHandler("OK");
+                    return true; // triggered
+                }
+                return false; // no trigger
+            }
+        });
+        Log.i(LOG_TAG, "Registered GUI Exception watchers");
+    }
+
+    public void onAnrDetected(String errorText) {
+        mErrors.add(errorText);
+    }
+
+    public void onCrashDetected(String errorText) {
+        mErrors.add(errorText);
+    }
+
+    public void reset() {
+        mErrors.clear();
+    }
+
+    public List<String> getErrors() {
+        return Collections.unmodifiableList(mErrors);
+    }
+
+    /**
+     * Current implementation ignores the exception and continues.
+     */
+    public void postHandler(String buttonText) {
+        // TODO: Add custom error logging here
+        String formatedOutput = String.format("UI Exception Message: %-20s\n", UiDevice
+                .getInstance().getCurrentPackageName());
+        Log.e(LOG_TAG, formatedOutput);
+        UiObject buttonOK = new UiObject(new UiSelector().text(buttonText).enabled(true));
+        // sometimes it takes a while for the OK button to become enabled
+        buttonOK.waitForExists(5000);
+        try {
+            buttonOK.click();
+        } catch (UiObjectNotFoundException e) {
+            e.printStackTrace();
+        }
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/compat/FileCompatTest.java

@@ -4,8 +4,9 @@ import android.app.Instrumentation;
 import android.content.Context;
 import android.os.Build;
 import android.os.Environment;
-import android.support.test.InstrumentationRegistry;
-import android.support.test.runner.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import android.util.Log;
 
 import org.fdroid.fdroid.AssetUtils;
 import org.fdroid.fdroid.data.SanitizedFile;
@@ -30,6 +31,8 @@ import static org.junit.Assume.assumeTrue;
 @RunWith(AndroidJUnit4.class)
 public class FileCompatTest {
 
+    private static final String TAG = "FileCompatTest";
+
     private SanitizedFile sourceFile;
     private SanitizedFile destFile;
 
@@ -47,11 +50,11 @@ public class FileCompatTest {
     @After
     public void tearDown() {
         if (!sourceFile.delete()) {
-            System.out.println("Can't delete " + sourceFile.getAbsolutePath() + ".");
+            Log.w(TAG, "Can't delete " + sourceFile.getAbsolutePath() + ".");
         }
 
         if (!destFile.delete()) {
-            System.out.println("Can't delete " + destFile.getAbsolutePath() + ".");
+            Log.w(TAG, "Can't delete " + destFile.getAbsolutePath() + ".");
         }
     }
 

app/src/androidTest/java/org/fdroid/fdroid/installer/ApkVerifierTest.java

@@ -22,17 +22,16 @@ package org.fdroid.fdroid.installer;
 import android.app.Instrumentation;
 import android.net.Uri;
 import android.os.Build;
-import android.support.annotation.NonNull;
-import android.support.test.InstrumentationRegistry;
-import android.support.test.runner.AndroidJUnit4;
 import android.util.Log;
-
+import androidx.annotation.NonNull;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
 import org.fdroid.fdroid.AssetUtils;
-import org.fdroid.fdroid.RepoXMLHandler;
 import org.fdroid.fdroid.Utils;
 import org.fdroid.fdroid.compat.FileCompatTest;
 import org.fdroid.fdroid.data.Apk;
 import org.fdroid.fdroid.data.Repo;
+import org.fdroid.fdroid.data.RepoXMLHandler;
 import org.fdroid.fdroid.mock.RepoDetails;
 import org.junit.Before;
 import org.junit.Test;
@@ -45,6 +44,7 @@ import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashSet;
+import java.util.TreeSet;
 
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
@@ -103,7 +103,7 @@ public class ApkVerifierTest {
     public void testNulls() {
         assertTrue(ApkVerifier.requestedPermissionsEqual(null, null));
 
-        String[] perms = new String[] {"Blah"};
+        String[] perms = new String[]{"Blah"};
         assertFalse(ApkVerifier.requestedPermissionsEqual(perms, null));
         assertFalse(ApkVerifier.requestedPermissionsEqual(null, perms));
     }
@@ -113,7 +113,7 @@ public class ApkVerifierTest {
         Apk apk = new Apk();
         apk.packageName = "org.fdroid.permissions.sdk14";
         apk.targetSdkVersion = 14;
-        String[] noPrefixPermissions = new String[]{
+        ArrayList<String> noPrefixPermissionsList = new ArrayList<>(Arrays.asList(
                 "AUTHENTICATE_ACCOUNTS",
                 "MANAGE_ACCOUNTS",
                 "READ_PROFILE",
@@ -129,8 +129,13 @@ public class ApkVerifierTest {
                 "READ_SYNC_SETTINGS",
                 "WRITE_SYNC_SETTINGS",
                 "WRITE_CALL_LOG", // implied-permission!
-                "READ_CALL_LOG", // implied-permission!
-        };
+                "READ_CALL_LOG" // implied-permission!
+        ));
+        if (Build.VERSION.SDK_INT >= 29) {
+            noPrefixPermissionsList.add("android.permission.ACCESS_MEDIA_LOCATION");
+        }
+        String[] noPrefixPermissions = noPrefixPermissionsList.toArray(new String[0]);
+
         for (int i = 0; i < noPrefixPermissions.length; i++) {
             noPrefixPermissions[i] = RepoXMLHandler.fdroidToAndroidPermission(noPrefixPermissions[i]);
         }
@@ -177,7 +182,7 @@ public class ApkVerifierTest {
         Apk apk = new Apk();
         apk.packageName = "org.fdroid.permissions.sdk14";
         apk.targetSdkVersion = 14;
-        apk.requestedPermissions = new String[]{
+        TreeSet<String> expectedSet = new TreeSet<>(Arrays.asList(
                 "android.permission.AUTHENTICATE_ACCOUNTS",
                 "android.permission.MANAGE_ACCOUNTS",
                 "android.permission.READ_PROFILE",
@@ -193,8 +198,12 @@ public class ApkVerifierTest {
                 "android.permission.READ_SYNC_SETTINGS",
                 "android.permission.WRITE_SYNC_SETTINGS",
                 "android.permission.WRITE_CALL_LOG", // implied-permission!
-                "android.permission.READ_CALL_LOG", // implied-permission!
-        };
+                "android.permission.READ_CALL_LOG"// implied-permission!
+        ));
+        if (Build.VERSION.SDK_INT >= 29) {
+            expectedSet.add("android.permission.ACCESS_MEDIA_LOCATION");
+        }
+        apk.requestedPermissions = expectedSet.toArray(new String[0]);
 
         Uri uri = Uri.fromFile(sdk14Apk);
 
@@ -290,7 +299,7 @@ public class ApkVerifierTest {
     public void testExtendedPerms() throws IOException,
             ApkVerifier.ApkPermissionUnequalException, ApkVerifier.ApkVerificationException {
         RepoDetails actualDetails = getFromFile(extendedPermsXml);
-        HashSet<String> expectedSet = new HashSet<>(Arrays.asList(new String[]{
+        HashSet<String> expectedSet = new HashSet<>(Arrays.asList(
                 "android.permission.ACCESS_NETWORK_STATE",
                 "android.permission.ACCESS_WIFI_STATE",
                 "android.permission.INTERNET",
@@ -301,8 +310,8 @@ public class ApkVerifierTest {
                 "android.permission.READ_CONTACTS",
                 "android.permission.WRITE_CONTACTS",
                 "android.permission.READ_CALENDAR",
-                "android.permission.WRITE_CALENDAR",
-        }));
+                "android.permission.WRITE_CALENDAR"
+        ));
         if (Build.VERSION.SDK_INT <= 18) {
             expectedSet.add("android.permission.READ_EXTERNAL_STORAGE");
             expectedSet.add("android.permission.WRITE_EXTERNAL_STORAGE");
@@ -345,6 +354,93 @@ public class ApkVerifierTest {
         apkVerifier.verifyApk();
     }
 
+    @Test
+    public void testImpliedPerms() throws IOException {
+        RepoDetails actualDetails = getFromFile(extendedPermsXml);
+        TreeSet<String> expectedSet = new TreeSet<>(Arrays.asList(
+                "android.permission.ACCESS_NETWORK_STATE",
+                "android.permission.ACCESS_WIFI_STATE",
+                "android.permission.INTERNET",
+                "android.permission.READ_CALENDAR",
+                "android.permission.READ_CONTACTS",
+                "android.permission.READ_EXTERNAL_STORAGE",
+                "android.permission.READ_SYNC_SETTINGS",
+                "android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS",
+                "android.permission.WRITE_CALENDAR",
+                "android.permission.WRITE_CONTACTS",
+                "android.permission.WRITE_EXTERNAL_STORAGE",
+                "android.permission.WRITE_SYNC_SETTINGS",
+                "org.dmfs.permission.READ_TASKS",
+                "org.dmfs.permission.WRITE_TASKS"
+        ));
+        if (Build.VERSION.SDK_INT <= 22) { // maxSdkVersion="22"
+            expectedSet.addAll(Arrays.asList(
+                    "android.permission.AUTHENTICATE_ACCOUNTS",
+                    "android.permission.GET_ACCOUNTS",
+                    "android.permission.MANAGE_ACCOUNTS"
+            ));
+        }
+        if (Build.VERSION.SDK_INT >= 29) {
+            expectedSet.add("android.permission.ACCESS_MEDIA_LOCATION");
+        }
+        Apk apk = actualDetails.apks.get(1);
+        Log.i(TAG, "APK: " + apk.apkName);
+        HashSet<String> actualSet = new HashSet<>(Arrays.asList(apk.requestedPermissions));
+        for (String permission : expectedSet) {
+            if (!actualSet.contains(permission)) {
+                Log.i(TAG, permission + " in expected but not actual! (android-"
+                        + Build.VERSION.SDK_INT + ")");
+            }
+        }
+        for (String permission : actualSet) {
+            if (!expectedSet.contains(permission)) {
+                Log.i(TAG, permission + " in actual but not expected! (android-"
+                        + Build.VERSION.SDK_INT + ")");
+            }
+        }
+        String[] expectedPermissions = expectedSet.toArray(new String[expectedSet.size()]);
+        assertTrue(ApkVerifier.requestedPermissionsEqual(expectedPermissions, apk.requestedPermissions));
+
+        expectedSet = new TreeSet<>(Arrays.asList(
+                "android.permission.ACCESS_NETWORK_STATE",
+                "android.permission.ACCESS_WIFI_STATE",
+                "android.permission.AUTHENTICATE_ACCOUNTS",
+                "android.permission.GET_ACCOUNTS",
+                "android.permission.INTERNET",
+                "android.permission.MANAGE_ACCOUNTS",
+                "android.permission.READ_CALENDAR",
+                "android.permission.READ_CONTACTS",
+                "android.permission.READ_EXTERNAL_STORAGE",
+                "android.permission.READ_SYNC_SETTINGS",
+                "android.permission.WRITE_CALENDAR",
+                "android.permission.WRITE_CONTACTS",
+                "android.permission.WRITE_EXTERNAL_STORAGE",
+                "android.permission.WRITE_SYNC_SETTINGS",
+                "org.dmfs.permission.READ_TASKS",
+                "org.dmfs.permission.WRITE_TASKS"
+        ));
+        if (Build.VERSION.SDK_INT >= 29) {
+            expectedSet.add("android.permission.ACCESS_MEDIA_LOCATION");
+        }
+        expectedPermissions = expectedSet.toArray(new String[expectedSet.size()]);
+        apk = actualDetails.apks.get(2);
+        Log.i(TAG, "APK: " + apk.apkName);
+        actualSet = new HashSet<>(Arrays.asList(apk.requestedPermissions));
+        for (String permission : expectedSet) {
+            if (!actualSet.contains(permission)) {
+                Log.i(TAG, permission + " in expected but not actual! (android-"
+                        + Build.VERSION.SDK_INT + ")");
+            }
+        }
+        for (String permission : actualSet) {
+            if (!expectedSet.contains(permission)) {
+                Log.i(TAG, permission + " in actual but not expected! (android-"
+                        + Build.VERSION.SDK_INT + ")");
+            }
+        }
+        assertTrue(ApkVerifier.requestedPermissionsEqual(expectedPermissions, apk.requestedPermissions));
+    }
+
     @NonNull
     private RepoDetails getFromFile(File indexFile) throws IOException {
         InputStream inputStream = null;

app/src/androidTest/java/org/fdroid/fdroid/nearby/BonjourManagerTest.java

@@ -0,0 +1,128 @@
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.fdroid.fdroid.FDroidApp;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import javax.jmdns.ServiceEvent;
+import javax.jmdns.ServiceListener;
+
+import static org.junit.Assert.assertTrue;
+
+@RunWith(AndroidJUnit4.class)
+public class BonjourManagerTest {
+
+    private static final String NAME = "Robolectric-test";
+    private static final String LOCALHOST = "localhost";
+    private static final int PORT = 8888;
+
+    @Test
+    public void testStartStop() throws InterruptedException {
+        Context context = ApplicationProvider.getApplicationContext();
+
+        FDroidApp.ipAddressString = LOCALHOST;
+        FDroidApp.port = PORT;
+
+        final CountDownLatch addedLatch = new CountDownLatch(1);
+        final CountDownLatch resolvedLatch = new CountDownLatch(1);
+        final CountDownLatch removedLatch = new CountDownLatch(1);
+        BonjourManager.start(context, NAME, false,
+                new ServiceListener() {
+                    @Override
+                    public void serviceAdded(ServiceEvent serviceEvent) {
+                        System.out.println("Service added: " + serviceEvent.getInfo());
+                        if (NAME.equals(serviceEvent.getName())) {
+                            addedLatch.countDown();
+                        }
+                    }
+
+                    @Override
+                    public void serviceRemoved(ServiceEvent serviceEvent) {
+                        System.out.println("Service removed: " + serviceEvent.getInfo());
+                        removedLatch.countDown();
+                    }
+
+                    @Override
+                    public void serviceResolved(ServiceEvent serviceEvent) {
+                        System.out.println("Service resolved: " + serviceEvent.getInfo());
+                        if (NAME.equals(serviceEvent.getName())) {
+                            resolvedLatch.countDown();
+                        }
+                    }
+                }, getBlankServiceListener());
+        BonjourManager.setVisible(context, true);
+        assertTrue(addedLatch.await(30, TimeUnit.SECONDS));
+        assertTrue(resolvedLatch.await(30, TimeUnit.SECONDS));
+        BonjourManager.setVisible(context, false);
+        assertTrue(removedLatch.await(30, TimeUnit.SECONDS));
+        BonjourManager.stop(context);
+    }
+
+    @Test
+    public void testRestart() throws InterruptedException {
+        Context context = ApplicationProvider.getApplicationContext();
+
+        FDroidApp.ipAddressString = LOCALHOST;
+        FDroidApp.port = PORT;
+
+        BonjourManager.start(context, NAME, false, getBlankServiceListener(), getBlankServiceListener());
+
+        final CountDownLatch addedLatch = new CountDownLatch(1);
+        final CountDownLatch resolvedLatch = new CountDownLatch(1);
+        final CountDownLatch removedLatch = new CountDownLatch(1);
+        BonjourManager.restart(context, NAME, false,
+                new ServiceListener() {
+                    @Override
+                    public void serviceAdded(ServiceEvent serviceEvent) {
+                        System.out.println("Service added: " + serviceEvent.getInfo());
+                        if (NAME.equals(serviceEvent.getName())) {
+                            addedLatch.countDown();
+                        }
+                    }
+
+                    @Override
+                    public void serviceRemoved(ServiceEvent serviceEvent) {
+                        System.out.println("Service removed: " + serviceEvent.getInfo());
+                        removedLatch.countDown();
+                    }
+
+                    @Override
+                    public void serviceResolved(ServiceEvent serviceEvent) {
+                        System.out.println("Service resolved: " + serviceEvent.getInfo());
+                        if (NAME.equals(serviceEvent.getName())) {
+                            resolvedLatch.countDown();
+                        }
+                    }
+                }, getBlankServiceListener());
+        BonjourManager.setVisible(context, true);
+        assertTrue(addedLatch.await(30, TimeUnit.SECONDS));
+        assertTrue(resolvedLatch.await(30, TimeUnit.SECONDS));
+        BonjourManager.setVisible(context, false);
+        assertTrue(removedLatch.await(30, TimeUnit.SECONDS));
+        BonjourManager.stop(context);
+    }
+
+    private ServiceListener getBlankServiceListener() {
+        return new ServiceListener() {
+            @Override
+            public void serviceAdded(ServiceEvent serviceEvent) {
+            }
+
+            @Override
+            public void serviceRemoved(ServiceEvent serviceEvent) {
+            }
+
+            @Override
+            public void serviceResolved(ServiceEvent serviceEvent) {
+            }
+        };
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/nearby/LocalHTTPDManagerTest.java

@@ -0,0 +1,192 @@
+package org.fdroid.fdroid.nearby;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.filters.LargeTest;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+import android.util.Log;
+import org.fdroid.fdroid.FDroidApp;
+import org.fdroid.fdroid.Netstat;
+import org.fdroid.fdroid.Utils;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+@LargeTest
+@RunWith(AndroidJUnit4.class)
+public class LocalHTTPDManagerTest {
+    private static final String TAG = "LocalHTTPDManagerTest";
+
+    private Context context;
+    private LocalBroadcastManager lbm;
+
+    private static final String LOCALHOST = "localhost";
+    private static final int PORT = 8888;
+
+    @Before
+    public void setUp() {
+        context = ApplicationProvider.getApplicationContext();
+        lbm = LocalBroadcastManager.getInstance(context);
+
+        FDroidApp.ipAddressString = LOCALHOST;
+        FDroidApp.port = PORT;
+
+        for (Netstat.Connection connection : Netstat.getConnections()) { // NOPMD
+            Log.i("LocalHTTPDManagerTest", "connection: " + connection.toString());
+        }
+        assertFalse(Utils.isServerSocketInUse(PORT));
+        LocalHTTPDManager.stop(context);
+
+        for (Netstat.Connection connection : Netstat.getConnections()) { // NOPMD
+            Log.i("LocalHTTPDManagerTest", "connection: " + connection.toString());
+        }
+    }
+
+    @After
+    public void tearDown() {
+        lbm.unregisterReceiver(startedReceiver);
+        lbm.unregisterReceiver(stoppedReceiver);
+        lbm.unregisterReceiver(errorReceiver);
+    }
+
+    @Ignore
+    @Test
+    public void testStartStop() throws InterruptedException {
+        Log.i(TAG, "testStartStop");
+
+        final CountDownLatch startLatch = new CountDownLatch(1);
+        BroadcastReceiver latchReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                startLatch.countDown();
+            }
+        };
+        lbm.registerReceiver(latchReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STARTED));
+        lbm.registerReceiver(stoppedReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STOPPED));
+        lbm.registerReceiver(errorReceiver, new IntentFilter(LocalHTTPDManager.ACTION_ERROR));
+        LocalHTTPDManager.start(context, false);
+        assertTrue(startLatch.await(30, TimeUnit.SECONDS));
+        assertTrue(Utils.isServerSocketInUse(PORT));
+        assertTrue(Utils.canConnectToSocket(LOCALHOST, PORT));
+        lbm.unregisterReceiver(latchReceiver);
+        lbm.unregisterReceiver(stoppedReceiver);
+        lbm.unregisterReceiver(errorReceiver);
+
+        final CountDownLatch stopLatch = new CountDownLatch(1);
+        latchReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                stopLatch.countDown();
+            }
+        };
+        lbm.registerReceiver(startedReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STARTED));
+        lbm.registerReceiver(latchReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STOPPED));
+        lbm.registerReceiver(errorReceiver, new IntentFilter(LocalHTTPDManager.ACTION_ERROR));
+        LocalHTTPDManager.stop(context);
+        assertTrue(stopLatch.await(30, TimeUnit.SECONDS));
+        assertFalse(Utils.isServerSocketInUse(PORT));
+        assertFalse(Utils.canConnectToSocket(LOCALHOST, PORT)); // if this is flaky, just remove it
+        lbm.unregisterReceiver(latchReceiver);
+    }
+
+    @Test
+    public void testError() throws InterruptedException, IOException {
+        Log.i("LocalHTTPDManagerTest", "testError");
+        ServerSocket blockerSocket = new ServerSocket(PORT);
+
+        final CountDownLatch latch = new CountDownLatch(1);
+        BroadcastReceiver latchReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                latch.countDown();
+            }
+        };
+        lbm.registerReceiver(startedReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STARTED));
+        lbm.registerReceiver(stoppedReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STOPPED));
+        lbm.registerReceiver(latchReceiver, new IntentFilter(LocalHTTPDManager.ACTION_ERROR));
+        LocalHTTPDManager.start(context, false);
+        assertTrue(latch.await(30, TimeUnit.SECONDS));
+        assertTrue(Utils.isServerSocketInUse(PORT));
+        assertNotEquals(PORT, FDroidApp.port);
+        assertFalse(Utils.isServerSocketInUse(FDroidApp.port));
+        lbm.unregisterReceiver(latchReceiver);
+        blockerSocket.close();
+    }
+
+    @Test
+    public void testRestart() throws InterruptedException, IOException {
+        Log.i("LocalHTTPDManagerTest", "testRestart");
+        assertFalse(Utils.isServerSocketInUse(PORT));
+        final CountDownLatch startLatch = new CountDownLatch(1);
+        BroadcastReceiver latchReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                startLatch.countDown();
+            }
+        };
+        lbm.registerReceiver(latchReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STARTED));
+        lbm.registerReceiver(stoppedReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STOPPED));
+        lbm.registerReceiver(errorReceiver, new IntentFilter(LocalHTTPDManager.ACTION_ERROR));
+        LocalHTTPDManager.start(context, false);
+        assertTrue(startLatch.await(30, TimeUnit.SECONDS));
+        assertTrue(Utils.isServerSocketInUse(PORT));
+        lbm.unregisterReceiver(latchReceiver);
+        lbm.unregisterReceiver(stoppedReceiver);
+
+        final CountDownLatch restartLatch = new CountDownLatch(1);
+        latchReceiver = new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                restartLatch.countDown();
+            }
+        };
+        lbm.registerReceiver(latchReceiver, new IntentFilter(LocalHTTPDManager.ACTION_STARTED));
+        LocalHTTPDManager.restart(context, false);
+        assertTrue(restartLatch.await(30, TimeUnit.SECONDS));
+        lbm.unregisterReceiver(latchReceiver);
+    }
+
+    private final BroadcastReceiver startedReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String message = intent.getStringExtra(Intent.EXTRA_TEXT);
+            Log.i(TAG, "startedReceiver: " + message);
+            fail();
+        }
+    };
+
+    private final BroadcastReceiver stoppedReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String message = intent.getStringExtra(Intent.EXTRA_TEXT);
+            Log.i(TAG, "stoppedReceiver: " + message);
+            fail();
+        }
+    };
+
+    private final BroadcastReceiver errorReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            String message = intent.getStringExtra(Intent.EXTRA_TEXT);
+            Log.i(TAG, "errorReceiver: " + message);
+            fail();
+        }
+    };
+}

app/src/androidTest/java/org/fdroid/fdroid/net/HttpDownloaderTest.java

@@ -1,12 +1,16 @@
 
 package org.fdroid.fdroid.net;
 
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
 import org.fdroid.fdroid.ProgressListener;
 import org.junit.Test;
 
 import java.io.File;
 import java.io.IOException;
-import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 
@@ -15,25 +19,40 @@ import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 public class HttpDownloaderTest {
+    private static final String TAG = "HttpDownloaderTest";
 
-    String[] urls = {
-            "https://en.wikipedia.org/wiki/Index.html",
-            "https://mirrors.kernel.org/debian/dists/stable/Release",
-            "https://f-droid.org/repo/index.jar",
-            // sites that use SNI for HTTPS
-            "https://guardianproject.info/fdroid/repo/index.jar",
-            //"https://microg.org/fdroid/repo/index.jar",
-            //"https://grobox.de/fdroid/repo/index.jar",
-    };
+    static final String[] URLS;
+
+    // https://developer.android.com/reference/javax/net/ssl/SSLContext
+    static {
+        ArrayList<String> tempUrls = new ArrayList<>(Arrays.asList(
+                "https://f-droid.org/repo/index-v1.jar",
+                // sites that use SNI for HTTPS
+                "https://mirrors.kernel.org/debian/dists/stable/Release",
+                "https://fdroid.tetaneutral.net/fdroid/repo/index-v1.jar",
+                "https://ftp.fau.de/fdroid/repo/index-v1.jar",
+                //"https://microg.org/fdroid/repo/index-v1.jar",
+                //"https://grobox.de/fdroid/repo/index.jar",
+                "https://guardianproject.info/fdroid/repo/index-v1.jar"
+        ));
+        if (Build.VERSION.SDK_INT >= 22) {
+            tempUrls.addAll(Arrays.asList(
+                    "https://en.wikipedia.org/wiki/Index.html", // no SNI but weird ipv6 lookup issues
+                    "https://mirror.cyberbits.eu/fdroid/repo/index-v1.jar"  // TLSv1.2 only and SNI
+            ));
+        }
+        URLS = tempUrls.toArray(new String[tempUrls.size()]);
+    }
 
     private boolean receivedProgress;
 
     @Test
     public void downloadUninterruptedTest() throws IOException, InterruptedException {
-        for (String urlString : urls) {
-            URL url = new URL(urlString);
+        for (String urlString : URLS) {
+            Log.i(TAG, "URL: " + urlString);
+            Uri uri = Uri.parse(urlString);
             File destFile = File.createTempFile("dl-", "");
-            HttpDownloader httpDownloader = new HttpDownloader(url, destFile);
+            HttpDownloader httpDownloader = new HttpDownloader(uri, destFile);
             httpDownloader.download();
             assertTrue(destFile.exists());
             assertTrue(destFile.canRead());
@@ -46,15 +65,12 @@ public class HttpDownloaderTest {
         final CountDownLatch latch = new CountDownLatch(1);
         String urlString = "https://f-droid.org/repo/index.jar";
         receivedProgress = false;
-        System.out.println("downloadUninterruptedTestWithProgress: " + urlString);
-        receivedProgress = false;
-        URL url = new URL(urlString);
+        Uri uri = Uri.parse(urlString);
         File destFile = File.createTempFile("dl-", "");
-        final HttpDownloader httpDownloader = new HttpDownloader(url, destFile);
+        final HttpDownloader httpDownloader = new HttpDownloader(uri, destFile);
         httpDownloader.setListener(new ProgressListener() {
             @Override
-            public void onProgress(URL sourceUrl, int bytesRead, int totalBytes) {
-                System.out.println("DownloaderProgressListener.sendProgress " + sourceUrl + " " + bytesRead + " / " + totalBytes);
+            public void onProgress(long bytesRead, long totalBytes) {
                 receivedProgress = true;
             }
         });
@@ -79,9 +95,9 @@ public class HttpDownloaderTest {
 
     @Test
     public void downloadHttpBasicAuth() throws IOException, InterruptedException {
-        URL url = new URL("https://httpbin.org/basic-auth/myusername/supersecretpassword");
+        Uri uri = Uri.parse("https://httpbin.org/basic-auth/myusername/supersecretpassword");
         File destFile = File.createTempFile("dl-", "");
-        HttpDownloader httpDownloader = new HttpDownloader(url, destFile, "myusername", "supersecretpassword");
+        HttpDownloader httpDownloader = new HttpDownloader(uri, destFile, "myusername", "supersecretpassword");
         httpDownloader.download();
         assertTrue(destFile.exists());
         assertTrue(destFile.canRead());
@@ -90,9 +106,9 @@ public class HttpDownloaderTest {
 
     @Test(expected = IOException.class)
     public void downloadHttpBasicAuthWrongPassword() throws IOException, InterruptedException {
-        URL url = new URL("https://httpbin.org/basic-auth/myusername/supersecretpassword");
+        Uri uri = Uri.parse("https://httpbin.org/basic-auth/myusername/supersecretpassword");
         File destFile = File.createTempFile("dl-", "");
-        HttpDownloader httpDownloader = new HttpDownloader(url, destFile, "myusername", "wrongpassword");
+        HttpDownloader httpDownloader = new HttpDownloader(uri, destFile, "myusername", "wrongpassword");
         httpDownloader.download();
         assertFalse(destFile.exists());
         destFile.deleteOnExit();
@@ -100,9 +116,9 @@ public class HttpDownloaderTest {
 
     @Test(expected = IOException.class)
     public void downloadHttpBasicAuthWrongUsername() throws IOException, InterruptedException {
-        URL url = new URL("https://httpbin.org/basic-auth/myusername/supersecretpassword");
+        Uri uri = Uri.parse("https://httpbin.org/basic-auth/myusername/supersecretpassword");
         File destFile = File.createTempFile("dl-", "");
-        HttpDownloader httpDownloader = new HttpDownloader(url, destFile, "wrongusername", "supersecretpassword");
+        HttpDownloader httpDownloader = new HttpDownloader(uri, destFile, "wrongusername", "supersecretpassword");
         httpDownloader.download();
         assertFalse(destFile.exists());
         destFile.deleteOnExit();
@@ -111,13 +127,12 @@ public class HttpDownloaderTest {
     @Test
     public void downloadThenCancel() throws IOException, InterruptedException {
         final CountDownLatch latch = new CountDownLatch(2);
-        URL url = new URL("https://f-droid.org/repo/index.jar");
+        Uri uri = Uri.parse("https://f-droid.org/repo/index.jar");
         File destFile = File.createTempFile("dl-", "");
-        final HttpDownloader httpDownloader = new HttpDownloader(url, destFile);
+        final HttpDownloader httpDownloader = new HttpDownloader(uri, destFile);
         httpDownloader.setListener(new ProgressListener() {
             @Override
-            public void onProgress(URL sourceUrl, int bytesRead, int totalBytes) {
-                System.out.println("DownloaderProgressListener.sendProgress " + bytesRead + " / " + totalBytes);
+            public void onProgress(long bytesRead, long totalBytes) {
                 receivedProgress = true;
                 latch.countDown();
             }

app/src/androidTest/java/org/fdroid/fdroid/updater/SwapRepoEmulatorTest.java

@@ -0,0 +1,203 @@
+package org.fdroid.fdroid.updater;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.ResolveInfo;
+import android.os.Looper;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.test.filters.LargeTest;
+import android.text.TextUtils;
+import android.util.Log;
+import org.fdroid.fdroid.BuildConfig;
+import org.fdroid.fdroid.FDroidApp;
+import org.fdroid.fdroid.Hasher;
+import org.fdroid.fdroid.IndexUpdater;
+import org.fdroid.fdroid.Preferences;
+import org.fdroid.fdroid.Utils;
+import org.fdroid.fdroid.data.Apk;
+import org.fdroid.fdroid.data.ApkProvider;
+import org.fdroid.fdroid.data.App;
+import org.fdroid.fdroid.data.AppProvider;
+import org.fdroid.fdroid.data.Repo;
+import org.fdroid.fdroid.data.RepoProvider;
+import org.fdroid.fdroid.data.Schema;
+import org.fdroid.fdroid.nearby.LocalHTTPD;
+import org.fdroid.fdroid.nearby.LocalRepoKeyStore;
+import org.fdroid.fdroid.nearby.LocalRepoManager;
+import org.fdroid.fdroid.nearby.LocalRepoService;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.net.Socket;
+import java.security.cert.Certificate;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.UUID;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+@LargeTest
+public class SwapRepoEmulatorTest {
+    public static final String TAG = "SwapRepoEmulatorTest";
+
+    /**
+     * @see org.fdroid.fdroid.nearby.WifiStateChangeService.WifiInfoThread#run()
+     */
+    @Ignore
+    @Test
+    public void testSwap()
+            throws IOException, LocalRepoKeyStore.InitException, IndexUpdater.UpdateException, InterruptedException {
+        Looper.prepare();
+        LocalHTTPD localHttpd = null;
+        try {
+            Log.i(TAG, "REPO: " + FDroidApp.repo);
+            final Context context = InstrumentationRegistry.getInstrumentation().getTargetContext();
+            Preferences.setupForTests(context);
+
+            FDroidApp.initWifiSettings();
+            assertNull(FDroidApp.repo.address);
+
+            final CountDownLatch latch = new CountDownLatch(1);
+            new Thread() {
+                @Override
+                public void run() {
+                    while (FDroidApp.repo.address == null) {
+                        try {
+                            Log.i(TAG, "Waiting for IP address... " + FDroidApp.repo.address);
+                            Thread.sleep(1000);
+                        } catch (InterruptedException e) {
+                            // ignored
+                        }
+                    }
+                    latch.countDown();
+                }
+            }.start();
+            latch.await(10, TimeUnit.MINUTES);
+            assertNotNull(FDroidApp.repo.address);
+
+            LocalRepoService.runProcess(context, new String[]{context.getPackageName()});
+            Log.i(TAG, "REPO: " + FDroidApp.repo);
+            File indexJarFile = LocalRepoManager.get(context).getIndexJar();
+            assertTrue(indexJarFile.isFile());
+
+            localHttpd = new LocalHTTPD(
+                    context,
+                    null,
+                    FDroidApp.port,
+                    LocalRepoManager.get(context).getWebRoot(),
+                    false);
+            localHttpd.start();
+            Thread.sleep(100); // give the server some tine to start.
+            assertTrue(localHttpd.isAlive());
+
+            LocalRepoKeyStore localRepoKeyStore = LocalRepoKeyStore.get(context);
+            Certificate localCert = localRepoKeyStore.getCertificate();
+            String signingCert = Hasher.hex(localCert);
+            assertFalse(TextUtils.isEmpty(signingCert));
+            assertFalse(TextUtils.isEmpty(Utils.calcFingerprint(localCert)));
+
+            Repo repoToDelete = RepoProvider.Helper.findByAddress(context, FDroidApp.repo.address);
+            while (repoToDelete != null) {
+                Log.d(TAG, "Removing old test swap repo matching this one: " + repoToDelete.address);
+                RepoProvider.Helper.remove(context, repoToDelete.getId());
+                repoToDelete = RepoProvider.Helper.findByAddress(context, FDroidApp.repo.address);
+            }
+
+            ContentValues values = new ContentValues(4);
+            values.put(Schema.RepoTable.Cols.SIGNING_CERT, signingCert);
+            values.put(Schema.RepoTable.Cols.ADDRESS, FDroidApp.repo.address);
+            values.put(Schema.RepoTable.Cols.NAME, FDroidApp.repo.name);
+            values.put(Schema.RepoTable.Cols.IS_SWAP, true);
+            final String lastEtag = UUID.randomUUID().toString();
+            values.put(Schema.RepoTable.Cols.LAST_ETAG, lastEtag);
+            RepoProvider.Helper.insert(context, values);
+            Repo repo = RepoProvider.Helper.findByAddress(context, FDroidApp.repo.address);
+            assertTrue(repo.isSwap);
+            assertNotEquals(-1, repo.getId());
+            assertTrue(repo.name.startsWith(FDroidApp.repo.name));
+            assertEquals(lastEtag, repo.lastetag);
+            assertNull(repo.lastUpdated);
+
+            assertTrue(isPortInUse(FDroidApp.ipAddressString, FDroidApp.port));
+            Thread.sleep(100);
+            IndexUpdater updater = new IndexUpdater(context, repo);
+            updater.update();
+            assertTrue(updater.hasChanged());
+
+            repo = RepoProvider.Helper.findByAddress(context, FDroidApp.repo.address);
+            final Date lastUpdated = repo.lastUpdated;
+            assertTrue("repo lastUpdated should be updated", new Date(2019, 5, 13).compareTo(repo.lastUpdated) > 0);
+
+            App app = AppProvider.Helper.findSpecificApp(context.getContentResolver(),
+                    context.getPackageName(), repo.getId());
+            assertEquals(context.getPackageName(), app.packageName);
+
+            List<Apk> apks = ApkProvider.Helper.findByRepo(context, repo, Schema.ApkTable.Cols.ALL);
+            assertEquals(1, apks.size());
+            for (Apk apk : apks) {
+                Log.i(TAG, "Apk: " + apk);
+                assertEquals(context.getPackageName(), apk.packageName);
+                assertEquals(BuildConfig.VERSION_NAME, apk.versionName);
+                assertEquals(BuildConfig.VERSION_CODE, apk.versionCode);
+                assertEquals(app.repoId, apk.repoId);
+            }
+
+            Intent mainIntent = new Intent(Intent.ACTION_MAIN, null);
+            mainIntent.addCategory(Intent.CATEGORY_LAUNCHER);
+            List<ResolveInfo> resolveInfoList = context.getPackageManager().queryIntentActivities(mainIntent, 0);
+            HashSet<String> packageNames = new HashSet<>();
+            for (ResolveInfo resolveInfo : resolveInfoList) {
+                if (!isSystemPackage(resolveInfo)) {
+                    Log.i(TAG, "resolveInfo: " + resolveInfo);
+                    packageNames.add(resolveInfo.activityInfo.packageName);
+                }
+            }
+            LocalRepoService.runProcess(context, packageNames.toArray(new String[0]));
+
+            updater = new IndexUpdater(context, repo);
+            updater.update();
+            assertTrue(updater.hasChanged());
+            assertTrue("repo lastUpdated should be updated", lastUpdated.compareTo(repo.lastUpdated) < 0);
+
+            for (String packageName : packageNames) {
+                assertNotNull(ApkProvider.Helper.findByPackageName(context, packageName));
+            }
+        } finally {
+            if (localHttpd != null) {
+                localHttpd.stop();
+            }
+        }
+        if (localHttpd != null) {
+            assertFalse(localHttpd.isAlive());
+        }
+    }
+
+    private boolean isPortInUse(String host, int port) {
+        boolean result = false;
+
+        try {
+            (new Socket(host, port)).close();
+            result = true;
+        } catch (IOException e) {
+            // Could not connect.
+            e.printStackTrace();
+        }
+        return result;
+    }
+
+    private boolean isSystemPackage(ResolveInfo resolveInfo) {
+        return (resolveInfo.activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) != 0;
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/work/CleanCacheWorkerTest.java

@@ -0,0 +1,110 @@
+package org.fdroid.fdroid.work;
+
+import android.app.Instrumentation;
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule;
+import androidx.test.filters.LargeTest;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.WorkInfo;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.apache.commons.io.FileUtils;
+import org.fdroid.fdroid.compat.FileCompatTest;
+import org.junit.Rule;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * This test cannot run on Robolectric unfortunately since it does not support
+ * getting the timestamps from the files completely.
+ * <p>
+ * This is marked with {@link LargeTest} because it always fails on the emulator
+ * tests on GitLab CI.  That excludes it from the test run there.
+ */
+@LargeTest
+public class CleanCacheWorkerTest {
+    public static final String TAG = "CleanCacheWorkerEmulatorTest";
+
+    @Rule
+    public InstantTaskExecutorRule instantTaskExecutorRule = new InstantTaskExecutorRule();
+
+    @Rule
+    public WorkManagerTestRule workManagerTestRule = new WorkManagerTestRule();
+
+    @Test
+    public void testWorkRequest() throws ExecutionException, InterruptedException {
+        OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(CleanCacheWorker.class).build();
+        workManagerTestRule.workManager.enqueue(request).getResult();
+        ListenableFuture<WorkInfo> workInfo = workManagerTestRule.workManager.getWorkInfoById(request.getId());
+        assertEquals(WorkInfo.State.SUCCEEDED, workInfo.get().getState());
+    }
+
+    @Test
+    public void testClearOldFiles() throws IOException, InterruptedException {
+        Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+        File tempDir = FileCompatTest.getWriteableDir(instrumentation);
+        assertTrue(tempDir.isDirectory());
+        assertTrue(tempDir.canWrite());
+
+        File dir = new File(tempDir, "F-Droid-test.clearOldFiles");
+        FileUtils.deleteQuietly(dir);
+        assertTrue(dir.mkdirs());
+        assertTrue(dir.isDirectory());
+
+        File first = new File(dir, "first");
+        first.deleteOnExit();
+
+        File second = new File(dir, "second");
+        second.deleteOnExit();
+
+        assertFalse(first.exists());
+        assertFalse(second.exists());
+
+        assertTrue(first.createNewFile());
+        assertTrue(first.exists());
+
+        Thread.sleep(7000);
+        assertTrue(second.createNewFile());
+        assertTrue(second.exists());
+
+        CleanCacheWorker.clearOldFiles(dir, 3000); // check all in dir
+        assertFalse(first.exists());
+        assertTrue(second.exists());
+
+        Thread.sleep(7000);
+        CleanCacheWorker.clearOldFiles(second, 3000); // check just second file
+        assertFalse(first.exists());
+        assertFalse(second.exists());
+
+        // make sure it doesn't freak out on a non-existent file
+        File nonexistent = new File(tempDir, "nonexistent");
+        CleanCacheWorker.clearOldFiles(nonexistent, 1);
+        CleanCacheWorker.clearOldFiles(null, 1);
+    }
+
+    /*
+    // TODO enable this once getImageCacheDir() can be mocked or provide a writable dir in the test
+    @Test
+    public void testDeleteOldIcons() throws IOException {
+        Context context = InstrumentationRegistry.getInstrumentation().getContext();
+        File imageCacheDir = Utils.getImageCacheDir(context);
+        imageCacheDir.mkdirs();
+        assertTrue(imageCacheDir.isDirectory());
+        File oldIcon = new File(imageCacheDir, "old.png");
+        assertTrue(oldIcon.createNewFile());
+        Assume.assumeTrue("test environment must be able to set LastModified time",
+                oldIcon.setLastModified(System.currentTimeMillis() - (DateUtils.DAY_IN_MILLIS * 370)));
+        File currentIcon = new File(imageCacheDir, "current.png");
+        assertTrue(currentIcon.createNewFile());
+        CleanCacheWorker.deleteOldIcons(context);
+        assertTrue(currentIcon.exists());
+        assertFalse(oldIcon.exists());
+    }
+     */
+}

app/src/androidTest/java/org/fdroid/fdroid/work/FDroidMetricsWorkerTest.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2021  Hans-Christoph Steiner <hans@eds.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.work;
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule;
+import androidx.test.filters.LargeTest;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.work.OneTimeWorkRequest;
+import androidx.work.WorkInfo;
+import com.google.common.util.concurrent.ListenableFuture;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.util.concurrent.ExecutionException;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * This actually runs {@link FDroidMetricsWorker} on a device/emulator and
+ * submits a report to https://metrics.cleaninsights.org
+ * <p>
+ * This is marked with {@link LargeTest} to exclude it from running on GitLab CI
+ * because it always fails on the emulator tests there.  Also, it actually submits
+ * a report.
+ */
+@LargeTest
+public class FDroidMetricsWorkerTest {
+    public static final String TAG = "FDroidMetricsWorkerTest";
+
+    @Rule
+    public InstantTaskExecutorRule instantTaskExecutorRule = new InstantTaskExecutorRule();
+
+    @Rule
+    public WorkManagerTestRule workManagerTestRule = new WorkManagerTestRule();
+
+    /**
+     * A test for easy manual testing.
+     */
+    @Ignore
+    @Test
+    public void testGenerateReport() throws IOException {
+        String json = FDroidMetricsWorker.generateReport(
+                InstrumentationRegistry.getInstrumentation().getTargetContext());
+        System.out.println(json);
+    }
+
+    @Test
+    public void testWorkRequest() throws ExecutionException, InterruptedException {
+        OneTimeWorkRequest request = new OneTimeWorkRequest.Builder(FDroidMetricsWorker.class).build();
+        workManagerTestRule.workManager.enqueue(request).getResult();
+        ListenableFuture<WorkInfo> workInfo = workManagerTestRule.workManager.getWorkInfoById(request.getId());
+        assertEquals(WorkInfo.State.SUCCEEDED, workInfo.get().getState());
+    }
+}

app/src/androidTest/java/org/fdroid/fdroid/work/WorkManagerTestRule.java

@@ -0,0 +1,33 @@
+package org.fdroid.fdroid.work;
+
+import android.app.Instrumentation;
+import android.content.Context;
+import android.util.Log;
+import androidx.test.platform.app.InstrumentationRegistry;
+import androidx.work.Configuration;
+import androidx.work.WorkManager;
+import androidx.work.testing.SynchronousExecutor;
+import androidx.work.testing.WorkManagerTestInitHelper;
+import org.junit.rules.TestWatcher;
+import org.junit.runner.Description;
+
+public class WorkManagerTestRule extends TestWatcher {
+    Context targetContext;
+    Context testContext;
+    Configuration configuration;
+    WorkManager workManager;
+
+    @Override
+    protected void starting(Description description) {
+        final Instrumentation instrumentation = InstrumentationRegistry.getInstrumentation();
+        targetContext = instrumentation.getTargetContext();
+        testContext = instrumentation.getContext();
+        configuration = new Configuration.Builder()
+                .setMinimumLoggingLevel(Log.DEBUG)
+                .setExecutor(new SynchronousExecutor())
+                .build();
+
+        WorkManagerTestInitHelper.initializeTestWorkManager(targetContext, configuration);
+        workManager = WorkManager.getInstance(targetContext);
+    }
+}

app/src/androidTest/proguard-rules.pro

@@ -1,3 +1,7 @@
+-dontoptimize
+-dontwarn
+-dontobfuscate
+
 -dontwarn android.test.**
 -dontwarn android.support.test.**
 -dontnote junit.framework.**
@@ -14,3 +18,8 @@
 
 -keep class junit.** { *; }
 -dontwarn junit.**
+
+# This is necessary so that RemoteWorkManager can be initialized (also marked with @Keep)
+-keep class androidx.work.multiprocess.RemoteWorkManagerClient {
+    public <init>(...);
+}

app/src/basic/java/org/fdroid/fdroid/nearby/BluetoothClient.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+
+public class BluetoothClient {
+
+    public BluetoothClient(String ignored) {
+    }
+
+    public BluetoothConnection openConnection() {
+        return null;
+    }
+}

app/src/basic/java/org/fdroid/fdroid/nearby/LocalRepoManager.java

@@ -0,0 +1,5 @@
+package org.fdroid.fdroid.nearby;
+
+public class LocalRepoManager {
+    public static final String[] WEB_ROOT_ASSET_FILES = {};
+}

app/src/basic/java/org/fdroid/fdroid/nearby/SDCardScannerService.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 Hans-Christoph Steiner <hans@eds.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class SDCardScannerService {
+    public static void scan(Context context) {
+    }
+}

app/src/basic/java/org/fdroid/fdroid/nearby/SwapService.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 Hans-Christoph Steiner <hans@eds.org>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class SwapService {
+    public static void start(Context context) {
+    }
+}

app/src/basic/java/org/fdroid/fdroid/nearby/SwapWorkflowActivity.java

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+import android.net.Uri;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class SwapWorkflowActivity {
+
+    public static final String EXTRA_PREVENT_FURTHER_SWAP_REQUESTS = "preventFurtherSwap";
+
+    public static void requestSwap(Context context, Uri uri) {
+    }
+}

app/src/basic/java/org/fdroid/fdroid/nearby/TreeUriScannerIntentService.java

@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby;
+
+import androidx.appcompat.app.AppCompatActivity;
+import android.content.Intent;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class TreeUriScannerIntentService {
+    public static void onActivityResult(AppCompatActivity activity, Intent intent) {
+        throw new IllegalStateException("unimplemented");
+    }
+}

app/src/basic/java/org/fdroid/fdroid/nearby/WifiStateChangeService.java

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+import android.content.Intent;
+import androidx.annotation.Nullable;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class WifiStateChangeService {
+    public static void start(Context context, @Nullable Intent intent) {
+    }
+
+    public class WifiInfoThread extends Thread {
+    }
+}

app/src/basic/java/org/fdroid/fdroid/nearby/peers/WifiPeer.java

@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.nearby.peers;
+
+import org.fdroid.fdroid.data.NewRepoConfig;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class WifiPeer {
+    public WifiPeer(NewRepoConfig config) {
+    }
+}

app/src/basic/java/org/fdroid/fdroid/panic/HidingManager.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.panic;
+
+import android.content.Context;
+
+/**
+ * Dummy version for basic app flavor.
+ */
+public class HidingManager {
+
+    public static boolean isHidden(Context context) {
+        return false;
+    }
+
+    public static void showHideDialog(final Context context) {
+        throw new IllegalStateException("unimplemented");
+    }
+
+}

app/src/basic/java/org/fdroid/fdroid/views/main/MainViewController.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
+ * MA 02110-1301, USA.
+ */
+
+package org.fdroid.fdroid.views.main;
+
+import android.widget.FrameLayout;
+import androidx.annotation.Nullable;
+import androidx.appcompat.app.AppCompatActivity;
+import androidx.fragment.app.Fragment;
+import androidx.recyclerview.widget.RecyclerView;
+import org.fdroid.fdroid.R;
+import org.fdroid.fdroid.views.PreferencesFragment;
+import org.fdroid.fdroid.views.updates.UpdatesViewBinder;
+
+/**
+ * Decides which view on the main screen to attach to a given {@link FrameLayout}. This class
+ * doesn't know which view it will be rendering at the time it is constructed. Rather, at some
+ * point in the future the {@link MainViewAdapter} will have information about which view we
+ * are required to render, and will invoke the relevant "bind*()" method on this class.
+ */
+class MainViewController extends RecyclerView.ViewHolder {
+
+    private final AppCompatActivity activity;
+    private final FrameLayout frame;
+
+    @Nullable
+    private UpdatesViewBinder updatesView = null;
+
+    MainViewController(AppCompatActivity activity, FrameLayout frame) {
+        super(frame);
+        this.activity = activity;
+        this.frame = frame;
+    }
+
+    /**
+     * @see LatestViewBinder
+     */
+    public void bindLatestView() {
+        new LatestViewBinder(activity, frame);
+    }
+
+    /**
+     * @see UpdatesViewBinder
+     */
+    public void bindUpdates() {
+        if (updatesView == null) {
+            updatesView = new UpdatesViewBinder(activity, frame);
+        }
+
+        updatesView.bind();
+    }
+
+    public void unbindUpdates() {
+        if (updatesView != null) {
+            updatesView.unbind();
+        }
+    }
+
+    public void bindCategoriesView() {
+        throw new IllegalStateException("unimplemented");
+    }
+
+    public void bindSwapView() {
+        throw new IllegalStateException("unimplemented");
+    }
+
+    /**
+     * Attaches a {@link PreferencesFragment} to the view. Everything else is managed by the
+     * fragment itself, so no further work needs to be done by this view binder.
+     * <p>
+     * Note: It is tricky to attach a {@link Fragment} to a view from this view holder. This is due
+     * to the way in which the {@link RecyclerView} will reuse existing views and ask us to
+     * put a settings fragment in there at arbitrary times. Usually it wont be the same view we
+     * attached the fragment to last time, which causes weirdness. The solution is to use code from
+     * the com.lsjwzh.widget.recyclerviewpager.FragmentStatePagerAdapter which manages this.
+     * The code has been ported to {@link SettingsView}.
+     *
+     * @see SettingsView
+     */
+    public void bindSettingsView() {
+        activity.getLayoutInflater().inflate(R.layout.main_tab_settings, frame, true);
+    }
+}

app/src/basic/java/org/fdroid/fdroid/views/main/NearbyViewBinder.java

@@ -0,0 +1,9 @@
+package org.fdroid.fdroid.views.main;
+
+import android.content.Context;
+
+class NearbyViewBinder {
+    public static void updateUsbOtg(Context context) {
+        throw new IllegalStateException("unimplemented");
+    }
+}

app/src/basic/res/menu/main_activity_screens.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+      xmlns:app="http://schemas.android.com/apk/res-auto"
+      xmlns:tools="http://schemas.android.com/tools"
+      tools:ignore="MenuTitle">
+    <!-- android:title and android:icon are set dynamically in MainActivity -->
+    <item
+            app:showAsAction="ifRoom|withText"
+            android:id="@+id/latest"/>
+    <item
+            app:showAsAction="ifRoom|withText"
+            android:id="@+id/updates"/>
+    <item
+            app:showAsAction="ifRoom|withText"
+            android:id="@+id/settings"/>
+</menu>

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

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name">F-Droid Basic</string>
+    <string name="about_title">About F-Droid Basic</string>
+</resources>

app/src/basic/res/xml/preferences.xml

@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <PreferenceScreen android:title="@string/about_title"
+        android:key="pref_about" />
+
+    <PreferenceCategory android:title="@string/preference_category__my_apps">
+        <PreferenceScreen android:title="@string/preference_manage_installed_apps">
+            <intent
+                    android:action="android.intent.action.MAIN"
+                    android:targetPackage="@string/applicationId"
+                    android:targetClass="org.fdroid.fdroid.views.installed.InstalledAppsActivity"/>
+        </PreferenceScreen>
+        <PreferenceScreen
+                android:title="@string/menu_manage"
+                android:summary="@string/repositories_summary">
+            <intent
+                    android:action="android.intent.action.MAIN"
+                    android:targetPackage="@string/applicationId"
+                    android:targetClass="org.fdroid.fdroid.views.ManageReposActivity"/>
+        </PreferenceScreen>
+        <PreferenceScreen
+                android:key="installHistory"
+                android:visible="false"
+                android:title="@string/install_history"
+                android:summary="@string/install_history_summary">
+            <intent
+                    android:action="android.intent.action.MAIN"
+                    android:targetPackage="@string/applicationId"
+                    android:targetClass="org.fdroid.fdroid.views.InstallHistoryActivity"/>
+        </PreferenceScreen>
+    </PreferenceCategory>
+
+    <PreferenceCategory android:title="@string/updates">
+        <org.fdroid.fdroid.views.LiveSeekBarPreference
+                android:key="overWifi"
+                android:title="@string/over_wifi"
+                android:defaultValue="@integer/defaultOverWifi"
+                android:layout="@layout/preference_seekbar"/>
+        <org.fdroid.fdroid.views.LiveSeekBarPreference
+                android:key="overData"
+                android:title="@string/over_data"
+                android:defaultValue="@integer/defaultOverData"
+                android:layout="@layout/preference_seekbar"/>
+        <SwitchPreferenceCompat
+                android:title="@string/update_auto_download"
+                android:summary="@string/update_auto_download_summary"
+                android:key="updateAutoDownload"/>
+        <org.fdroid.fdroid.views.LiveSeekBarPreference
+                android:key="updateIntervalSeekBarPosition"
+                android:title="@string/update_interval"
+                android:defaultValue="@integer/defaultUpdateInterval"
+                android:layout="@layout/preference_seekbar"/>
+        <SwitchPreferenceCompat
+                android:title="@string/notify"
+                android:defaultValue="true"
+                android:key="updateNotify"/>
+    </PreferenceCategory>
+
+    <PreferenceCategory android:title="@string/display"
+                                                      android:key="pref_category_display">
+        <ListPreference
+                android:title="@string/pref_language"
+                android:key="language"/>
+        <ListPreference
+                android:title="@string/theme"
+                android:key="theme"
+                android:defaultValue="light"
+                android:entries="@array/themeNames"
+                android:entryValues="@array/themeValues"/>
+    </PreferenceCategory>
+
+    <PreferenceCategory android:title="@string/appcompatibility"
+                                                      android:key="pref_category_appcompatibility">
+        <SwitchPreferenceCompat
+                android:title="@string/show_incompat_versions"
+                android:defaultValue="false"
+                android:key="incompatibleVersions"/>
+        <SwitchPreferenceCompat
+                android:title="@string/show_anti_feature_apps"
+                android:defaultValue="false"
+                android:key="showAntiFeatureApps"/>
+        <SwitchPreferenceCompat
+                android:title="@string/force_touch_apps"
+                android:defaultValue="false"
+                android:key="ignoreTouchscreen"/>
+    </PreferenceCategory>
+
+    <PreferenceCategory android:title="@string/proxy">
+        <SwitchPreferenceCompat
+                android:key="useTor"
+                android:summary="@string/useTorSummary"
+                android:title="@string/useTor"/>
+        <SwitchPreferenceCompat
+                android:defaultValue="false"
+                android:key="enableProxy"
+                android:title="@string/enable_proxy_title"
+                android:summary="@string/enable_proxy_summary"/>
+        <EditTextPreference
+                android:key="proxyHost"
+                android:title="@string/proxy_host"
+                android:summary="@string/proxy_host_summary"
+                android:dependency="enableProxy"/>
+        <EditTextPreference
+                android:key="proxyPort"
+                android:title="@string/proxy_port"
+                android:summary="@string/proxy_port_summary"
+                android:dependency="enableProxy"/>
+    </PreferenceCategory>
+
+    <PreferenceCategory
+            android:key="pref_category_privacy"
+            android:title="@string/privacy">
+        <SwitchPreferenceCompat
+                android:key="promptToSendCrashReports"
+                android:title="@string/prompt_to_send_crash_reports"
+                android:summary="@string/prompt_to_send_crash_reports_summary"
+                android:defaultValue="true"/>
+        <SwitchPreferenceCompat
+                android:defaultValue="false"
+                android:key="preventScreenshots"
+                android:summary="@string/preventScreenshots_summary"
+                android:title="@string/preventScreenshots_title"/>
+    </PreferenceCategory>
+
+    <PreferenceCategory
+            android:title="@string/other"
+            android:key="pref_category_other">
+        <ListPreference
+                android:title="@string/cache_downloaded"
+                android:key="keepCacheFor"
+                android:defaultValue="86400000"
+                android:entries="@array/keepCacheNames"
+                android:entryValues="@array/keepCacheValues"/>
+        <SwitchPreferenceCompat
+                android:title="@string/expert"
+                android:defaultValue="false"
+                android:key="expert"/>
+        <CheckBoxPreference
+                android:key="unstableUpdates"
+                android:title="@string/unstable_updates"
+                android:summary="@string/unstable_updates_summary"
+                android:defaultValue="false"
+                android:dependency="expert"/>
+        <CheckBoxPreference
+                android:key="keepInstallHistory"
+                android:title="@string/keep_install_history"
+                android:summary="@string/keep_install_history_summary"
+                android:defaultValue="false"
+                android:dependency="expert"/>
+        <CheckBoxPreference
+                android:key="sendToFdroidMetrics"
+                android:title="@string/send_to_fdroid_metrics"
+                android:summary="@string/send_to_fdroid_metrics_summary"
+                android:defaultValue="false"
+                android:dependency="expert"/>
+        <CheckBoxPreference
+                android:key="hideAllNotifications"
+                android:title="@string/hide_all_notifications"
+                android:summary="@string/hide_all_notifications_summary"
+                android:defaultValue="false"
+                android:dependency="expert"/>
+        <CheckBoxPreference
+                android:key="sendVersionAndUUIDToServers"
+                android:title="@string/send_version_and_uuid"
+                android:summary="@string/send_version_and_uuid_summary"
+                android:defaultValue="false"
+                android:dependency="expert"/>
+        <CheckBoxPreference
+                android:key="forceOldIndex"
+                android:title="@string/force_old_index"
+                android:summary="@string/force_old_index_summary"
+                android:defaultValue="false"
+                android:dependency="expert"/>
+        <CheckBoxPreference
+                android:title="@string/system_installer"
+                android:defaultValue="false"
+                android:key="privilegedInstaller"
+                android:persistent="false"
+                android:dependency="expert"/>
+    </PreferenceCategory>
+
+</PreferenceScreen>

app/src/debug/AndroidManifest.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- This file should be outside of release manifest (in this case app/src/mock/Manifest.xml -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!--required to enable/disable system animations from the app itself during Espresso test runs-->
+    <uses-permission android:name="android.permission.SET_ANIMATION_SCALE" />
+</manifest>

app/src/full/AndroidManifest.xml

@@ -0,0 +1,179 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+ * Copyright (C) 2010-2012 Ciaran Gultnieks
+ * Copyright (C) 2013-2017 Peter Serwylo
+ * Copyright (C) 2014-2015 Daniel Martí
+ * Copyright (C) 2014-2018 Hans-Christoph Steiner
+ * Copyright (C) 2016 Dominik Schürmann
+ * Copyright (C) 2018 Torsten Grote
+ * Copyright (C) 2018 Senecto Limited
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.fdroid.fdroid"
+    android:installLocation="auto">
+
+    <uses-feature
+        android:name="android.hardware.nfc"
+        android:required="false" />
+    <uses-feature
+        android:name="android.hardware.bluetooth"
+        android:required="false" />
+
+    <uses-feature
+        android:name="android.hardware.usb.host"
+        android:required="false" />
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WRITE_SETTINGS" />
+    <uses-permission android:name="android.permission.NFC" />
+    <uses-permission
+        android:name="android.permission.USB_PERMISSION"
+        android:maxSdkVersion="22" /><!-- maybe unnecessary -->
+
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+
+    <uses-permission-sdk-23 android:name="android.permission.ACCESS_COARSE_LOCATION" />
+
+    <application>
+
+        <activity
+            android:name=".nearby.SwapWorkflowActivity"
+            android:configChanges="orientation|keyboardHidden"
+            android:label="@string/swap"
+            android:launchMode="singleTask"
+            android:parentActivityName=".views.main.MainActivity"
+            android:screenOrientation="portrait">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value=".views.main.MainActivity" />
+        </activity>
+
+        <activity
+            android:name=".panic.PanicPreferencesActivity"
+            android:label="@string/panic_settings"
+            android:parentActivityName=".views.main.MainActivity">
+            <intent-filter>
+                <action android:name="info.guardianproject.panic.action.CONNECT" />
+                <action android:name="info.guardianproject.panic.action.DISCONNECT" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value=".views.main.MainActivity" />
+        </activity>
+
+        <activity
+            android:name=".panic.SelectInstalledAppsActivity"
+            android:parentActivityName=".panic.PanicPreferencesActivity" />
+
+        <activity
+            android:name=".panic.PanicResponderActivity"
+            android:noHistory="true"
+            android:theme="@android:style/Theme.NoDisplay">
+
+            <!-- this can never have launchMode singleTask or singleInstance! -->
+            <intent-filter>
+                <action android:name="info.guardianproject.panic.action.TRIGGER" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".panic.ExitActivity"
+            android:theme="@android:style/Theme.NoDisplay" />
+
+        <activity
+            android:name=".panic.CalculatorActivity"
+            android:enabled="false"
+            android:icon="@mipmap/ic_calculator_launcher"
+            android:label="@string/hiding_calculator">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <receiver android:name=".nearby.WifiStateChangeReceiver">
+            <intent-filter>
+                <action android:name="android.net.wifi.STATE_CHANGE" />
+            </intent-filter>
+        </receiver>
+        <receiver android:name=".receiver.DeviceStorageReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.DEVICE_STORAGE_LOW" />
+            </intent-filter>
+        </receiver>
+
+        <receiver android:name=".nearby.UsbDeviceAttachedReceiver">
+            <intent-filter>
+                <action android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED" />
+            </intent-filter>
+            <meta-data
+                android:name="android.hardware.usb.action.USB_DEVICE_ATTACHED"
+                android:resource="@xml/device_filter" />
+        </receiver>
+        <receiver android:name=".nearby.UsbDeviceDetachedReceiver">
+            <intent-filter>
+                <action android:name="android.hardware.usb.action.USB_DEVICE_DETACHED" />
+            </intent-filter>
+            <meta-data
+                android:name="android.hardware.usb.action.USB_DEVICE_DETACHED"
+                android:resource="@xml/device_filter" />
+        </receiver>
+        <receiver android:name=".nearby.UsbDeviceMediaMountedReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_EJECT" />
+                <action android:name="android.intent.action.MEDIA_REMOVED" />
+                <action android:name="android.intent.action.MEDIA_MOUNTED" />
+                <action android:name="android.intent.action.MEDIA_BAD_REMOVAL" />
+
+                <data android:scheme="content" />
+                <data android:scheme="file" />
+            </intent-filter>
+        </receiver>
+
+        <service
+            android:name=".nearby.WifiStateChangeService"
+            android:exported="false" />
+        <service android:name=".nearby.SwapService" />
+
+        <service
+            android:name=".nearby.LocalRepoService"
+            android:exported="false" />
+        <service
+            android:name=".nearby.TreeUriScannerIntentService"
+            android:exported="false" />
+        <service
+            android:name=".nearby.SDCardScannerService"
+            android:exported="false" />
+
+    </application>
+
+</manifest>

app/src/full/java/javax/jmdns/impl/FDroidServiceInfo.java

@@ -9,6 +9,7 @@ import java.net.Inet6Address;
 import java.net.UnknownHostException;
 
 import javax.jmdns.ServiceInfo;
+import javax.jmdns.impl.util.ByteWrangler;
 
 /**
  * The ServiceInfo class needs to be serialized in order to be sent as an Android broadcast.
@@ -32,7 +33,7 @@ public class FDroidServiceInfo extends ServiceInfoImpl implements Parcelable {
         if (data == null || data.length == 0) {
             return null;
         }
-        String fingerprint = this.readUTF(data, 0, data.length);
+        String fingerprint = ByteWrangler.readUTF(data, 0, data.length);
         if (TextUtils.isEmpty(fingerprint)) {
             return null;
         }
@@ -51,14 +52,14 @@ public class FDroidServiceInfo extends ServiceInfoImpl implements Parcelable {
 
     public FDroidServiceInfo(Parcel in) {
         super(
-            in.readString(),
-            in.readString(),
-            in.readString(),
-            in.readInt(),
-            in.readInt(),
-            in.readInt(),
-            in.readByte() != 0,
-            readBytes(in)
+                in.readString(),
+                in.readString(),
+                in.readString(),
+                in.readInt(),
+                in.readInt(),
+                in.readInt(),
+                in.readByte() != 0,
+                readBytes(in)
         );
 
         int addressCount = in.readInt();

app/src/full/java/kellinwood/logging/AbstractLogger.java

@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2010 Ken Ellinwood.
+ *
+ * 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 kellinwood.logging;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+public abstract class AbstractLogger implements LoggerInterface {
+
+    protected String category;
+
+    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss", Locale.ENGLISH);
+
+    public AbstractLogger(String category) {
+        this.category = category;
+    }
+
+    protected String format(String level, String message) {
+        return String.format("%s %s %s: %s\n", dateFormat.format(new Date()), level, category, message);
+    }
+
+    protected abstract void write(String level, String message, Throwable t);
+
+    protected void writeFixNullMessage(String level, String message, Throwable t) {
+        if (message == null) {
+            if (t != null) message = t.getClass().getName();
+            else message = "null";
+        }
+        write(level, message, t);
+    }
+
+    public void debug(String message, Throwable t) {
+        writeFixNullMessage(DEBUG, message, t);
+    }
+
+    public void debug(String message) {
+        writeFixNullMessage(DEBUG, message, null);
+    }
+
+    public void error(String message, Throwable t) {
+        writeFixNullMessage(ERROR, message, t);
+    }
+
+    public void error(String message) {
+        writeFixNullMessage(ERROR, message, null);
+    }
+
+    public void info(String message, Throwable t) {
+        writeFixNullMessage(INFO, message, t);
+    }
+
+    public void info(String message) {
+        writeFixNullMessage(INFO, message, null);
+    }
+
+    public void warning(String message, Throwable t) {
+        writeFixNullMessage(WARNING, message, t);
+    }
+
+    public void warning(String message) {
+        writeFixNullMessage(WARNING, message, null);
+    }
+
+    public boolean isDebugEnabled() {
+        return true;
+    }
+
+    public boolean isErrorEnabled() {
+        return true;
+    }
+
+    public boolean isInfoEnabled() {
+        return true;
+    }
+
+    public boolean isWarningEnabled() {
+        return true;
+    }
+}

app/src/full/java/kellinwood/logging/ConsoleLoggerFactory.java

@@ -13,11 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.logging;
 
 public class ConsoleLoggerFactory implements LoggerFactory {
 
-	public LoggerInterface getLogger(String category) {
-		return new StreamLogger( category, System.out);
-	}
+    public LoggerInterface getLogger(String category) {
+        return new StreamLogger(category, System.out);
+    }
 }

app/src/full/java/kellinwood/logging/LoggerFactory.java

@@ -13,9 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.logging;
 
 public interface LoggerFactory {
 
-	public LoggerInterface getLogger( String category);
+    public LoggerInterface getLogger(String category);
 }

app/src/full/java/kellinwood/logging/LoggerInterface.java

@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2010 Ken Ellinwood.
+ *
+ * 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 kellinwood.logging;
+
+public interface LoggerInterface {
+
+    public static final String ERROR = "ERROR";
+    public static final String WARNING = "WARNING";
+    public static final String INFO = "INFO";
+    public static final String DEBUG = "DEBUG";
+
+    public boolean isErrorEnabled();
+
+    public void error(String message);
+
+    public void error(String message, Throwable t);
+
+
+    public boolean isWarningEnabled();
+
+    public void warning(String message);
+
+    public void warning(String message, Throwable t);
+
+    public boolean isInfoEnabled();
+
+    public void info(String message);
+
+    public void info(String message, Throwable t);
+
+    public boolean isDebugEnabled();
+
+    public void debug(String message);
+
+    public void debug(String message, Throwable t);
+
+
+}

app/src/full/java/kellinwood/logging/LoggerManager.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.logging;
 
 import java.util.Map;
@@ -20,21 +21,21 @@ import java.util.TreeMap;
 
 public class LoggerManager {
 
-	static LoggerFactory factory = new NullLoggerFactory();
-	
-	static Map<String,LoggerInterface> loggers = new TreeMap<String,LoggerInterface>();
-	
-	public static void setLoggerFactory( LoggerFactory f) {
-		factory = f;
-	}
-	
-	public static LoggerInterface getLogger(String category) {
-		
-		LoggerInterface logger = loggers.get( category);
-		if (logger == null) {
-			logger = factory.getLogger(category);
-			loggers.put( category, logger);
-		}
-		return logger;
-	}
+    static LoggerFactory factory = new NullLoggerFactory();
+
+    static Map<String, LoggerInterface> loggers = new TreeMap<String, LoggerInterface>();
+
+    public static void setLoggerFactory(LoggerFactory f) {
+        factory = f;
+    }
+
+    public static LoggerInterface getLogger(String category) {
+
+        LoggerInterface logger = loggers.get(category);
+        if (logger == null) {
+            logger = factory.getLogger(category);
+            loggers.put(category, logger);
+        }
+        return logger;
+    }
 }

app/src/full/java/kellinwood/logging/NullLoggerFactory.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2010 Ken Ellinwood.
+ *
+ * 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 kellinwood.logging;
+
+public class NullLoggerFactory implements LoggerFactory {
+
+    static LoggerInterface logger = new LoggerInterface() {
+
+        public void debug(String message) {
+        }
+
+        public void debug(String message, Throwable t) {
+        }
+
+        public void error(String message) {
+        }
+
+        public void error(String message, Throwable t) {
+        }
+
+        public void info(String message) {
+        }
+
+        public void info(String message, Throwable t) {
+        }
+
+        public boolean isDebugEnabled() {
+            return false;
+        }
+
+        public boolean isErrorEnabled() {
+            return false;
+        }
+
+        public boolean isInfoEnabled() {
+            return false;
+        }
+
+        public boolean isWarningEnabled() {
+            return false;
+        }
+
+        public void warning(String message) {
+        }
+
+        public void warning(String message, Throwable t) {
+        }
+
+    };
+
+
+    public LoggerInterface getLogger(String category) {
+        return logger;
+    }
+
+}

app/src/full/java/kellinwood/logging/StreamLogger.java

@@ -13,24 +13,24 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.logging;
 
 import java.io.PrintStream;
 
 public class StreamLogger extends AbstractLogger {
 
-	PrintStream out;
-	
-	public StreamLogger( String category, PrintStream out)
-	{
-		super( category);
-		this.out = out;
-	}
-	
-	@Override
-	protected void write(String level, String message, Throwable t) {
-		out.print( format( level, message));
-		if (t != null) t.printStackTrace(out);
-	}
+    PrintStream out;
+
+    public StreamLogger(String category, PrintStream out) {
+        super(category);
+        this.out = out;
+    }
+
+    @Override
+    protected void write(String level, String message, Throwable t) {
+        out.print(format(level, message));
+        if (t != null) t.printStackTrace(out);
+    }
 
 }

app/src/full/java/kellinwood/security/zipsigner/AutoKeyException.java

@@ -1,14 +1,15 @@
+
 package kellinwood.security.zipsigner;
 
 public class AutoKeyException extends RuntimeException {
 
     private static final long serialVersionUID = 1L;
 
-    public AutoKeyException( String message) {
+    public AutoKeyException(String message) {
         super(message);
     }
-    
-    public AutoKeyException( String message, Throwable cause) {
+
+    public AutoKeyException(String message, Throwable cause) {
         super(message, cause);
-    }    
+    }
 }

app/src/full/java/kellinwood/security/zipsigner/Base64.java

@@ -15,15 +15,16 @@
  */
 
 
+
 package kellinwood.security.zipsigner;
 
+import kellinwood.logging.LoggerInterface;
+import kellinwood.logging.LoggerManager;
+
 import java.io.ByteArrayOutputStream;
 import java.io.OutputStream;
 import java.lang.reflect.Method;
 
-import kellinwood.logging.LoggerInterface;
-import kellinwood.logging.LoggerManager;
-
 /*
  * This class provides Base64 encoding services using one of several possible 
  * implementations available elsewhere in the classpath. Supported implementations 
@@ -42,92 +43,88 @@ public class Base64 {
 
     static Method aEncodeMethod = null;  // Reference to the android.util.Base64.encode() method, if available
     static Method aDecodeMethod = null;  // Reference to the android.util.Base64.decode() method, if available
-    
+
     static Object bEncoder = null; // Reference to an org.bouncycastle.util.encoders.Base64Encoder instance, if available
     static Method bEncodeMethod = null;  // Reference to the bEncoder.encode() method, if available
-    
+
     static Object bDecoder = null; // Reference to an org.bouncycastle.util.encoders.Base64Encoder instance, if available
     static Method bDecodeMethod = null;  // Reference to the bEncoder.encode() method, if available    
-    
+
     static LoggerInterface logger = null;
-    
+
     static {
-        
+
         Class<Object> clazz;
-    
-        logger = LoggerManager.getLogger( Base64.class.getName());
-        
+
+        logger = LoggerManager.getLogger(Base64.class.getName());
+
         try {
             clazz = (Class<Object>) Class.forName("android.util.Base64");
             // Looking for encode( byte[] input, int flags)
             aEncodeMethod = clazz.getMethod("encode", byte[].class, Integer.TYPE);
             aDecodeMethod = clazz.getMethod("decode", byte[].class, Integer.TYPE);
-            logger.info( clazz.getName() + " is available.");
-        }
-        catch (ClassNotFoundException x) {} // Ignore
+            logger.info(clazz.getName() + " is available.");
+        } catch (ClassNotFoundException x) {
+        } // Ignore
         catch (Exception x) {
             logger.error("Failed to initialize use of android.util.Base64", x);
         }
-        
+
         try {
             clazz = (Class<Object>) Class.forName("org.bouncycastle.util.encoders.Base64Encoder");
             bEncoder = clazz.newInstance();
             // Looking for encode( byte[] input, int offset, int length, OutputStream output)
             bEncodeMethod = clazz.getMethod("encode", byte[].class, Integer.TYPE, Integer.TYPE, OutputStream.class);
-            logger.info( clazz.getName() + " is available.");
+            logger.info(clazz.getName() + " is available.");
             // Looking for decode( byte[] input, int offset, int length, OutputStream output)
             bDecodeMethod = clazz.getMethod("decode", byte[].class, Integer.TYPE, Integer.TYPE, OutputStream.class);
 
-        }
-        catch (ClassNotFoundException x) {} // Ignore
+        } catch (ClassNotFoundException x) {
+        } // Ignore
         catch (Exception x) {
             logger.error("Failed to initialize use of org.bouncycastle.util.encoders.Base64Encoder", x);
         }
-        
+
         if (aEncodeMethod == null && bEncodeMethod == null)
             throw new IllegalStateException("No base64 encoder implementation is available.");
     }
-    
 
-    public static String encode( byte[] data) {
+
+    public static String encode(byte[] data) {
         try {
             if (aEncodeMethod != null) {
                 // Invoking a static method call, using null for the instance value
-                byte[] encodedBytes = (byte[])aEncodeMethod.invoke(null, data, 2);
-                return new String( encodedBytes);
-            }
-            else if (bEncodeMethod != null) {
+                byte[] encodedBytes = (byte[]) aEncodeMethod.invoke(null, data, 2);
+                return new String(encodedBytes);
+            } else if (bEncodeMethod != null) {
                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
                 bEncodeMethod.invoke(bEncoder, data, 0, data.length, baos);
-                return new String( baos.toByteArray());
+                return new String(baos.toByteArray());
             }
-        }
-        catch (Exception x) {
-            throw new IllegalStateException( x.getClass().getName() + ": " + x.getMessage());
+        } catch (Exception x) {
+            throw new IllegalStateException(x.getClass().getName() + ": " + x.getMessage());
         }
 
-        
+
         throw new IllegalStateException("No base64 encoder implementation is available.");
     }
-    
-    public static byte[] decode( byte[] data) {
+
+    public static byte[] decode(byte[] data) {
         try {
             if (aDecodeMethod != null) {
                 // Invoking a static method call, using null for the instance value
-                byte[] decodedBytes = (byte[])aDecodeMethod.invoke(null, data, 2);
+                byte[] decodedBytes = (byte[]) aDecodeMethod.invoke(null, data, 2);
                 return decodedBytes;
-            }
-            else if (bDecodeMethod != null) {
+            } else if (bDecodeMethod != null) {
                 ByteArrayOutputStream baos = new ByteArrayOutputStream();
                 bDecodeMethod.invoke(bEncoder, data, 0, data.length, baos);
                 return baos.toByteArray();
             }
-        }
-        catch (Exception x) {
-            throw new IllegalStateException( x.getClass().getName() + ": " + x.getMessage());
+        } catch (Exception x) {
+            throw new IllegalStateException(x.getClass().getName() + ": " + x.getMessage());
         }
 
-        
+
         throw new IllegalStateException("No base64 encoder implementation is available.");
     }
 }

app/src/full/java/kellinwood/security/zipsigner/DefaultResourceAdapter.java

@@ -1,5 +1,8 @@
+
 package kellinwood.security.zipsigner;
 
+import java.util.Locale;
+
 /**
  * Default resource adapter.
  */
@@ -24,7 +27,7 @@ public class DefaultResourceAdapter implements ResourceAdapter {
             case GENERATING_SIGNATURE_BLOCK:
                 return "Generating signature block file";
             case COPYING_ZIP_ENTRY:
-                return String.format("Copying zip entry %d of %d", args[0], args[1]);
+                return String.format(Locale.ENGLISH, "Copying zip entry %d of %d", args[0], args[1]);
             default:
                 throw new IllegalArgumentException("Unknown item " + item);
         }

app/src/full/java/kellinwood/security/zipsigner/HexDumpEncoder.java

@@ -15,58 +15,58 @@
  */
 
 
+
 package kellinwood.security.zipsigner;
 
-import java.io.IOException;
 import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 
-/** Produces the classic hex dump with an address column, hex data
+/**
+ * Produces the classic hex dump with an address column, hex data
  * section (16 bytes per row) and right-column printable character dislpay.
- */    
-public class HexDumpEncoder
-{
+ */
+public class HexDumpEncoder {
 
     static HexEncoder encoder = new HexEncoder();
 
-    public static String encode( byte[] data) {
+    public static String encode(byte[] data) {
 
         try {
             ByteArrayOutputStream baos = new ByteArrayOutputStream();
-            encoder.encode( data, 0, data.length, baos);
+            encoder.encode(data, 0, data.length, baos);
             byte[] hex = baos.toByteArray();
 
             StringBuilder hexDumpOut = new StringBuilder();
             for (int i = 0; i < hex.length; i += 32) {
 
-                int max = Math.min(i+32, hex.length);
+                int max = Math.min(i + 32, hex.length);
 
                 StringBuilder hexOut = new StringBuilder();
                 StringBuilder chrOut = new StringBuilder();
 
-                hexOut.append( String.format("%08x: ", (i/2)));
+                hexOut.append(String.format("%08x: ", (i / 2)));
 
-                for (int j = i; j < max; j+= 2) {
-                    hexOut.append( Character.valueOf( (char)hex[j]));
-                    hexOut.append( Character.valueOf( (char)hex[j+1]));
-                    if ((j+2) % 4 == 0) hexOut.append( ' ');
+                for (int j = i; j < max; j += 2) {
+                    hexOut.append(Character.valueOf((char) hex[j]));
+                    hexOut.append(Character.valueOf((char) hex[j + 1]));
+                    if ((j + 2) % 4 == 0) hexOut.append(' ');
 
-                    int dataChar = data[j/2];
-                    if (dataChar >= 32 && dataChar < 127) chrOut.append( Character.valueOf( (char)dataChar));
-                    else chrOut.append( '.');
+                    int dataChar = data[j / 2];
+                    if (dataChar >= 32 && dataChar < 127) chrOut.append(Character.valueOf((char) dataChar));
+                    else chrOut.append('.');
 
                 }
 
-                hexDumpOut.append( hexOut.toString());
+                hexDumpOut.append(hexOut.toString());
                 for (int k = hexOut.length(); k < 50; k++) hexDumpOut.append(' ');
-                hexDumpOut.append( "  ");
-                hexDumpOut.append( chrOut);
+                hexDumpOut.append("  ");
+                hexDumpOut.append(chrOut);
                 hexDumpOut.append("\n");
             }
 
             return hexDumpOut.toString();
-        }
-        catch (IOException x) {
-            throw new IllegalStateException( x.getClass().getName() + ": " + x.getMessage());
+        } catch (IOException x) {
+            throw new IllegalStateException(x.getClass().getName() + ": " + x.getMessage());
         }
     }
 

app/src/full/java/kellinwood/security/zipsigner/HexEncoder.java

@@ -1,3 +1,4 @@
+
 package kellinwood.security.zipsigner;
 
 /*
@@ -32,26 +33,23 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 import java.io.IOException;
 import java.io.OutputStream;
 
-public class HexEncoder
-{
+public class HexEncoder {
     protected final byte[] encodingTable =
-        {
-            (byte)'0', (byte)'1', (byte)'2', (byte)'3', (byte)'4', (byte)'5', (byte)'6', (byte)'7',
-            (byte)'8', (byte)'9', (byte)'a', (byte)'b', (byte)'c', (byte)'d', (byte)'e', (byte)'f'
-        };
-    
+            {
+                    (byte) '0', (byte) '1', (byte) '2', (byte) '3', (byte) '4', (byte) '5', (byte) '6', (byte) '7',
+                    (byte) '8', (byte) '9', (byte) 'a', (byte) 'b', (byte) 'c', (byte) 'd', (byte) 'e', (byte) 'f'
+            };
+
     /*
      * set up the decoding table.
      */
     protected final byte[] decodingTable = new byte[128];
 
-    protected void initialiseDecodingTable()
-    {
-        for (int i = 0; i < encodingTable.length; i++)
-        {
-            decodingTable[encodingTable[i]] = (byte)i;
+    protected void initialiseDecodingTable() {
+        for (int i = 0; i < encodingTable.length; i++) {
+            decodingTable[encodingTable[i]] = (byte) i;
         }
-        
+
         decodingTable['A'] = decodingTable['a'];
         decodingTable['B'] = decodingTable['b'];
         decodingTable['C'] = decodingTable['c'];
@@ -59,27 +57,24 @@ public class HexEncoder
         decodingTable['E'] = decodingTable['e'];
         decodingTable['F'] = decodingTable['f'];
     }
-    
-    public HexEncoder()
-    {
+
+    public HexEncoder() {
         initialiseDecodingTable();
     }
-    
+
     /**
      * encode the input data producing a Hex output stream.
      *
      * @return the number of bytes produced.
      */
     public int encode(
-        byte[]                data,
-        int                    off,
-        int                    length,
-        OutputStream    out) 
-        throws IOException
-    {        
-        for (int i = off; i < (off + length); i++)
-        {
-            int    v = data[i] & 0xff;
+            byte[] data,
+            int off,
+            int length,
+            OutputStream out)
+            throws IOException {
+        for (int i = off; i < (off + length); i++) {
+            int v = data[i] & 0xff;
 
             out.write(encodingTable[(v >>> 4)]);
             out.write(encodingTable[v & 0xf]);
@@ -89,11 +84,10 @@ public class HexEncoder
     }
 
     private boolean ignore(
-        char    c)
-    {
-        return (c == '\n' || c =='\r' || c == '\t' || c == ' ');
+            char c) {
+        return (c == '\n' || c == '\r' || c == '\t' || c == ' ');
     }
-    
+
     /**
      * decode the Hex encoded byte data writing it to the given output stream,
      * whitespace characters will be ignored.
@@ -101,52 +95,46 @@ public class HexEncoder
      * @return the number of bytes produced.
      */
     public int decode(
-        byte[]          data,
-        int             off,
-        int             length,
-        OutputStream    out)
-        throws IOException
-    {
-        byte    b1, b2;
-        int     outLen = 0;
-        
-        int     end = off + length;
-        
-        while (end > off)
-        {
-            if (!ignore((char)data[end - 1]))
-            {
+            byte[] data,
+            int off,
+            int length,
+            OutputStream out)
+            throws IOException {
+        byte b1, b2;
+        int outLen = 0;
+
+        int end = off + length;
+
+        while (end > off) {
+            if (!ignore((char) data[end - 1])) {
                 break;
             }
-            
+
             end--;
         }
-        
+
         int i = off;
-        while (i < end)
-        {
-            while (i < end && ignore((char)data[i]))
-            {
+        while (i < end) {
+            while (i < end && ignore((char) data[i])) {
                 i++;
             }
-            
+
             b1 = decodingTable[data[i++]];
-            
-            while (i < end && ignore((char)data[i]))
-            {
+
+            while (i < end && ignore((char) data[i])) {
                 i++;
             }
-            
+
             b2 = decodingTable[data[i++]];
 
             out.write((b1 << 4) | b2);
-            
+
             outLen++;
         }
 
         return outLen;
     }
-    
+
     /**
      * decode the Hex encoded String data writing it to the given output stream,
      * whitespace characters will be ignored.
@@ -154,44 +142,38 @@ public class HexEncoder
      * @return the number of bytes produced.
      */
     public int decode(
-        String          data,
-        OutputStream    out)
-        throws IOException
-    {
-        byte    b1, b2;
-        int     length = 0;
-        
-        int     end = data.length();
-        
-        while (end > 0)
-        {
-            if (!ignore(data.charAt(end - 1)))
-            {
+            String data,
+            OutputStream out)
+            throws IOException {
+        byte b1, b2;
+        int length = 0;
+
+        int end = data.length();
+
+        while (end > 0) {
+            if (!ignore(data.charAt(end - 1))) {
                 break;
             }
-            
+
             end--;
         }
-        
+
         int i = 0;
-        while (i < end)
-        {
-            while (i < end && ignore(data.charAt(i)))
-            {
+        while (i < end) {
+            while (i < end && ignore(data.charAt(i))) {
                 i++;
             }
-            
+
             b1 = decodingTable[data.charAt(i++)];
-            
-            while (i < end && ignore(data.charAt(i)))
-            {
+
+            while (i < end && ignore(data.charAt(i))) {
                 i++;
             }
-            
+
             b2 = decodingTable[data.charAt(i++)];
 
             out.write((b1 << 4) | b2);
-            
+
             length++;
         }
 

app/src/full/java/kellinwood/security/zipsigner/KeySet.java

@@ -1,5 +1,3 @@
-
-
 /*
  * Copyright (C) 2010 Ken Ellinwood
  *
@@ -15,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.security.zipsigner;
 
 import java.security.PrivateKey;
@@ -23,31 +22,29 @@ import java.security.cert.X509Certificate;
 public class KeySet {
 
     String name;
-    
+
     // certificate
     X509Certificate publicKey = null;
-    
+
     // private key
-    PrivateKey privateKey = null; 
+    PrivateKey privateKey = null;
 
     // signature block template
     byte[] sigBlockTemplate = null;
 
     String signatureAlgorithm = "SHA1withRSA";
-    
+
     public KeySet() {
     }
-    
-    public KeySet( String name, X509Certificate publicKey, PrivateKey privateKey, byte[] sigBlockTemplate)
-    {
+
+    public KeySet(String name, X509Certificate publicKey, PrivateKey privateKey, byte[] sigBlockTemplate) {
         this.name = name;
         this.publicKey = publicKey;
         this.privateKey = privateKey;
         this.sigBlockTemplate = sigBlockTemplate;
     }
 
-    public KeySet( String name, X509Certificate publicKey, PrivateKey privateKey, String signatureAlgorithm, byte[] sigBlockTemplate)
-    {
+    public KeySet(String name, X509Certificate publicKey, PrivateKey privateKey, String signatureAlgorithm, byte[] sigBlockTemplate) {
         this.name = name;
         this.publicKey = publicKey;
         this.privateKey = privateKey;

app/src/full/java/kellinwood/security/zipsigner/ProgressEvent.java

@@ -13,34 +13,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.security.zipsigner;
 
 public class ProgressEvent {
 
     public static final int PRORITY_NORMAL = 0;
     public static final int PRORITY_IMPORTANT = 1;
-    
+
     private String message;
     private int percentDone;
     private int priority;
-    
+
     public String getMessage() {
         return message;
     }
+
     public void setMessage(String message) {
         this.message = message;
     }
+
     public int getPercentDone() {
         return percentDone;
     }
+
     public void setPercentDone(int percentDone) {
         this.percentDone = percentDone;
     }
+
     public int getPriority() {
         return priority;
     }
+
     public void setPriority(int priority) {
         this.priority = priority;
     }
-    
+
 }

app/src/full/java/kellinwood/security/zipsigner/ProgressHelper.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.security.zipsigner;
 
 import java.util.ArrayList;
@@ -22,13 +23,12 @@ public class ProgressHelper {
     private int progressTotalItems = 0;
     private int progressCurrentItem = 0;
     private ProgressEvent progressEvent = new ProgressEvent();
-    
-    public void initProgress()
-    {
+
+    public void initProgress() {
         progressTotalItems = 10000;
-        progressCurrentItem = 0;        
+        progressCurrentItem = 0;
     }
-    
+
     public int getProgressTotalItems() {
         return progressTotalItems;
     }
@@ -45,7 +45,7 @@ public class ProgressHelper {
         this.progressCurrentItem = progressCurrentItem;
     }
 
-    public void progress( int priority, String message) {
+    public void progress(int priority, String message) {
 
         progressCurrentItem += 1;
 
@@ -58,25 +58,23 @@ public class ProgressHelper {
             progressEvent.setMessage(message);
             progressEvent.setPercentDone(percentDone);
             progressEvent.setPriority(priority);
-            listener.onProgress( progressEvent);
+            listener.onProgress(progressEvent);
         }
     }
 
     private ArrayList<ProgressListener> listeners = new ArrayList<ProgressListener>();
 
     @SuppressWarnings("unchecked")
-    public synchronized void addProgressListener( ProgressListener l)
-    {
-        ArrayList<ProgressListener> list = (ArrayList<ProgressListener>)listeners.clone();
+    public synchronized void addProgressListener(ProgressListener l) {
+        ArrayList<ProgressListener> list = (ArrayList<ProgressListener>) listeners.clone();
         list.add(l);
         listeners = list;
     }
 
     @SuppressWarnings("unchecked")
-    public synchronized void removeProgressListener( ProgressListener l)
-    {
-        ArrayList<ProgressListener> list = (ArrayList<ProgressListener>)listeners.clone();
+    public synchronized void removeProgressListener(ProgressListener l) {
+        ArrayList<ProgressListener> list = (ArrayList<ProgressListener>) listeners.clone();
         list.remove(l);
         listeners = list;
-    }      
+    }
 }

app/src/full/java/kellinwood/security/zipsigner/ProgressListener.java

@@ -13,12 +13,14 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.security.zipsigner;
 
 public interface ProgressListener {
 
-    /** Called to notify the listener that progress has been made during
-        the zip signing operation.
+    /**
+     * Called to notify the listener that progress has been made during
+     * the zip signing operation.
      */
-    public void onProgress( ProgressEvent event);
+    public void onProgress(ProgressEvent event);
 }

app/src/full/java/kellinwood/security/zipsigner/ResourceAdapter.java

@@ -1,3 +1,4 @@
+
 package kellinwood.security.zipsigner;
 
 /**
@@ -14,7 +15,9 @@ public interface ResourceAdapter {
         GENERATING_SIGNATURE_FILE,
         GENERATING_SIGNATURE_BLOCK,
         COPYING_ZIP_ENTRY
-    };
+    }
 
-    public String getString( Item item, Object... args);
+    ;
+
+    public String getString(Item item, Object... args);
 }

app/src/full/java/kellinwood/security/zipsigner/ZipSignature.java

@@ -13,59 +13,56 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.security.zipsigner;
 
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
 import java.io.IOException;
 import java.security.GeneralSecurityException;
 import java.security.InvalidKeyException;
 import java.security.MessageDigest;
 import java.security.PrivateKey;
 
-import javax.crypto.BadPaddingException;
-import javax.crypto.Cipher;
-import javax.crypto.IllegalBlockSizeException;
-
 @SuppressWarnings("restriction")
 public class ZipSignature {
 
-    byte[] beforeAlgorithmIdBytes =  { 0x30, 0x21 };
+    byte[] beforeAlgorithmIdBytes = {0x30, 0x21};
 
     //      byte[] algorithmIdBytes;    
     //		algorithmIdBytes =  sun.security.x509.AlgorithmId.get("SHA1").encode();    
-    byte[] algorithmIdBytes = {0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00 }; 
+    byte[] algorithmIdBytes = {0x30, 0x09, 0x06, 0x05, 0x2B, 0x0E, 0x03, 0x02, 0x1A, 0x05, 0x00};
 
-    byte[] afterAlgorithmIdBytes = { 0x04, 0x14 };
+    byte[] afterAlgorithmIdBytes = {0x04, 0x14};
 
     Cipher cipher;
 
     MessageDigest md;
 
 
-    public ZipSignature() throws IOException, GeneralSecurityException
-    {
+    public ZipSignature() throws IOException, GeneralSecurityException {
         md = MessageDigest.getInstance("SHA1");
         cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
     }
 
-    public void initSign( PrivateKey privateKey) throws InvalidKeyException 
-    {
+    public void initSign(PrivateKey privateKey) throws InvalidKeyException {
         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
     }
 
-    public void update( byte[] data) {
-        md.update( data);
+    public void update(byte[] data) {
+        md.update(data);
     }
 
-    public void update( byte[] data, int offset, int count) {
-        md.update( data, offset, count);
+    public void update(byte[] data, int offset, int count) {
+        md.update(data, offset, count);
     }
 
-    public byte[] sign() throws BadPaddingException, IllegalBlockSizeException 
-    {
-        cipher.update( beforeAlgorithmIdBytes);
-        cipher.update( algorithmIdBytes);
-        cipher.update( afterAlgorithmIdBytes);
-        cipher.update( md.digest());		
+    public byte[] sign() throws BadPaddingException, IllegalBlockSizeException {
+        cipher.update(beforeAlgorithmIdBytes);
+        cipher.update(algorithmIdBytes);
+        cipher.update(afterAlgorithmIdBytes);
+        cipher.update(md.digest());
         return cipher.doFinal();
     }
 }

app/src/full/java/kellinwood/security/zipsigner/ZipSigner.java

@@ -26,6 +26,7 @@
  *     using signature block template files.
  */
 
+
 package kellinwood.security.zipsigner;
 
 import kellinwood.logging.LoggerInterface;
@@ -38,17 +39,40 @@ import javax.crypto.Cipher;
 import javax.crypto.EncryptedPrivateKeyInfo;
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.PBEKeySpec;
-import java.io.*;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PrintStream;
 import java.lang.reflect.Method;
 import java.net.URL;
-import java.security.*;
+import java.security.DigestOutputStream;
+import java.security.GeneralSecurityException;
+import java.security.Key;
+import java.security.KeyFactory;
+import java.security.KeyStore;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.Provider;
+import java.security.Security;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
 import java.security.spec.InvalidKeySpecException;
 import java.security.spec.KeySpec;
 import java.security.spec.PKCS8EncodedKeySpec;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.TreeMap;
 import java.util.jar.Attributes;
 import java.util.jar.JarFile;
 import java.util.jar.Manifest;
@@ -58,17 +82,16 @@ import java.util.regex.Pattern;
  * This is a modified copy of com.android.signapk.SignApk.java.  It provides an
  * API to sign JAR files (including APKs and Zip/OTA updates) in
  * a way compatible with the mincrypt verifier, using SHA1 and RSA keys.
- *
+ * <p>
  * Please see the README.txt file in the root of this project for usage instructions.
  */
-public class ZipSigner 
-{
+public class ZipSigner {
 
     private boolean canceled = false;
 
     private ProgressHelper progressHelper = new ProgressHelper();
     private ResourceAdapter resourceAdapter = new DefaultResourceAdapter();
-    
+
     static LoggerInterface log = null;
 
     private static final String CERT_SF_NAME = "META-INF/CERT.SF";
@@ -76,13 +99,13 @@ public class ZipSigner
 
     // Files matching this pattern are not copied to the output.
     private static Pattern stripPattern =
-        Pattern.compile("^META-INF/(.*)[.](SF|RSA|DSA)$");
+            Pattern.compile("^META-INF/(.*)[.](SF|RSA|DSA)$");
 
-    Map<String,KeySet> loadedKeys = new HashMap<String,KeySet>();
+    Map<String, KeySet> loadedKeys = new HashMap<String, KeySet>();
     KeySet keySet = null;
-    
+
     public static LoggerInterface getLogger() {
-        if (log == null) log = LoggerManager.getLogger( ZipSigner.class.getName());
+        if (log == null) log = LoggerManager.getLogger(ZipSigner.class.getName());
         return log;
     }
 
@@ -91,25 +114,24 @@ public class ZipSigner
     public static final String MODE_AUTO = "auto";
     public static final String KEY_NONE = "none";
     public static final String KEY_TESTKEY = "testkey";
-    
+
     // Allowable key modes.
     public static final String[] SUPPORTED_KEY_MODES =
-        new String[] { MODE_AUTO_TESTKEY, MODE_AUTO, MODE_AUTO_NONE, "media", "platform", "shared", KEY_TESTKEY, KEY_NONE};
-    
+            new String[]{MODE_AUTO_TESTKEY, MODE_AUTO, MODE_AUTO_NONE, "media", "platform", "shared", KEY_TESTKEY, KEY_NONE};
+
     String keymode = KEY_TESTKEY; // backwards compatible with versions that only signed with this key
-    
-    Map<String,String> autoKeyDetect = new HashMap<String,String>();
-    
+
+    Map<String, String> autoKeyDetect = new HashMap<String, String>();
+
     AutoKeyObservable autoKeyObservable = new AutoKeyObservable();
-    
-    public ZipSigner() throws ClassNotFoundException, IllegalAccessException, InstantiationException
-    {
+
+    public ZipSigner() throws ClassNotFoundException, IllegalAccessException, InstantiationException {
         // MD5 of the first 1458 bytes of the signature block generated by the key, mapped to the key name
-        autoKeyDetect.put( "aa9852bc5a53272ac8031d49b65e4b0e", "media");
-        autoKeyDetect.put( "e60418c4b638f20d0721e115674ca11f", "platform");
-        autoKeyDetect.put( "3e24e49741b60c215c010dc6048fca7d", "shared");
-        autoKeyDetect.put( "dab2cead827ef5313f28e22b6fa8479f", "testkey");
-        
+        autoKeyDetect.put("aa9852bc5a53272ac8031d49b65e4b0e", "media");
+        autoKeyDetect.put("e60418c4b638f20d0721e115674ca11f", "platform");
+        autoKeyDetect.put("3e24e49741b60c215c010dc6048fca7d", "shared");
+        autoKeyDetect.put("dab2cead827ef5313f28e22b6fa8479f", "testkey");
+
     }
 
     public ResourceAdapter getResourceAdapter() {
@@ -121,24 +143,22 @@ public class ZipSigner
     }
 
     // when the key mode is automatic, the observers are called when the key is determined
-    public void addAutoKeyObserver( Observer o) {
+    public void addAutoKeyObserver(Observer o) {
         autoKeyObservable.addObserver(o);
     }
-    
+
     public String getKeymode() {
         return keymode;
     }
 
-    public void setKeymode(String km) throws IOException, GeneralSecurityException  
-    {
+    public void setKeymode(String km) throws IOException, GeneralSecurityException {
         if (getLogger().isDebugEnabled()) getLogger().debug("setKeymode: " + km);
         keymode = km;
         if (keymode.startsWith(MODE_AUTO)) {
             keySet = null;
-        }
-        else {
-            progressHelper.initProgress();        
-            loadKeys( keymode);
+        } else {
+            progressHelper.initProgress();
+            loadKeys(keymode);
         }
     }
 
@@ -146,41 +166,40 @@ public class ZipSigner
         return SUPPORTED_KEY_MODES;
     }
 
-    
-    protected String autoDetectKey( String mode, Map<String,ZioEntry> zioEntries) 
-        throws NoSuchAlgorithmException, IOException 
-    {
+
+    protected String autoDetectKey(String mode, Map<String, ZioEntry> zioEntries)
+            throws NoSuchAlgorithmException, IOException {
         boolean debug = getLogger().isDebugEnabled();
-        
+
         if (!mode.startsWith(MODE_AUTO)) return mode;
-        
+
 
         // Auto-determine which keys to use
         String keyName = null;
         // Start by finding the signature block file in the input.
-        for (Map.Entry<String,ZioEntry> entry : zioEntries.entrySet()) {
+        for (Map.Entry<String, ZioEntry> entry : zioEntries.entrySet()) {
             String entryName = entry.getKey();
             if (entryName.startsWith("META-INF/") && entryName.endsWith(".RSA")) {
-                
+
                 // Compute MD5 of the first 1458 bytes, which is the size of our signature block templates -- 
                 // e.g., the portion of the sig block file that is the same for a given certificate.                    
                 MessageDigest md5 = MessageDigest.getInstance("MD5");
                 byte[] entryData = entry.getValue().getData();
                 if (entryData.length < 1458) break; // sig block too short to be a supported key 
-                md5.update( entryData, 0, 1458);
+                md5.update(entryData, 0, 1458);
                 byte[] rawDigest = md5.digest();
-                
+
                 // Create the hex representation of the digest value
                 StringBuilder builder = new StringBuilder();
-                for( byte b : rawDigest) {
-                    builder.append( String.format("%02x", b));
+                for (byte b : rawDigest) {
+                    builder.append(String.format("%02x", b));
                 }
-                
+
                 String md5String = builder.toString();
                 // Lookup the key name
-                keyName = autoKeyDetect.get( md5String); 
-                
-                
+                keyName = autoKeyDetect.get(md5String);
+
+
                 if (debug) {
                     if (keyName != null) {
                         getLogger().debug(String.format("Auto-determined key=%s using md5=%s", keyName, md5String));
@@ -191,19 +210,18 @@ public class ZipSigner
                 if (keyName != null) return keyName;
             }
         }
-        
-        if (mode.equals( MODE_AUTO_TESTKEY)) {
+
+        if (mode.equals(MODE_AUTO_TESTKEY)) {
             // in auto-testkey mode, fallback to the testkey if it couldn't be determined
-            if (debug) getLogger().debug("Falling back to key="+ keyName);
+            if (debug) getLogger().debug("Falling back to key=" + keyName);
             return KEY_TESTKEY;
-            
-        }
-        else if (mode.equals(MODE_AUTO_NONE)) {
+
+        } else if (mode.equals(MODE_AUTO_NONE)) {
             // in auto-node mode, simply copy the input to the output when the key can't be determined.
             if (debug) getLogger().debug("Unable to determine key, returning: " + KEY_NONE);
             return KEY_NONE;
         }
-        
+
         return null;
     }
 
@@ -212,55 +230,52 @@ public class ZipSigner
     }
 
     // Loads one of the built-in keys (media, platform, shared, testkey)
-    public void loadKeys( String name)
-        throws IOException, GeneralSecurityException
-    {
-        
+    public void loadKeys(String name)
+            throws IOException, GeneralSecurityException {
+
         keySet = loadedKeys.get(name);
         if (keySet != null) return;
-        
+
         keySet = new KeySet();
         keySet.setName(name);
-        loadedKeys.put( name, keySet);
-        
+        loadedKeys.put(name, keySet);
+
         if (KEY_NONE.equals(name)) return;
 
         issueLoadingCertAndKeysProgressEvent();
 
         // load the private key
-        URL privateKeyUrl = getClass().getResource("/keys/"+name+".pk8");
+        URL privateKeyUrl = getClass().getResource("/keys/" + name + ".pk8");
         keySet.setPrivateKey(readPrivateKey(privateKeyUrl, null));
 
         // load the certificate
-        URL publicKeyUrl = getClass().getResource("/keys/"+name+".x509.pem");
+        URL publicKeyUrl = getClass().getResource("/keys/" + name + ".x509.pem");
         keySet.setPublicKey(readPublicKey(publicKeyUrl));
 
         // load the signature block template
-        URL sigBlockTemplateUrl = getClass().getResource("/keys/"+name+".sbt");
+        URL sigBlockTemplateUrl = getClass().getResource("/keys/" + name + ".sbt");
         if (sigBlockTemplateUrl != null) {
             keySet.setSigBlockTemplate(readContentAsBytes(sigBlockTemplateUrl));
         }
     }
-    
-    public void setKeys( String name, X509Certificate publicKey, PrivateKey privateKey, byte[] signatureBlockTemplate)
-    {
-        keySet = new KeySet( name, publicKey, privateKey, signatureBlockTemplate);
+
+    public void setKeys(String name, X509Certificate publicKey, PrivateKey privateKey, byte[] signatureBlockTemplate) {
+        keySet = new KeySet(name, publicKey, privateKey, signatureBlockTemplate);
     }
 
-    public void setKeys( String name, X509Certificate publicKey, PrivateKey privateKey, String signatureAlgorithm, byte[] signatureBlockTemplate)
-    {
-        keySet = new KeySet( name, publicKey, privateKey, signatureAlgorithm, signatureBlockTemplate);
+    public void setKeys(String name, X509Certificate publicKey, PrivateKey privateKey, String signatureAlgorithm, byte[] signatureBlockTemplate) {
+        keySet = new KeySet(name, publicKey, privateKey, signatureAlgorithm, signatureBlockTemplate);
     }
 
     public KeySet getKeySet() {
         return keySet;
     }
-    
+
     // Allow the operation to be canceled.
     public void cancel() {
         canceled = true;
     }
-    
+
     // Allow the instance to sign again if previously canceled.
     public void resetCanceled() {
         canceled = false;
@@ -271,17 +286,16 @@ public class ZipSigner
     }
 
     @SuppressWarnings("unchecked")
-    public void loadProvider( String providerClassName)
-        throws ClassNotFoundException, IllegalAccessException, InstantiationException
-    {
+    public void loadProvider(String providerClassName)
+            throws ClassNotFoundException, IllegalAccessException, InstantiationException {
         Class providerClass = Class.forName(providerClassName);
-        Provider provider = (Provider)providerClass.newInstance();
+        Provider provider = (Provider) providerClass.newInstance();
         Security.insertProviderAt(provider, 1);
     }
 
 
     public X509Certificate readPublicKey(URL publicKeyUrl)
-    throws IOException, GeneralSecurityException {
+            throws IOException, GeneralSecurityException {
         InputStream input = publicKeyUrl.openStream();
         try {
             CertificateFactory cf = CertificateFactory.getInstance("X.509");
@@ -293,15 +307,15 @@ public class ZipSigner
 
     /**
      * Decrypt an encrypted PKCS 8 format private key.
-     *
+     * <p>
      * Based on ghstark's post on Aug 6, 2006 at
      * http://forums.sun.com/thread.jspa?threadID=758133&messageID=4330949
      *
      * @param encryptedPrivateKey The raw data of the private key
-     * @param keyPassword the key password
+     * @param keyPassword         the key password
      */
     private KeySpec decryptPrivateKey(byte[] encryptedPrivateKey, String keyPassword)
-    throws GeneralSecurityException {
+            throws GeneralSecurityException {
         EncryptedPrivateKeyInfo epkInfo;
         try {
             epkInfo = new EncryptedPrivateKeyInfo(encryptedPrivateKey);
@@ -326,35 +340,39 @@ public class ZipSigner
         }
     }
 
-    /** Fetch the content at the specified URL and return it as a byte array. */
-    public byte[] readContentAsBytes( URL contentUrl) throws IOException
-    {
-        return readContentAsBytes( contentUrl.openStream());
+    /**
+     * Fetch the content at the specified URL and return it as a byte array.
+     */
+    public byte[] readContentAsBytes(URL contentUrl) throws IOException {
+        return readContentAsBytes(contentUrl.openStream());
     }
 
-    /** Fetch the content from the given stream and return it as a byte array. */
-    public byte[] readContentAsBytes( InputStream input) throws IOException
-    {
+    /**
+     * Fetch the content from the given stream and return it as a byte array.
+     */
+    public byte[] readContentAsBytes(InputStream input) throws IOException {
         ByteArrayOutputStream baos = new ByteArrayOutputStream();
 
         byte[] buffer = new byte[2048];
 
-        int numRead = input.read( buffer);
+        int numRead = input.read(buffer);
         while (numRead != -1) {
-            baos.write( buffer, 0, numRead);
-            numRead = input.read( buffer);
+            baos.write(buffer, 0, numRead);
+            numRead = input.read(buffer);
         }
 
         byte[] bytes = baos.toByteArray();
         return bytes;
     }
 
-    /** Read a PKCS 8 format private key. */
+    /**
+     * Read a PKCS 8 format private key.
+     */
     public PrivateKey readPrivateKey(URL privateKeyUrl, String keyPassword)
-    throws IOException, GeneralSecurityException {
-        DataInputStream input = new DataInputStream( privateKeyUrl.openStream());
+            throws IOException, GeneralSecurityException {
+        DataInputStream input = new DataInputStream(privateKeyUrl.openStream());
         try {
-            byte[] bytes = readContentAsBytes( input);
+            byte[] bytes = readContentAsBytes(input);
 
             KeySpec spec = decryptPrivateKey(bytes, keyPassword);
             if (spec == null) {
@@ -371,17 +389,16 @@ public class ZipSigner
         }
     }
 
-    /** Add the SHA1 of every file to the manifest, creating it if necessary. */
-    private Manifest addDigestsToManifest(Map<String,ZioEntry> entries)
-        throws IOException, GeneralSecurityException 
-    {
+    /**
+     * Add the SHA1 of every file to the manifest, creating it if necessary.
+     */
+    private Manifest addDigestsToManifest(Map<String, ZioEntry> entries)
+            throws IOException, GeneralSecurityException {
         Manifest input = null;
         ZioEntry manifestEntry = entries.get(JarFile.MANIFEST_NAME);
         if (manifestEntry != null) {
-            InputStream is = manifestEntry.getInputStream();
             input = new Manifest();
-            input.read(is);
-            is.close();
+            input.read(manifestEntry.getInputStream());
         }
         Manifest output = new Manifest();
         Attributes main = output.getMainAttributes();
@@ -402,30 +419,29 @@ public class ZipSigner
         // map will be deterministic.
 
         TreeMap<String, ZioEntry> byName = new TreeMap<String, ZioEntry>();
-        byName.putAll( entries);
+        byName.putAll(entries);
 
         boolean debug = getLogger().isDebugEnabled();
         if (debug) getLogger().debug("Manifest entries:");
-        for (ZioEntry entry: byName.values()) {
+        for (ZioEntry entry : byName.values()) {
             if (canceled) break;
             String name = entry.getName();
             if (debug) getLogger().debug(name);
             if (!entry.isDirectory() && !name.equals(JarFile.MANIFEST_NAME) &&
                     !name.equals(CERT_SF_NAME) && !name.equals(CERT_RSA_NAME) &&
                     (stripPattern == null ||
-                     !stripPattern.matcher(name).matches()))
-            {
+                            !stripPattern.matcher(name).matches())) {
 
-                progressHelper.progress( ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.GENERATING_MANIFEST));
+                progressHelper.progress(ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.GENERATING_MANIFEST));
                 InputStream data = entry.getInputStream();
                 while ((num = data.read(buffer)) > 0) {
                     md.update(buffer, 0, num);
                 }
-                    
+
                 Attributes attr = null;
                 if (input != null) {
-                    java.util.jar.Attributes inAttr = input.getAttributes(name); 
-                    if (inAttr != null) attr = new Attributes( inAttr);
+                    java.util.jar.Attributes inAttr = input.getAttributes(name);
+                    if (inAttr != null) attr = new Attributes(inAttr);
                 }
                 if (attr == null) attr = new Attributes();
                 attr.putValue("SHA1-Digest", Base64.encode(md.digest()));
@@ -437,11 +453,13 @@ public class ZipSigner
     }
 
 
-    /** Write the signature file to the given output stream. */
+    /**
+     * Write the signature file to the given output stream.
+     */
     private void generateSignatureFile(Manifest manifest, OutputStream out)
-    throws IOException, GeneralSecurityException {
-        out.write( ("Signature-Version: 1.0\r\n").getBytes());
-        out.write( ("Created-By: 1.0 (Android SignApk)\r\n").getBytes());
+            throws IOException, GeneralSecurityException {
+        out.write(("Signature-Version: 1.0\r\n").getBytes());
+        out.write(("Created-By: 1.0 (Android SignApk)\r\n").getBytes());
 
 
         // BASE64Encoder base64 = new BASE64Encoder();
@@ -454,32 +472,33 @@ public class ZipSigner
         manifest.write(print);
         print.flush();
 
-        out.write( ("SHA1-Digest-Manifest: "+ Base64.encode(md.digest()) + "\r\n\r\n").getBytes());
+        out.write(("SHA1-Digest-Manifest: " + Base64.encode(md.digest()) + "\r\n\r\n").getBytes());
 
         Map<String, Attributes> entries = manifest.getEntries();
         for (Map.Entry<String, Attributes> entry : entries.entrySet()) {
             if (canceled) break;
-            progressHelper.progress( ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.GENERATING_SIGNATURE_FILE));
+            progressHelper.progress(ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.GENERATING_SIGNATURE_FILE));
             // Digest of the manifest stanza for this entry.
-            String nameEntry = "Name: " + entry.getKey() + "\r\n"; 
-            print.print( nameEntry);
+            String nameEntry = "Name: " + entry.getKey() + "\r\n";
+            print.print(nameEntry);
             for (Map.Entry<Object, Object> att : entry.getValue().entrySet()) {
                 print.print(att.getKey() + ": " + att.getValue() + "\r\n");
             }
             print.print("\r\n");
             print.flush();
 
-            out.write( nameEntry.getBytes());
-            out.write( ("SHA1-Digest: " +  Base64.encode(md.digest()) + "\r\n\r\n").getBytes());
+            out.write(nameEntry.getBytes());
+            out.write(("SHA1-Digest: " + Base64.encode(md.digest()) + "\r\n\r\n").getBytes());
         }
 
     }
 
-    /** Write a .RSA file with a digital signature. */
+    /**
+     * Write a .RSA file with a digital signature.
+     */
     @SuppressWarnings("unchecked")
-    private void writeSignatureBlock( KeySet keySet, byte[] signatureFileBytes, OutputStream out)
-        throws IOException, GeneralSecurityException
-    {
+    private void writeSignatureBlock(KeySet keySet, byte[] signatureFileBytes, OutputStream out)
+            throws IOException, GeneralSecurityException {
         if (keySet.getSigBlockTemplate() != null) {
 
             // Can't use default Signature on Android.  Although it generates a signature that can be verified by jarsigner,
@@ -490,35 +509,34 @@ public class ZipSigner
             signature.update(signatureFileBytes);
             byte[] signatureBytes = signature.sign();
 
-            out.write( keySet.getSigBlockTemplate());
-            out.write( signatureBytes);
+            out.write(keySet.getSigBlockTemplate());
+            out.write(signatureBytes);
 
             if (getLogger().isDebugEnabled()) {
 
                 MessageDigest md = MessageDigest.getInstance("SHA1");
-                md.update( signatureFileBytes);
+                md.update(signatureFileBytes);
                 byte[] sfDigest = md.digest();
-                getLogger().debug( "Sig File SHA1: \n" + HexDumpEncoder.encode( sfDigest));
+                getLogger().debug("Sig File SHA1: \n" + HexDumpEncoder.encode(sfDigest));
 
-                getLogger().debug( "Signature: \n" + HexDumpEncoder.encode(signatureBytes));
+                getLogger().debug("Signature: \n" + HexDumpEncoder.encode(signatureBytes));
 
                 Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
                 cipher.init(Cipher.DECRYPT_MODE, keySet.getPublicKey());
 
-                byte[] tmpData = cipher.doFinal( signatureBytes);
-                getLogger().debug( "Signature Decrypted: \n" + HexDumpEncoder.encode(tmpData));
+                byte[] tmpData = cipher.doFinal(signatureBytes);
+                getLogger().debug("Signature Decrypted: \n" + HexDumpEncoder.encode(tmpData));
             }
-        }
-        else {
+        } else {
             try {
                 byte[] sigBlock = null;
                 // Use reflection to call the optional generator.
                 Class generatorClass = Class.forName("kellinwood.security.zipsigner.optional.SignatureBlockGenerator");
                 Method generatorMethod = generatorClass.getMethod("generate", KeySet.class, (new byte[1]).getClass());
-                sigBlock = (byte[])generatorMethod.invoke(null, keySet, signatureFileBytes);
+                sigBlock = (byte[]) generatorMethod.invoke(null, keySet, signatureFileBytes);
                 out.write(sigBlock);
             } catch (Exception x) {
-                throw new RuntimeException(x.getMessage(),x);
+                throw new RuntimeException(x.getMessage(), x);
             }
         }
     }
@@ -529,9 +547,8 @@ public class ZipSigner
      * reduce variation in the output file and make incremental OTAs
      * more efficient.
      */
-    private void copyFiles(Manifest manifest, Map<String,ZioEntry> input, ZipOutput output, long timestamp)
-        throws IOException 
-    {
+    private void copyFiles(Manifest manifest, Map<String, ZioEntry> input, ZipOutput output, long timestamp)
+            throws IOException {
         Map<String, Attributes> entries = manifest.getEntries();
         List<String> names = new ArrayList<String>(entries.keySet());
         Collections.sort(names);
@@ -548,15 +565,14 @@ public class ZipSigner
     }
 
     /**
-     * Copy all the files from input to output. 
+     * Copy all the files from input to output.
      */
-    private void copyFiles(Map<String,ZioEntry> input, ZipOutput output)
-        throws IOException 
-    {
+    private void copyFiles(Map<String, ZioEntry> input, ZipOutput output)
+            throws IOException {
         int i = 1;
         for (ZioEntry inEntry : input.values()) {
             if (canceled) break;
-            progressHelper.progress( ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.COPYING_ZIP_ENTRY, i, input.size()));
+            progressHelper.progress(ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.COPYING_ZIP_ENTRY, i, input.size()));
             i += 1;
             output.write(inEntry);
         }
@@ -565,30 +581,28 @@ public class ZipSigner
     /**
      * @deprecated - use the version that takes the passwords as char[]
      */
-    public void signZip( URL keystoreURL,
-                         String keystoreType,
-                         String keystorePw,
-                         String certAlias,
-                         String certPw,
-                         String inputZipFilename,
-                         String outputZipFilename)
-        throws ClassNotFoundException, IllegalAccessException, InstantiationException,
-        IOException, GeneralSecurityException
-    {
-        signZip( keystoreURL, keystoreType, keystorePw.toCharArray(), certAlias, certPw.toCharArray(), "SHA1withRSA", inputZipFilename, outputZipFilename);
+    public void signZip(URL keystoreURL,
+                        String keystoreType,
+                        String keystorePw,
+                        String certAlias,
+                        String certPw,
+                        String inputZipFilename,
+                        String outputZipFilename)
+            throws ClassNotFoundException, IllegalAccessException, InstantiationException,
+            IOException, GeneralSecurityException {
+        signZip(keystoreURL, keystoreType, keystorePw.toCharArray(), certAlias, certPw.toCharArray(), "SHA1withRSA", inputZipFilename, outputZipFilename);
     }
 
-    public void signZip( URL keystoreURL, 
-            String keystoreType,
-            char[] keystorePw,
-            String certAlias,
-            char[] certPw,
-            String signatureAlgorithm,
-            String inputZipFilename, 
-            String outputZipFilename)
-        throws ClassNotFoundException, IllegalAccessException, InstantiationException,
-        IOException, GeneralSecurityException
-    {
+    public void signZip(URL keystoreURL,
+                        String keystoreType,
+                        char[] keystorePw,
+                        String certAlias,
+                        char[] certPw,
+                        String signatureAlgorithm,
+                        String inputZipFilename,
+                        String outputZipFilename)
+            throws ClassNotFoundException, IllegalAccessException, InstantiationException,
+            IOException, GeneralSecurityException {
         InputStream keystoreStream = null;
 
 
@@ -600,107 +614,109 @@ public class ZipSigner
             keystoreStream = keystoreURL.openStream();
             keystore.load(keystoreStream, keystorePw);
             Certificate cert = keystore.getCertificate(certAlias);
-            X509Certificate publicKey = (X509Certificate)cert;
+            X509Certificate publicKey = (X509Certificate) cert;
             Key key = keystore.getKey(certAlias, certPw);
-            PrivateKey privateKey = (PrivateKey)key;
-            
-            setKeys( "custom", publicKey, privateKey, signatureAlgorithm, null);
+            PrivateKey privateKey = (PrivateKey) key;
 
-            signZip( inputZipFilename, outputZipFilename);
-        }
-        finally {
+            setKeys("custom", publicKey, privateKey, signatureAlgorithm, null);
+
+            signZip(inputZipFilename, outputZipFilename);
+        } finally {
             if (keystoreStream != null) keystoreStream.close();
         }
     }
 
 
-    
-
-    /** Sign the input with the default test key and certificate.  
-     *  Save result to output file.
+    /**
+     * Sign the input with the default test key and certificate.
+     * Save result to output file.
      */
-    public void signZip( Map<String,ZioEntry> zioEntries, String outputZipFilename)
-        throws IOException, GeneralSecurityException
-    {
-        progressHelper.initProgress();        
-        signZip( zioEntries, new FileOutputStream(outputZipFilename), outputZipFilename);
+    public void signZip(Map<String, ZioEntry> zioEntries, String outputZipFilename)
+            throws IOException, GeneralSecurityException {
+        progressHelper.initProgress();
+        signZip(zioEntries, new FileOutputStream(outputZipFilename), outputZipFilename);
     }
-    
 
-    /** Sign the file using the given public key cert, private key,
-     *  and signature block template.  The signature block template
-     *  parameter may be null, but if so
-     *  android-sun-jarsign-support.jar must be in the classpath.
+
+    /**
+     * Sign the file using the given public key cert, private key,
+     * and signature block template.  The signature block template
+     * parameter may be null, but if so
+     * android-sun-jarsign-support.jar must be in the classpath.
      */
-    public void signZip( String inputZipFilename, String outputZipFilename)
-        throws IOException, GeneralSecurityException
-    {
-        File inFile = new File( inputZipFilename).getCanonicalFile();
-        File outFile = new File( outputZipFilename).getCanonicalFile();
-        
+    public void signZip(String inputZipFilename, String outputZipFilename)
+            throws IOException, GeneralSecurityException {
+        File inFile = new File(inputZipFilename).getCanonicalFile();
+        File outFile = new File(outputZipFilename).getCanonicalFile();
+
         if (inFile.equals(outFile)) {
-            throw new IllegalArgumentException( resourceAdapter.getString(ResourceAdapter.Item.INPUT_SAME_AS_OUTPUT_ERROR));
-        }        
+            throw new IllegalArgumentException(resourceAdapter.getString(ResourceAdapter.Item.INPUT_SAME_AS_OUTPUT_ERROR));
+        }
 
-        progressHelper.initProgress();        
-        progressHelper.progress( ProgressEvent.PRORITY_IMPORTANT, resourceAdapter.getString(ResourceAdapter.Item.PARSING_CENTRAL_DIRECTORY));
-        
-        ZipInput input = ZipInput.read( inputZipFilename);
-        signZip( input.getEntries(), new FileOutputStream( outputZipFilename), outputZipFilename);
-        input.close();
+        progressHelper.initProgress();
+        progressHelper.progress(ProgressEvent.PRORITY_IMPORTANT, resourceAdapter.getString(ResourceAdapter.Item.PARSING_CENTRAL_DIRECTORY));
+
+        ZipInput input = null;
+        OutputStream outStream = null;
+        try {
+            input = ZipInput.read(inputZipFilename);
+            outStream = new FileOutputStream(outputZipFilename);
+            signZip(input.getEntries(), outStream, outputZipFilename);
+        } finally {
+            if (input != null) input.close();
+            if (outStream != null) outStream.close();
+        }
     }
-    
-    /** Sign the 
-     *  and signature block template.  The signature block template
-     *  parameter may be null, but if so
-     *  android-sun-jarsign-support.jar must be in the classpath.
+
+    /**
+     * Sign the
+     * and signature block template.  The signature block template
+     * parameter may be null, but if so
+     * android-sun-jarsign-support.jar must be in the classpath.
      */
-    public void signZip( Map<String,ZioEntry> zioEntries, OutputStream outputStream, String outputZipFilename)
-        throws IOException, GeneralSecurityException    
-    {
-        boolean debug =  getLogger().isDebugEnabled();
-        
+    public void signZip(Map<String, ZioEntry> zioEntries, OutputStream outputStream, String outputZipFilename)
+            throws IOException, GeneralSecurityException {
+        boolean debug = getLogger().isDebugEnabled();
+
         progressHelper.initProgress();
         if (keySet == null) {
-            if (!keymode.startsWith(MODE_AUTO)) 
+            if (!keymode.startsWith(MODE_AUTO))
                 throw new IllegalStateException("No keys configured for signing the file!");
-            
+
             // Auto-determine which keys to use
-            String keyName = this.autoDetectKey( keymode, zioEntries);
-            if (keyName == null) 
-                throw new AutoKeyException( resourceAdapter.getString(ResourceAdapter.Item.AUTO_KEY_SELECTION_ERROR, new File( outputZipFilename).getName()));
-            
+            String keyName = this.autoDetectKey(keymode, zioEntries);
+            if (keyName == null)
+                throw new AutoKeyException(resourceAdapter.getString(ResourceAdapter.Item.AUTO_KEY_SELECTION_ERROR, new File(outputZipFilename).getName()));
+
             autoKeyObservable.notifyObservers(keyName);
 
-            loadKeys( keyName);
-            
+            loadKeys(keyName);
+
         }
 
 
-        
         ZipOutput zipOutput = null;
 
         try {
 
 
-            zipOutput = new ZipOutput( outputStream);
+            zipOutput = new ZipOutput(outputStream);
 
             if (KEY_NONE.equals(keySet.getName())) {
                 progressHelper.setProgressTotalItems(zioEntries.size());
-                progressHelper.setProgressCurrentItem(0);                
+                progressHelper.setProgressCurrentItem(0);
                 copyFiles(zioEntries, zipOutput);
                 return;
             }
-            
+
             // Calculate total steps to complete for accurate progress percentages.
             int progressTotalItems = 0;
-            for (ZioEntry entry: zioEntries.values()) {
+            for (ZioEntry entry : zioEntries.values()) {
                 String name = entry.getName();
                 if (!entry.isDirectory() && !name.equals(JarFile.MANIFEST_NAME) &&
                         !name.equals(CERT_SF_NAME) && !name.equals(CERT_RSA_NAME) &&
                         (stripPattern == null ||
-                                !stripPattern.matcher(name).matches()))
-                {
+                                !stripPattern.matcher(name).matches())) {
                     progressTotalItems += 3;  // digest for manifest, digest in sig file, copy data
                 }
             }
@@ -710,12 +726,12 @@ public class ZipSigner
 
             // Assume the certificate is valid for at least an hour.
             long timestamp = keySet.getPublicKey().getNotBefore().getTime() + 3600L * 1000;
-            
+
             // MANIFEST.MF
             // progress(ProgressEvent.PRORITY_NORMAL, JarFile.MANIFEST_NAME);
             Manifest manifest = addDigestsToManifest(zioEntries);
             if (canceled) return;
-            ZioEntry ze = new ZioEntry( JarFile.MANIFEST_NAME);
+            ZioEntry ze = new ZioEntry(JarFile.MANIFEST_NAME);
             ze.setTime(timestamp);
             manifest.write(ze.getOutputStream());
             zipOutput.write(ze);
@@ -724,62 +740,57 @@ public class ZipSigner
             // CERT.SF
             ze = new ZioEntry(CERT_SF_NAME);
             ze.setTime(timestamp);
-            
+
             ByteArrayOutputStream out = new ByteArrayOutputStream();
             generateSignatureFile(manifest, out);
             if (canceled) return;
             byte[] sfBytes = out.toByteArray();
             if (debug) {
-                getLogger().debug( "Signature File: \n" + new String( sfBytes) + "\n" + 
-                        HexDumpEncoder.encode( sfBytes));
+                getLogger().debug("Signature File: \n" + new String(sfBytes) + "\n" +
+                        HexDumpEncoder.encode(sfBytes));
             }
             ze.getOutputStream().write(sfBytes);
             zipOutput.write(ze);
 
             // CERT.RSA
-            progressHelper.progress( ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.GENERATING_SIGNATURE_BLOCK));
+            progressHelper.progress(ProgressEvent.PRORITY_NORMAL, resourceAdapter.getString(ResourceAdapter.Item.GENERATING_SIGNATURE_BLOCK));
             ze = new ZioEntry(CERT_RSA_NAME);
             ze.setTime(timestamp);
             writeSignatureBlock(keySet, sfBytes, ze.getOutputStream());
-            zipOutput.write( ze);
+            zipOutput.write(ze);
             if (canceled) return;
 
             // Everything else
             copyFiles(manifest, zioEntries, zipOutput, timestamp);
             if (canceled) return;
-            
-        }
-        finally {
-            zipOutput.close();
+
+        } finally {
+            if (zipOutput != null) zipOutput.close();
             if (canceled) {
                 try {
-                    if (outputZipFilename != null) new File( outputZipFilename).delete();
-                }
-                catch (Throwable t) {
-                    getLogger().warning( t.getClass().getName() + ":" + t.getMessage());
+                    if (outputZipFilename != null) new File(outputZipFilename).delete();
+                } catch (Throwable t) {
+                    getLogger().warning(t.getClass().getName() + ":" + t.getMessage());
                 }
             }
         }
     }
-    
-    public void addProgressListener( ProgressListener l)
-    {
+
+    public void addProgressListener(ProgressListener l) {
         progressHelper.addProgressListener(l);
     }
 
-    public synchronized void removeProgressListener( ProgressListener l)
-    {
+    public synchronized void removeProgressListener(ProgressListener l) {
         progressHelper.removeProgressListener(l);
-    }     
+    }
 
-    
-    public static class AutoKeyObservable extends Observable
-    {
+
+    public static class AutoKeyObservable extends Observable {
         @Override
         public void notifyObservers(Object arg) {
             super.setChanged();
             super.notifyObservers(arg);
         }
-        
+
     }
 }

app/src/full/java/kellinwood/security/zipsigner/optional/CertCreator.java

@@ -1,13 +1,17 @@
+
 package kellinwood.security.zipsigner.optional;
 
 import kellinwood.security.zipsigner.KeySet;
-import org.spongycastle.jce.X509Principal;
-import org.spongycastle.x509.X509V3CertificateGenerator;
+import org.bouncycastle.jce.X509Principal;
+import org.bouncycastle.x509.X509V3CertificateGenerator;
 
 import java.io.File;
 import java.io.IOException;
 import java.math.BigInteger;
-import java.security.*;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.KeyStore;
+import java.security.SecureRandom;
 import java.security.cert.X509Certificate;
 import java.util.Date;
 
@@ -17,84 +21,83 @@ import java.util.Date;
  */
 public class CertCreator {
 
-    /** Creates a new keystore and self-signed key.  The key will have the same password as the key, and will be
-     *  RSA 2048, with the cert signed using SHA1withRSA.  The certificate will have a validity of
-     *  30 years).
+    /**
+     * Creates a new keystore and self-signed key.  The key will have the same password as the key, and will be
+     * RSA 2048, with the cert signed using SHA1withRSA.  The certificate will have a validity of
+     * 30 years).
      *
-     * @param storePath - pathname of the new keystore file
-     * @param password - keystore and key password
-     * @param keyName - the new key will have this as its alias within the keystore
+     * @param storePath               - pathname of the new keystore file
+     * @param password                - keystore and key password
+     * @param keyName                 - the new key will have this as its alias within the keystore
      * @param distinguishedNameValues - contains Country, State, Locality,...,Common Name, etc.
      */
-    public static void createKeystoreAndKey( String storePath, char[] password,
-                                      String keyName, DistinguishedNameValues distinguishedNameValues)
-    {
+    public static void createKeystoreAndKey(String storePath, char[] password,
+                                            String keyName, DistinguishedNameValues distinguishedNameValues) {
         createKeystoreAndKey(storePath, password, "RSA", 2048, keyName, password, "SHA1withRSA", 30,
-            distinguishedNameValues);
+                distinguishedNameValues);
     }
 
 
-    public static KeySet createKeystoreAndKey( String storePath, char[] storePass,
-                                      String keyAlgorithm, int keySize, String keyName, char[] keyPass,
-                                      String certSignatureAlgorithm, int certValidityYears, DistinguishedNameValues distinguishedNameValues) {
+    public static KeySet createKeystoreAndKey(String storePath, char[] storePass,
+                                              String keyAlgorithm, int keySize, String keyName, char[] keyPass,
+                                              String certSignatureAlgorithm, int certValidityYears, DistinguishedNameValues distinguishedNameValues) {
         try {
 
             KeySet keySet = createKey(keyAlgorithm, keySize, keyName, certSignatureAlgorithm, certValidityYears,
-                distinguishedNameValues);
+                    distinguishedNameValues);
 
 
             KeyStore privateKS = KeyStoreFileManager.createKeyStore(storePath, storePass);
 
             privateKS.setKeyEntry(keyName, keySet.getPrivateKey(),
-                keyPass,
-                new java.security.cert.Certificate[]{keySet.getPublicKey()});
+                    keyPass,
+                    new java.security.cert.Certificate[]{keySet.getPublicKey()});
 
             File sfile = new File(storePath);
             if (sfile.exists()) {
                 throw new IOException("File already exists: " + storePath);
             }
-            KeyStoreFileManager.writeKeyStore( privateKS, storePath, storePass);
+            KeyStoreFileManager.writeKeyStore(privateKS, storePath, storePass);
 
             return keySet;
         } catch (RuntimeException x) {
             throw x;
-        } catch ( Exception x) {
-            throw new RuntimeException( x.getMessage(), x);
-        }
-    }
-
-    /** Create a new key and store it in an existing keystore.
-     *
-     */
-    public static KeySet createKey( String storePath, char[] storePass,
-                           String keyAlgorithm, int keySize, String keyName, char[] keyPass,
-                           String certSignatureAlgorithm, int certValidityYears,
-                           DistinguishedNameValues distinguishedNameValues) {
-        try {
-
-            KeySet keySet = createKey(keyAlgorithm, keySize, keyName, certSignatureAlgorithm, certValidityYears,
-                distinguishedNameValues);
-
-            KeyStore privateKS = KeyStoreFileManager.loadKeyStore(storePath, storePass);
-
-            privateKS.setKeyEntry(keyName, keySet.getPrivateKey(),
-                keyPass,
-                new java.security.cert.Certificate[]{keySet.getPublicKey()});
-
-            KeyStoreFileManager.writeKeyStore( privateKS, storePath, storePass);
-
-            return keySet;
-
-        } catch (RuntimeException x) {
-            throw x;
-        } catch ( Exception x) {
+        } catch (Exception x) {
             throw new RuntimeException(x.getMessage(), x);
         }
     }
 
-    public static KeySet createKey( String keyAlgorithm, int keySize, String keyName,
-                           String certSignatureAlgorithm, int certValidityYears, DistinguishedNameValues distinguishedNameValues)
-    {
+    /**
+     * Create a new key and store it in an existing keystore.
+     */
+    public static KeySet createKey(String storePath, char[] storePass,
+                                   String keyAlgorithm, int keySize, String keyName, char[] keyPass,
+                                   String certSignatureAlgorithm, int certValidityYears,
+                                   DistinguishedNameValues distinguishedNameValues) {
+        try {
+
+            KeySet keySet = createKey(keyAlgorithm, keySize, keyName, certSignatureAlgorithm, certValidityYears,
+                    distinguishedNameValues);
+
+            KeyStore privateKS = KeyStoreFileManager.loadKeyStore(storePath, storePass);
+
+            privateKS.setKeyEntry(keyName, keySet.getPrivateKey(),
+                    keyPass,
+                    new java.security.cert.Certificate[]{keySet.getPublicKey()});
+
+            KeyStoreFileManager.writeKeyStore(privateKS, storePath, storePass);
+
+            return keySet;
+
+        } catch (RuntimeException x) {
+            throw x;
+        } catch (Exception x) {
+            throw new RuntimeException(x.getMessage(), x);
+        }
+    }
+
+    public static KeySet createKey(String keyAlgorithm, int keySize, String keyName,
+                                   String certSignatureAlgorithm, int certValidityYears, DistinguishedNameValues distinguishedNameValues) {
         try {
             KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(keyAlgorithm);
             keyPairGenerator.initialize(keySize);
@@ -110,15 +113,15 @@ public class CertCreator {
                 serialNumber = BigInteger.valueOf(new SecureRandom().nextInt());
             }
             v3CertGen.setSerialNumber(serialNumber);
-            v3CertGen.setIssuerDN( principal);
+            v3CertGen.setIssuerDN(principal);
             v3CertGen.setNotBefore(new Date(System.currentTimeMillis() - 1000L * 60L * 60L * 24L * 30L));
-            v3CertGen.setNotAfter(new Date(System.currentTimeMillis() + (1000L * 60L * 60L * 24L * 366L * (long)certValidityYears)));
+            v3CertGen.setNotAfter(new Date(System.currentTimeMillis() + (1000L * 60L * 60L * 24L * 366L * (long) certValidityYears)));
             v3CertGen.setSubjectDN(principal);
 
             v3CertGen.setPublicKey(KPair.getPublic());
             v3CertGen.setSignatureAlgorithm(certSignatureAlgorithm);
 
-            X509Certificate PKCertificate = v3CertGen.generate(KPair.getPrivate(),"BC");
+            X509Certificate PKCertificate = v3CertGen.generate(KPair.getPrivate(), "BC");
 
             KeySet keySet = new KeySet();
             keySet.setName(keyName);

app/src/full/java/kellinwood/security/zipsigner/optional/CustomKeySigner.java

@@ -0,0 +1,39 @@
+
+package kellinwood.security.zipsigner.optional;
+
+import kellinwood.security.zipsigner.ZipSigner;
+
+import java.security.Key;
+import java.security.KeyStore;
+import java.security.PrivateKey;
+import java.security.cert.Certificate;
+import java.security.cert.X509Certificate;
+
+/**
+ */
+public class CustomKeySigner {
+
+    /**
+     * KeyStore-type agnostic.  This method will sign the zip file, automatically handling JKS or BKS keystores.
+     */
+    public static void signZip(ZipSigner zipSigner,
+                               String keystorePath,
+                               char[] keystorePw,
+                               String certAlias,
+                               char[] certPw,
+                               String signatureAlgorithm,
+                               String inputZipFilename,
+                               String outputZipFilename)
+            throws Exception {
+        zipSigner.issueLoadingCertAndKeysProgressEvent();
+        KeyStore keystore = KeyStoreFileManager.loadKeyStore(keystorePath, keystorePw);
+        Certificate cert = keystore.getCertificate(certAlias);
+        X509Certificate publicKey = (X509Certificate) cert;
+        Key key = keystore.getKey(certAlias, certPw);
+        PrivateKey privateKey = (PrivateKey) key;
+
+        zipSigner.setKeys("custom", publicKey, privateKey, signatureAlgorithm, null);
+        zipSigner.signZip(inputZipFilename, outputZipFilename);
+    }
+
+}

app/src/full/java/kellinwood/security/zipsigner/optional/DistinguishedNameValues.java

@@ -0,0 +1,89 @@
+
+package kellinwood.security.zipsigner.optional;
+
+import org.bouncycastle.asn1.ASN1ObjectIdentifier;
+import org.bouncycastle.asn1.x500.style.BCStyle;
+import org.bouncycastle.jce.X509Principal;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Vector;
+
+
+/**
+ * Helper class for dealing with the distinguished name RDNs.
+ */
+public class DistinguishedNameValues extends LinkedHashMap<ASN1ObjectIdentifier, String> {
+
+    public DistinguishedNameValues() {
+        put(BCStyle.C, null);
+        put(BCStyle.ST, null);
+        put(BCStyle.L, null);
+        put(BCStyle.STREET, null);
+        put(BCStyle.O, null);
+        put(BCStyle.OU, null);
+        put(BCStyle.CN, null);
+    }
+
+    public String put(ASN1ObjectIdentifier oid, String value) {
+        if (value != null && value.equals("")) value = null;
+        if (containsKey(oid)) super.put(oid, value); // preserve original ordering
+        else {
+            super.put(oid, value);
+//            String cn = remove(BCStyle.CN); // CN will always be last.
+//            put(BCStyle.CN,cn);
+        }
+        return value;
+    }
+
+    public void setCountry(String country) {
+        put(BCStyle.C, country);
+    }
+
+    public void setState(String state) {
+        put(BCStyle.ST, state);
+    }
+
+    public void setLocality(String locality) {
+        put(BCStyle.L, locality);
+    }
+
+    public void setStreet(String street) {
+        put(BCStyle.STREET, street);
+    }
+
+    public void setOrganization(String organization) {
+        put(BCStyle.O, organization);
+    }
+
+    public void setOrganizationalUnit(String organizationalUnit) {
+        put(BCStyle.OU, organizationalUnit);
+    }
+
+    public void setCommonName(String commonName) {
+        put(BCStyle.CN, commonName);
+    }
+
+    @Override
+    public int size() {
+        int result = 0;
+        for (String value : values()) {
+            if (value != null) result += 1;
+        }
+        return result;
+    }
+
+    public X509Principal getPrincipal() {
+        Vector<ASN1ObjectIdentifier> oids = new Vector<ASN1ObjectIdentifier>();
+        Vector<String> values = new Vector<String>();
+
+        for (Map.Entry<ASN1ObjectIdentifier, String> entry : entrySet()) {
+            if (entry.getValue() != null && !entry.getValue().equals("")) {
+                oids.add(entry.getKey());
+                values.add(entry.getValue());
+            }
+        }
+
+        return new X509Principal(oids, values);
+    }
+}

app/src/full/java/kellinwood/security/zipsigner/optional/Fingerprint.java

@@ -1,11 +1,13 @@
+
 package kellinwood.security.zipsigner.optional;
 
 import kellinwood.logging.LoggerInterface;
 import kellinwood.logging.LoggerManager;
 import kellinwood.security.zipsigner.Base64;
-import org.spongycastle.util.encoders.HexTranslator;
+import org.bouncycastle.util.encoders.HexTranslator;
 
 import java.security.MessageDigest;
+import java.util.Locale;
 
 /**
  * User: ken
@@ -15,34 +17,34 @@ public class Fingerprint {
 
     static LoggerInterface logger = LoggerManager.getLogger(Fingerprint.class.getName());
 
-    static byte[] calcDigest( String algorithm, byte[] encodedCert) {
+    static byte[] calcDigest(String algorithm, byte[] encodedCert) {
         byte[] result = null;
         try {
             MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
             messageDigest.update(encodedCert);
             result = messageDigest.digest();
         } catch (Exception x) {
-            logger.error(x.getMessage(),x);
+            logger.error(x.getMessage(), x);
         }
         return result;
     }
 
-    public static String hexFingerprint( String algorithm, byte[] encodedCert) {
+    public static String hexFingerprint(String algorithm, byte[] encodedCert) {
         try {
-            byte[] digest = calcDigest(algorithm,encodedCert);
+            byte[] digest = calcDigest(algorithm, encodedCert);
             if (digest == null) return null;
             HexTranslator hexTranslator = new HexTranslator();
             byte[] hex = new byte[digest.length * 2];
             hexTranslator.encode(digest, 0, digest.length, hex, 0);
             StringBuilder builder = new StringBuilder();
             for (int i = 0; i < hex.length; i += 2) {
-                builder.append((char)hex[i]);
-                builder.append((char)hex[i+1]);
+                builder.append((char) hex[i]);
+                builder.append((char) hex[i + 1]);
                 if (i != (hex.length - 2)) builder.append(':');
             }
-            return builder.toString().toUpperCase();
+            return builder.toString().toUpperCase(Locale.ENGLISH);
         } catch (Exception x) {
-            logger.error(x.getMessage(),x);
+            logger.error(x.getMessage(), x);
         }
         return null;
     }
@@ -55,14 +57,14 @@ public class Fingerprint {
 //
 //    }
 
-    public static String base64Fingerprint( String algorithm, byte[] encodedCert) {
+    public static String base64Fingerprint(String algorithm, byte[] encodedCert) {
         String result = null;
         try {
-            byte[] digest = calcDigest(algorithm,encodedCert);
+            byte[] digest = calcDigest(algorithm, encodedCert);
             if (digest == null) return result;
             return Base64.encode(digest);
         } catch (Exception x) {
-            logger.error(x.getMessage(),x);
+            logger.error(x.getMessage(), x);
         }
         return result;
     }

app/src/full/java/kellinwood/security/zipsigner/optional/JKS.java

@@ -25,13 +25,14 @@ and it is irresponsible for them to claim they can.  */
 
 package kellinwood.security.zipsigner.optional;
 
+import javax.crypto.EncryptedPrivateKeyInfo;
+import javax.crypto.spec.SecretKeySpec;
 import java.io.ByteArrayInputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
-import java.io.InputStream;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.OutputStream;
-
 import java.security.DigestInputStream;
 import java.security.DigestOutputStream;
 import java.security.Key;
@@ -42,29 +43,25 @@ import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.UnrecoverableKeyException;
-
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.spec.InvalidKeySpecException;
 import java.security.spec.PKCS8EncodedKeySpec;
-
 import java.util.Date;
 import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.Iterator;
+import java.util.Locale;
 import java.util.Vector;
 
-import javax.crypto.EncryptedPrivateKeyInfo;
-import javax.crypto.spec.SecretKeySpec;
-
 /**
  * This is an implementation of Sun's proprietary key store
  * algorithm, called "JKS" for "Java Key Store". This implementation was
  * created entirely through reverse-engineering.
- *
+ * <p>
  * <p>The format of JKS files is, from the start of the file:
- *
+ * <p>
  * <ol>
  * <li>Magic bytes. This is a four-byte integer, in big-endian byte
  * order, equal to <code>0xFEEDFEED</code>.</li>
@@ -74,46 +71,46 @@ import javax.crypto.spec.SecretKeySpec;
  * <li>The number of entrires in this keystore, as a four-byte
  * integer. Call this value <i>n</i></li>
  * <li>Then, <i>n</i> times:
- *  <ol>
- *  <li>The entry type, a four-byte int. The value 1 denotes a private
- *  key entry, and 2 denotes a trusted certificate.</li>
- *  <li>The entry's alias, formatted as strings such as those written
- *  by <a
- *  href="http://java.sun.com/j2se/1.4.1/docs/api/java/io/DataOutput.html#writeUTF(java.lang.String)">DataOutput.writeUTF(String)</a>.</li>
- *  <li>An eight-byte integer, representing the entry's creation date,
- *  in milliseconds since the epoch.
- *
- *  <p>Then, if the entry is a private key entry:
- *   <ol>
- *   <li>The size of the encoded key as a four-byte int, then that
- *   number of bytes. The encoded key is the DER encoded bytes of the
- *   <a
- *   href="http://java.sun.com/j2se/1.4.1/docs/api/javax/crypto/EncryptedPrivateKeyInfo.html">EncryptedPrivateKeyInfo</a> structure (the
- *   encryption algorithm is discussed later).</li>
- *   <li>A four-byte integer, followed by that many encoded
- *   certificates, encoded as described in the trusted certificates
- *   section.</li>
- *   </ol>
- *
- *  <p>Otherwise, the entry is a trusted certificate, which is encoded
- *  as the name of the encoding algorithm (e.g. X.509), encoded the same
- *  way as alias names. Then, a four-byte integer representing the size
- *  of the encoded certificate, then that many bytes representing the
- *  encoded certificate (e.g. the DER bytes in the case of X.509).
- *  </li>
- *  </ol>
+ * <ol>
+ * <li>The entry type, a four-byte int. The value 1 denotes a private
+ * key entry, and 2 denotes a trusted certificate.</li>
+ * <li>The entry's alias, formatted as strings such as those written
+ * by <a
+ * href="http://java.sun.com/j2se/1.4.1/docs/api/java/io/DataOutput.html#writeUTF(java.lang.String)">DataOutput.writeUTF(String)</a>.</li>
+ * <li>An eight-byte integer, representing the entry's creation date,
+ * in milliseconds since the epoch.
+ * <p>
+ * <p>Then, if the entry is a private key entry:
+ * <ol>
+ * <li>The size of the encoded key as a four-byte int, then that
+ * number of bytes. The encoded key is the DER encoded bytes of the
+ * <a
+ * href="http://java.sun.com/j2se/1.4.1/docs/api/javax/crypto/EncryptedPrivateKeyInfo.html">EncryptedPrivateKeyInfo</a> structure (the
+ * encryption algorithm is discussed later).</li>
+ * <li>A four-byte integer, followed by that many encoded
+ * certificates, encoded as described in the trusted certificates
+ * section.</li>
+ * </ol>
+ * <p>
+ * <p>Otherwise, the entry is a trusted certificate, which is encoded
+ * as the name of the encoding algorithm (e.g. X.509), encoded the same
+ * way as alias names. Then, a four-byte integer representing the size
+ * of the encoded certificate, then that many bytes representing the
+ * encoded certificate (e.g. the DER bytes in the case of X.509).
+ * </li>
+ * </ol>
  * </li>
  * <li>Then, the signature.</li>
  * </ol>
  * </ol>
  * </li>
  * </ol>
- *
+ * <p>
  * <p>(See <a href="genkey.java">this file</a> for some idea of how I
  * was able to figure out these algorithms)</p>
- *
+ * <p>
  * <p>Decrypting the key works as follows:
- *
+ * <p>
  * <ol>
  * <li>The key length is the length of the ciphertext minus 40. The
  * encrypted key, <code>ekey</code>, is the middle bytes of the
@@ -129,36 +126,37 @@ import javax.crypto.spec.SecretKeySpec;
  * the last 20 bytes of the ciphertext, output <code>FAIL</code>. Otherwise,
  * output <code>key</code>.</li>
  * </ol>
- *
+ * <p>
  * <p>The signature is defined as <code>SHA-1(UTF-16BE(password) +
  * US_ASCII("Mighty Aphrodite") + encoded_keystore)</code> (yup, Sun
  * engineers are just that clever).
- *
+ * <p>
  * <p>(Above, SHA-1 denotes the secure hash algorithm, UTF-16BE the
  * big-endian byte representation of a UTF-16 string, and US_ASCII the
  * ASCII byte representation of the string.)
- *
+ * <p>
  * <p>The source code of this class should be available in the file <a
  * href="http://metastatic.org/source/JKS.java">JKS.java</a>.
  *
  * @author Casey Marshall (rsdio@metastatic.org)
- *
- * Changes by Ken Ellinwood:
- * ** Fixed a NullPointerException in engineLoad(). This method must return gracefully if the keystore input stream is null.
- * ** engineGetCertificateEntry() was updated to return the first cert in the chain for private key entries.
- * ** Lowercase the alias names, otherwise keytool chokes on the file created by this code.
- * ** Fixed the integrity check in engineLoad(), previously the exception was never thrown regardless of password value.
+ *         <p>
+ *         Changes by Ken Ellinwood:
+ *         ** Fixed a NullPointerException in engineLoad(). This method must return gracefully if the keystore input stream is null.
+ *         ** engineGetCertificateEntry() was updated to return the first cert in the chain for private key entries.
+ *         ** Lowercase the alias names, otherwise keytool chokes on the file created by this code.
+ *         ** Fixed the integrity check in engineLoad(), previously the exception was never thrown regardless of password value.
  */
-public class JKS extends KeyStoreSpi
-{
+public class JKS extends KeyStoreSpi {
 
     // Constants and fields.
     // ------------------------------------------------------------------------
 
-    /** Ah, Sun. So goddamned clever with those magic bytes. */
+    /**
+     * Ah, Sun. So goddamned clever with those magic bytes.
+     */
     private static final int MAGIC = 0xFEEDFEED;
 
-    private static final int PRIVATE_KEY  = 1;
+    private static final int PRIVATE_KEY = 1;
     private static final int TRUSTED_CERT = 2;
 
     private final Vector aliases;
@@ -170,8 +168,7 @@ public class JKS extends KeyStoreSpi
     // Constructor.
     // ------------------------------------------------------------------------
 
-    public JKS()
-    {
+    public JKS() {
         super();
         aliases = new Vector();
         trustedCerts = new HashMap();
@@ -185,42 +182,34 @@ public class JKS extends KeyStoreSpi
     // ------------------------------------------------------------------------
 
     public Key engineGetKey(String alias, char[] password)
-        throws NoSuchAlgorithmException, UnrecoverableKeyException
-    {
-        alias = alias.toLowerCase();
+            throws NoSuchAlgorithmException, UnrecoverableKeyException {
+        alias = alias.toLowerCase(Locale.ENGLISH);
 
         if (!privateKeys.containsKey(alias))
             return null;
         byte[] key = decryptKey((byte[]) privateKeys.get(alias),
-            charsToBytes(password));
+                charsToBytes(password));
         Certificate[] chain = engineGetCertificateChain(alias);
-        if (chain.length > 0)
-        {
-            try
-            {
+        if (chain.length > 0) {
+            try {
                 // Private and public keys MUST have the same algorithm.
                 KeyFactory fact = KeyFactory.getInstance(
-                    chain[0].getPublicKey().getAlgorithm());
+                        chain[0].getPublicKey().getAlgorithm());
                 return fact.generatePrivate(new PKCS8EncodedKeySpec(key));
-            }
-            catch (InvalidKeySpecException x)
-            {
+            } catch (InvalidKeySpecException x) {
                 throw new UnrecoverableKeyException(x.getMessage());
             }
-        }
-        else
+        } else
             return new SecretKeySpec(key, alias);
     }
 
-    public Certificate[] engineGetCertificateChain(String alias)
-    {
-        alias = alias.toLowerCase();
+    public Certificate[] engineGetCertificateChain(String alias) {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         return (Certificate[]) certChains.get(alias);
     }
 
-    public Certificate engineGetCertificate(String alias)
-    {
-        alias = alias.toLowerCase();
+    public Certificate engineGetCertificate(String alias) {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         if (engineIsKeyEntry(alias)) {
             Certificate[] certChain = (Certificate[]) certChains.get(alias);
             if (certChain != null && certChain.length > 0) return certChain[0];
@@ -228,18 +217,16 @@ public class JKS extends KeyStoreSpi
         return (Certificate) trustedCerts.get(alias);
     }
 
-    public Date engineGetCreationDate(String alias)
-    {
-        alias = alias.toLowerCase();
+    public Date engineGetCreationDate(String alias) {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         return (Date) dates.get(alias);
     }
 
     // XXX implement writing methods.
 
     public void engineSetKeyEntry(String alias, Key key, char[] passwd, Certificate[] certChain)
-        throws KeyStoreException
-    {
-        alias = alias.toLowerCase();
+            throws KeyStoreException {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         if (trustedCerts.containsKey(alias))
             throw new KeyStoreException("\"" + alias + " is a trusted certificate entry");
         privateKeys.put(alias, encryptKey(key, charsToBytes(passwd)));
@@ -247,25 +234,20 @@ public class JKS extends KeyStoreSpi
             certChains.put(alias, certChain);
         else
             certChains.put(alias, new Certificate[0]);
-        if (!aliases.contains(alias))
-        {
+        if (!aliases.contains(alias)) {
             dates.put(alias, new Date());
             aliases.add(alias);
         }
     }
 
     public void engineSetKeyEntry(String alias, byte[] encodedKey, Certificate[] certChain)
-        throws KeyStoreException
-    {
-        alias = alias.toLowerCase();
+            throws KeyStoreException {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         if (trustedCerts.containsKey(alias))
             throw new KeyStoreException("\"" + alias + "\" is a trusted certificate entry");
-        try
-        {
+        try {
             new EncryptedPrivateKeyInfo(encodedKey);
-        }
-        catch (IOException ioe)
-        {
+        } catch (IOException ioe) {
             throw new KeyStoreException("encoded key is not an EncryptedPrivateKeyInfo");
         }
         privateKeys.put(alias, encodedKey);
@@ -273,67 +255,56 @@ public class JKS extends KeyStoreSpi
             certChains.put(alias, certChain);
         else
             certChains.put(alias, new Certificate[0]);
-        if (!aliases.contains(alias))
-        {
+        if (!aliases.contains(alias)) {
             dates.put(alias, new Date());
             aliases.add(alias);
         }
     }
 
     public void engineSetCertificateEntry(String alias, Certificate cert)
-        throws KeyStoreException
-    {
-        alias = alias.toLowerCase();
+            throws KeyStoreException {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         if (privateKeys.containsKey(alias))
             throw new KeyStoreException("\"" + alias + "\" is a private key entry");
         if (cert == null)
             throw new NullPointerException();
         trustedCerts.put(alias, cert);
-        if (!aliases.contains(alias))
-        {
+        if (!aliases.contains(alias)) {
             dates.put(alias, new Date());
             aliases.add(alias);
         }
     }
 
-    public void engineDeleteEntry(String alias) throws KeyStoreException
-    {
-        alias = alias.toLowerCase();
+    public void engineDeleteEntry(String alias) throws KeyStoreException {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         aliases.remove(alias);
     }
 
-    public Enumeration engineAliases()
-    {
+    public Enumeration engineAliases() {
         return aliases.elements();
     }
 
-    public boolean engineContainsAlias(String alias)
-    {
-        alias = alias.toLowerCase();
+    public boolean engineContainsAlias(String alias) {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         return aliases.contains(alias);
     }
 
-    public int engineSize()
-    {
+    public int engineSize() {
         return aliases.size();
     }
 
-    public boolean engineIsKeyEntry(String alias)
-    {
-        alias = alias.toLowerCase();
+    public boolean engineIsKeyEntry(String alias) {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         return privateKeys.containsKey(alias);
     }
 
-    public boolean engineIsCertificateEntry(String alias)
-    {
-        alias = alias.toLowerCase();
+    public boolean engineIsCertificateEntry(String alias) {
+        alias = alias.toLowerCase(Locale.ENGLISH);
         return trustedCerts.containsKey(alias);
     }
 
-    public String engineGetCertificateAlias(Certificate cert)
-    {
-        for (Iterator keys = trustedCerts.keySet().iterator(); keys.hasNext(); )
-        {
+    public String engineGetCertificateAlias(Certificate cert) {
+        for (Iterator keys = trustedCerts.keySet().iterator(); keys.hasNext(); ) {
             String alias = (String) keys.next();
             if (cert.equals(trustedCerts.get(alias)))
                 return alias;
@@ -342,8 +313,7 @@ public class JKS extends KeyStoreSpi
     }
 
     public void engineStore(OutputStream out, char[] passwd)
-        throws IOException, NoSuchAlgorithmException, CertificateException
-    {
+            throws IOException, NoSuchAlgorithmException, CertificateException {
         MessageDigest md = MessageDigest.getInstance("SHA1");
         md.update(charsToBytes(passwd));
         md.update("Mighty Aphrodite".getBytes("UTF-8"));
@@ -351,18 +321,14 @@ public class JKS extends KeyStoreSpi
         dout.writeInt(MAGIC);
         dout.writeInt(2);
         dout.writeInt(aliases.size());
-        for (Enumeration e = aliases.elements(); e.hasMoreElements(); )
-        {
+        for (Enumeration e = aliases.elements(); e.hasMoreElements(); ) {
             String alias = (String) e.nextElement();
-            if (trustedCerts.containsKey(alias))
-            {
+            if (trustedCerts.containsKey(alias)) {
                 dout.writeInt(TRUSTED_CERT);
                 dout.writeUTF(alias);
                 dout.writeLong(((Date) dates.get(alias)).getTime());
                 writeCert(dout, (Certificate) trustedCerts.get(alias));
-            }
-            else
-            {
+            } else {
                 dout.writeInt(PRIVATE_KEY);
                 dout.writeUTF(alias);
                 dout.writeLong(((Date) dates.get(alias)).getTime());
@@ -380,8 +346,7 @@ public class JKS extends KeyStoreSpi
     }
 
     public void engineLoad(InputStream in, char[] passwd)
-        throws IOException, NoSuchAlgorithmException, CertificateException
-    {
+            throws IOException, NoSuchAlgorithmException, CertificateException {
         MessageDigest md = MessageDigest.getInstance("SHA");
         if (passwd != null) md.update(charsToBytes(passwd));
         md.update("Mighty Aphrodite".getBytes("UTF-8")); // HAR HAR
@@ -399,14 +364,12 @@ public class JKS extends KeyStoreSpi
         aliases.ensureCapacity(n);
         if (n < 0)
             throw new LoadKeystoreException("Malformed key store");
-        for (int i = 0; i < n; i++)
-        {
+        for (int i = 0; i < n; i++) {
             int type = din.readInt();
             String alias = din.readUTF();
             aliases.add(alias);
             dates.put(alias, new Date(din.readLong()));
-            switch (type)
-            {
+            switch (type) {
                 case PRIVATE_KEY:
                     int len = din.readInt();
                     byte[] encoded = new byte[len];
@@ -442,8 +405,7 @@ public class JKS extends KeyStoreSpi
     // ------------------------------------------------------------------------
 
     private static Certificate readCert(DataInputStream in)
-        throws IOException, CertificateException, NoSuchAlgorithmException
-    {
+            throws IOException, CertificateException, NoSuchAlgorithmException {
         String type = in.readUTF();
         int len = in.readInt();
         byte[] encoded = new byte[len];
@@ -453,8 +415,7 @@ public class JKS extends KeyStoreSpi
     }
 
     private static void writeCert(DataOutputStream dout, Certificate cert)
-        throws IOException, CertificateException
-    {
+            throws IOException, CertificateException {
         dout.writeUTF(cert.getType());
         byte[] b = cert.getEncoded();
         dout.writeInt(b.length);
@@ -462,29 +423,25 @@ public class JKS extends KeyStoreSpi
     }
 
     private static byte[] decryptKey(byte[] encryptedPKI, byte[] passwd)
-        throws UnrecoverableKeyException
-    {
-        try
-        {
+            throws UnrecoverableKeyException {
+        try {
             EncryptedPrivateKeyInfo epki =
-                new EncryptedPrivateKeyInfo(encryptedPKI);
+                    new EncryptedPrivateKeyInfo(encryptedPKI);
             byte[] encr = epki.getEncryptedData();
             byte[] keystream = new byte[20];
             System.arraycopy(encr, 0, keystream, 0, 20);
             byte[] check = new byte[20];
-            System.arraycopy(encr, encr.length-20, check, 0, 20);
+            System.arraycopy(encr, encr.length - 20, check, 0, 20);
             byte[] key = new byte[encr.length - 40];
             MessageDigest sha = MessageDigest.getInstance("SHA1");
             int count = 0;
-            while (count < key.length)
-            {
+            while (count < key.length) {
                 sha.reset();
                 sha.update(passwd);
                 sha.update(keystream);
                 sha.digest(keystream, 0, keystream.length);
-                for (int i = 0; i < keystream.length && count < key.length; i++)
-                {
-                    key[count] = (byte) (keystream[i] ^ encr[count+20]);
+                for (int i = 0; i < keystream.length && count < key.length; i++) {
+                    key[count] = (byte) (keystream[i] ^ encr[count + 20]);
                     count++;
                 }
             }
@@ -494,18 +451,14 @@ public class JKS extends KeyStoreSpi
             if (!MessageDigest.isEqual(check, sha.digest()))
                 throw new UnrecoverableKeyException("checksum mismatch");
             return key;
-        }
-        catch (Exception x)
-        {
+        } catch (Exception x) {
             throw new UnrecoverableKeyException(x.getMessage());
         }
     }
 
     private static byte[] encryptKey(Key key, byte[] passwd)
-        throws KeyStoreException
-    {
-        try
-        {
+            throws KeyStoreException {
+        try {
             MessageDigest sha = MessageDigest.getInstance("SHA1");
             SecureRandom rand = SecureRandom.getInstance("SHA1PRNG");
             byte[] k = key.getEncoded();
@@ -513,15 +466,13 @@ public class JKS extends KeyStoreSpi
             byte[] keystream = rand.getSeed(20);
             System.arraycopy(keystream, 0, encrypted, 0, 20);
             int count = 0;
-            while (count < k.length)
-            {
+            while (count < k.length) {
                 sha.reset();
                 sha.update(passwd);
                 sha.update(keystream);
                 sha.digest(keystream, 0, keystream.length);
-                for (int i = 0; i < keystream.length && count < k.length; i++)
-                {
-                    encrypted[count+20] = (byte) (keystream[i] ^ k[count]);
+                for (int i = 0; i < keystream.length && count < k.length; i++) {
+                    encrypted[count + 20] = (byte) (keystream[i] ^ k[count]);
                     count++;
                 }
             }
@@ -532,21 +483,17 @@ public class JKS extends KeyStoreSpi
             // 1.3.6.1.4.1.42.2.17.1.1 is Sun's private OID for this
             // encryption algorithm.
             return new EncryptedPrivateKeyInfo("1.3.6.1.4.1.42.2.17.1.1",
-                encrypted).getEncoded();
-        }
-        catch (Exception x)
-        {
+                    encrypted).getEncoded();
+        } catch (Exception x) {
             throw new KeyStoreException(x.getMessage());
         }
     }
 
-    private static byte[] charsToBytes(char[] passwd)
-    {
+    private static byte[] charsToBytes(char[] passwd) {
         byte[] buf = new byte[passwd.length * 2];
-        for (int i = 0, j = 0; i < passwd.length; i++)
-        {
+        for (int i = 0, j = 0; i < passwd.length; i++) {
             buf[j++] = (byte) (passwd[i] >>> 8);
-            buf[j++] = (byte)  passwd[i];
+            buf[j++] = (byte) passwd[i];
         }
         return buf;
     }

app/src/full/java/kellinwood/security/zipsigner/optional/JksKeyStore.java

@@ -1,3 +1,4 @@
+
 package kellinwood.security.zipsigner.optional;
 
 

app/src/full/java/kellinwood/security/zipsigner/optional/KeyNameConflictException.java

@@ -1,3 +1,4 @@
+
 package kellinwood.security.zipsigner.optional;
 
 public class KeyNameConflictException extends Exception {

app/src/full/java/kellinwood/security/zipsigner/optional/KeyStoreFileManager.java

@@ -1,14 +1,23 @@
+
 package kellinwood.security.zipsigner.optional;
 
 
 import kellinwood.logging.LoggerInterface;
 import kellinwood.logging.LoggerManager;
-import org.spongycastle.jce.provider.BouncyCastleProvider;
+import org.bouncycastle.jce.provider.BouncyCastleProvider;
 
-import java.io.*;
-import java.security.*;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.security.Key;
+import java.security.KeyStore;
+import java.security.Provider;
+import java.security.Security;
 import java.security.cert.Certificate;
-
+import java.util.Locale;
 
 
 /**
@@ -17,29 +26,31 @@ public class KeyStoreFileManager {
 
     static Provider provider = new BouncyCastleProvider();
 
-    public static Provider getProvider() { return provider; }
-
-    public static void setProvider(Provider provider) {
-        if (KeyStoreFileManager.provider != null) Security.removeProvider( KeyStoreFileManager.provider.getName());
-        KeyStoreFileManager.provider = provider;
-        Security.addProvider( provider);
+    public static Provider getProvider() {
+        return provider;
     }
 
-    static LoggerInterface logger = LoggerManager.getLogger( KeyStoreFileManager.class.getName());
+    public static void setProvider(Provider provider) {
+        if (KeyStoreFileManager.provider != null) Security.removeProvider(KeyStoreFileManager.provider.getName());
+        KeyStoreFileManager.provider = provider;
+        Security.addProvider(provider);
+    }
+
+    static LoggerInterface logger = LoggerManager.getLogger(KeyStoreFileManager.class.getName());
 
     static {
-        // Add the spongycastle version of the BC provider so that the implementation classes returned
-        // from the keystore are all from the spongycastle libs.
+        // Add the bouncycastle version of the BC provider so that the implementation classes returned
+        // from the keystore are all from the bouncycastle libs.
         Security.addProvider(getProvider());
     }
 
 
-    public static KeyStore loadKeyStore( String keystorePath, String encodedPassword)
-        throws Exception{
+    public static KeyStore loadKeyStore(String keystorePath, String encodedPassword)
+            throws Exception {
         char password[] = null;
         try {
             if (encodedPassword != null) {
-                password = PasswordObfuscator.getInstance().decodeKeystorePassword( keystorePath, encodedPassword);
+                password = PasswordObfuscator.getInstance().decodeKeystorePassword(keystorePath, encodedPassword);
             }
             return loadKeyStore(keystorePath, password);
         } finally {
@@ -47,27 +58,24 @@ public class KeyStoreFileManager {
         }
     }
 
-    public static KeyStore createKeyStore( String keystorePath, char[] password)
-        throws Exception
-    {
+    public static KeyStore createKeyStore(String keystorePath, char[] password)
+            throws Exception {
         KeyStore ks = null;
-        if (keystorePath.toLowerCase().endsWith(".bks")) {
+        if (keystorePath.toLowerCase(Locale.ENGLISH).endsWith(".bks")) {
             ks = KeyStore.getInstance("bks", new BouncyCastleProvider());
-        }
-        else ks = new JksKeyStore();
+        } else ks = new JksKeyStore();
         ks.load(null, password);
 
         return ks;
     }
 
-    public static KeyStore loadKeyStore( String keystorePath, char[] password)
-        throws Exception
-    {
+    public static KeyStore loadKeyStore(String keystorePath, char[] password)
+            throws Exception {
         KeyStore ks = null;
         try {
             ks = new JksKeyStore();
-            FileInputStream fis = new FileInputStream( keystorePath);
-            ks.load( fis, password);
+            FileInputStream fis = new FileInputStream(keystorePath);
+            ks.load(fis, password);
             fis.close();
             return ks;
         } catch (LoadKeystoreException x) {
@@ -78,8 +86,8 @@ public class KeyStoreFileManager {
             // logger.warning( x.getMessage(), x);
             try {
                 ks = KeyStore.getInstance("bks", getProvider());
-                FileInputStream fis = new FileInputStream( keystorePath);
-                ks.load( fis, password);
+                FileInputStream fis = new FileInputStream(keystorePath);
+                ks.load(fis, password);
                 fis.close();
                 return ks;
             } catch (Exception e) {
@@ -88,29 +96,27 @@ public class KeyStoreFileManager {
         }
     }
 
-    public static void writeKeyStore( KeyStore ks, String keystorePath, String encodedPassword)
-        throws Exception
-    {
+    public static void writeKeyStore(KeyStore ks, String keystorePath, String encodedPassword)
+            throws Exception {
         char password[] = null;
         try {
-            password = PasswordObfuscator.getInstance().decodeKeystorePassword( keystorePath, encodedPassword);
-            writeKeyStore( ks, keystorePath, password);
+            password = PasswordObfuscator.getInstance().decodeKeystorePassword(keystorePath, encodedPassword);
+            writeKeyStore(ks, keystorePath, password);
         } finally {
             if (password != null) PasswordObfuscator.flush(password);
         }
     }
 
-    public static void writeKeyStore( KeyStore ks, String keystorePath, char[] password)
-        throws Exception
-    {
+    public static void writeKeyStore(KeyStore ks, String keystorePath, char[] password)
+            throws Exception {
 
-        File keystoreFile = new File( keystorePath);
+        File keystoreFile = new File(keystorePath);
         try {
             if (keystoreFile.exists()) {
-                // I've had some trouble saving new verisons of the keystore file in which the file becomes empty/corrupt.
+                // I've had some trouble saving new versions of the keystore file in which the file becomes empty/corrupt.
                 // Saving the new version to a new file and creating a backup of the old version.
-                File tmpFile = File.createTempFile( keystoreFile.getName(), null, keystoreFile.getParentFile());
-                FileOutputStream fos = new FileOutputStream( tmpFile);
+                File tmpFile = File.createTempFile(keystoreFile.getName(), null, keystoreFile.getParentFile());
+                FileOutputStream fos = new FileOutputStream(tmpFile);
                 ks.store(fos, password);
                 fos.flush();
                 fos.close();
@@ -125,18 +131,19 @@ public class KeyStoreFileManager {
                 */
                 renameTo(tmpFile, keystoreFile);
             } else {
-                FileOutputStream fos = new FileOutputStream( keystorePath);
+                FileOutputStream fos = new FileOutputStream(keystorePath);
                 ks.store(fos, password);
                 fos.close();
             }
         } catch (Exception x) {
             try {
                 File logfile = File.createTempFile("zipsigner-error", ".log", keystoreFile.getParentFile());
-                PrintWriter pw = new PrintWriter(new FileWriter( logfile));
-                x.printStackTrace( pw);
+                PrintWriter pw = new PrintWriter(new FileWriter(logfile));
+                x.printStackTrace(pw);
                 pw.flush();
                 pw.close();
-            } catch (Exception y) {}
+            } catch (Exception y) {
+            }
             throw x;
         }
     }
@@ -159,15 +166,21 @@ public class KeyStoreFileManager {
                     count += n;
                 }
             } finally {
-                try { output.close();  } catch (IOException x) {} // Ignore
+                try {
+                    output.close();
+                } catch (IOException x) {
+                } // Ignore
             }
         } finally {
-            try { input.close(); } catch (IOException x) {}
+            try {
+                input.close();
+            } catch (IOException x) {
+            }
         }
 
         if (srcFile.length() != destFile.length()) {
             throw new IOException("Failed to copy full contents from '" +
-                srcFile + "' to '" + destFile + "'");
+                    srcFile + "' to '" + destFile + "'");
         }
         if (preserveFileDate) {
             destFile.setLastModified(srcFile.lastModified());
@@ -176,84 +189,75 @@ public class KeyStoreFileManager {
 
 
     public static void renameTo(File fromFile, File toFile)
-        throws IOException
-    {
+            throws IOException {
         copyFile(fromFile, toFile, true);
         if (!fromFile.delete()) throw new IOException("Failed to delete " + fromFile);
     }
 
     public static void deleteKey(String storePath, String storePass, String keyName)
-        throws Exception
-    {
-        KeyStore ks = loadKeyStore( storePath, storePass);
-        ks.deleteEntry( keyName);
+            throws Exception {
+        KeyStore ks = loadKeyStore(storePath, storePass);
+        ks.deleteEntry(keyName);
         writeKeyStore(ks, storePath, storePass);
     }
 
-    public static String renameKey( String keystorePath, String storePass, String oldKeyName, String newKeyName, String keyPass)
-        throws Exception
-    {
+    public static String renameKey(String keystorePath, String storePass, String oldKeyName, String newKeyName, String keyPass)
+            throws Exception {
         char[] keyPw = null;
 
         try {
             KeyStore ks = loadKeyStore(keystorePath, storePass);
-            if (ks instanceof JksKeyStore) newKeyName = newKeyName.toLowerCase();
+            if (ks instanceof JksKeyStore) newKeyName = newKeyName.toLowerCase(Locale.ENGLISH);
 
             if (ks.containsAlias(newKeyName)) throw new KeyNameConflictException();
 
-            keyPw = PasswordObfuscator.getInstance().decodeAliasPassword( keystorePath, oldKeyName, keyPass);
+            keyPw = PasswordObfuscator.getInstance().decodeAliasPassword(keystorePath, oldKeyName, keyPass);
             Key key = ks.getKey(oldKeyName, keyPw);
-            Certificate cert = ks.getCertificate( oldKeyName);
+            Certificate cert = ks.getCertificate(oldKeyName);
 
-            ks.setKeyEntry(newKeyName, key, keyPw, new Certificate[] { cert});
-            ks.deleteEntry( oldKeyName);
+            ks.setKeyEntry(newKeyName, key, keyPw, new Certificate[]{cert});
+            ks.deleteEntry(oldKeyName);
 
             writeKeyStore(ks, keystorePath, storePass);
             return newKeyName;
-        }
-        finally {
+        } finally {
             PasswordObfuscator.flush(keyPw);
         }
     }
 
-    public static KeyStore.Entry getKeyEntry( String keystorePath, String storePass, String keyName, String keyPass)
-        throws Exception
-    {
+    public static KeyStore.Entry getKeyEntry(String keystorePath, String storePass, String keyName, String keyPass)
+            throws Exception {
         char[] keyPw = null;
         KeyStore.PasswordProtection passwordProtection = null;
 
         try {
             KeyStore ks = loadKeyStore(keystorePath, storePass);
-            keyPw = PasswordObfuscator.getInstance().decodeAliasPassword( keystorePath, keyName, keyPass);
+            keyPw = PasswordObfuscator.getInstance().decodeAliasPassword(keystorePath, keyName, keyPass);
             passwordProtection = new KeyStore.PasswordProtection(keyPw);
-            return ks.getEntry( keyName, passwordProtection);
-        }
-        finally {
+            return ks.getEntry(keyName, passwordProtection);
+        } finally {
             if (keyPw != null) PasswordObfuscator.flush(keyPw);
             if (passwordProtection != null) passwordProtection.destroy();
         }
     }
 
-    public static boolean containsKey( String keystorePath, String storePass, String keyName)
-        throws Exception
-    {
+    public static boolean containsKey(String keystorePath, String storePass, String keyName)
+            throws Exception {
         KeyStore ks = loadKeyStore(keystorePath, storePass);
-        return ks.containsAlias( keyName);
+        return ks.containsAlias(keyName);
     }
 
 
     /**
-     *
      * @param keystorePath
      * @param encodedPassword
      * @throws Exception if the password is invalid
      */
-    public static void validateKeystorePassword( String keystorePath, String encodedPassword)
-        throws Exception
-    {
+    public static void validateKeystorePassword(String keystorePath, String encodedPassword)
+            throws Exception {
         char[] password = null;
         try {
-            KeyStore ks = KeyStoreFileManager.loadKeyStore( keystorePath, encodedPassword);
+            KeyStore ks = KeyStoreFileManager.loadKeyStore(keystorePath, encodedPassword);
         } finally {
             if (password != null) PasswordObfuscator.flush(password);
         }
@@ -261,19 +265,17 @@ public class KeyStoreFileManager {
     }
 
     /**
-     *
      * @param keystorePath
      * @param keyName
      * @param encodedPassword
      * @throws java.security.UnrecoverableKeyException if the password is invalid
      */
-    public static void validateKeyPassword( String keystorePath, String keyName, String encodedPassword)
-        throws Exception
-    {
+    public static void validateKeyPassword(String keystorePath, String keyName, String encodedPassword)
+            throws Exception {
         char[] password = null;
         try {
-            KeyStore ks = KeyStoreFileManager.loadKeyStore( keystorePath, (char[])null);
-            password = PasswordObfuscator.getInstance().decodeAliasPassword(keystorePath,keyName, encodedPassword);
+            KeyStore ks = KeyStoreFileManager.loadKeyStore(keystorePath, (char[]) null);
+            password = PasswordObfuscator.getInstance().decodeAliasPassword(keystorePath, keyName, encodedPassword);
             ks.getKey(keyName, password);
         } finally {
             if (password != null) PasswordObfuscator.flush(password);

app/src/full/java/kellinwood/security/zipsigner/optional/LoadKeystoreException.java

@@ -1,3 +1,4 @@
+
 package kellinwood.security.zipsigner.optional;
 
 import java.io.IOException;

app/src/full/java/kellinwood/security/zipsigner/optional/PasswordObfuscator.java

@@ -1,3 +1,4 @@
+
 package kellinwood.security.zipsigner.optional;
 
 import kellinwood.logging.LoggerInterface;
@@ -6,19 +7,24 @@ import kellinwood.security.zipsigner.Base64;
 
 import javax.crypto.Cipher;
 import javax.crypto.spec.SecretKeySpec;
-import java.io.*;
+import java.io.BufferedReader;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
 
 public class PasswordObfuscator {
 
     private static PasswordObfuscator instance = null;
-    
-    static final String x = "harold-and-maude";   
+
+    static final String x = "harold-and-maude";
 
     LoggerInterface logger;
     SecretKeySpec skeySpec;
-    
+
     private PasswordObfuscator() {
-        logger = LoggerManager.getLogger( PasswordObfuscator.class.getName());
+        logger = LoggerManager.getLogger(PasswordObfuscator.class.getName());
         skeySpec = new SecretKeySpec(x.getBytes(), "AES");
     }
 
@@ -27,39 +33,46 @@ public class PasswordObfuscator {
         return instance;
     }
 
-    public String encodeKeystorePassword( String keystorePath, String password) {
-        return encode( keystorePath, password);
+    public String encodeKeystorePassword(String keystorePath, String password) {
+        return encode(keystorePath, password);
     }
 
-    public String encodeKeystorePassword( String keystorePath, char[] password) {
-        return encode( keystorePath, password);
+    public String encodeKeystorePassword(String keystorePath, char[] password) {
+        return encode(keystorePath, password);
     }
 
-    public String encodeAliasPassword( String keystorePath, String aliasName, String password) {
-        return encode( keystorePath+aliasName, password);
+    public String encodeAliasPassword(String keystorePath, String aliasName, String password) {
+        return encode(keystorePath + aliasName, password);
     }
 
-    public String encodeAliasPassword( String keystorePath, String aliasName, char[] password) {
-        return encode( keystorePath+aliasName, password);
+    public String encodeAliasPassword(String keystorePath, String aliasName, char[] password) {
+        return encode(keystorePath + aliasName, password);
     }
 
-    public char[] decodeKeystorePassword( String keystorePath, String password) {
-        return decode(keystorePath,password);
+    public char[] decodeKeystorePassword(String keystorePath, String password) {
+        return decode(keystorePath, password);
     }
 
-    public char[] decodeAliasPassword( String keystorePath, String aliasName, String password) {
-        return decode(keystorePath+aliasName,password);
+    public char[] decodeAliasPassword(String keystorePath, String aliasName, String password) {
+        return decode(keystorePath + aliasName, password);
     }
 
-    public String encode( String junk, String password) {
+    public String encode(String junk, String password) {
         if (password == null) return null;
         char[] c = password.toCharArray();
-        String result = encode( junk, c);
+        String result = encode(junk, c);
         flush(c);
         return result;
     }
 
-    public String encode( String junk, char[] password) {
+    /**
+     * <b>This uses the AES-ECB cipher which is known to be insecure</b>
+     *
+     * @see <a href="https://blog.filippo.io/the-ecb-penguin/">The ECB Penguin</a>
+     */
+    @Deprecated
+    @SuppressWarnings("GetInstance")
+    public String encode(String junk, char[] password) {
         if (password == null) return null;
         try {
             // Instantiate the cipher
@@ -70,33 +83,40 @@ public class PasswordObfuscator {
             w.write(junk);
             w.write(password);
             w.flush();
-            byte[] encoded = cipher.doFinal( baos.toByteArray());
-            return Base64.encode( encoded);
+            byte[] encoded = cipher.doFinal(baos.toByteArray());
+            return Base64.encode(encoded);
         } catch (Exception x) {
             logger.error("Failed to obfuscate password", x);
         }
         return null;
     }
-    
-    public char[] decode( String junk, String password) {
+
+    /**
+     * <b>This uses the AES-ECB cipher which is known to be insecure</b>
+     *
+     * @see <a href="https://blog.filippo.io/the-ecb-penguin/">The ECB Penguin</a>
+     */
+    @Deprecated
+    @SuppressWarnings("GetInstance")
+    public char[] decode(String junk, String password) {
         if (password == null) return null;
         try {
             // Instantiate the cipher  
             Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
             SecretKeySpec skeySpec = new SecretKeySpec(x.getBytes(), "AES");
             cipher.init(Cipher.DECRYPT_MODE, skeySpec);
-            byte[] bytes = cipher.doFinal( Base64.decode(password.getBytes()));
-            BufferedReader r = new BufferedReader( new InputStreamReader( new ByteArrayInputStream( bytes)));
+            byte[] bytes = cipher.doFinal(Base64.decode(password.getBytes()));
+            BufferedReader r = new BufferedReader(new InputStreamReader(new ByteArrayInputStream(bytes)));
             char[] cb = new char[128];
             int length = 0;
             int numRead;
-            while ((numRead = r.read(cb, length, 128-length)) != -1) {
+            while ((numRead = r.read(cb, length, 128 - length)) != -1) {
                 length += numRead;
             }
-            
+
             if (length <= junk.length()) return null;
-            
-            char[] result = new char[ length - junk.length()];
+
+            char[] result = new char[length - junk.length()];
             int j = 0;
             for (int i = junk.length(); i < length; i++) {
                 result[j] = cb[i];
@@ -104,21 +124,21 @@ public class PasswordObfuscator {
             }
             flush(cb);
             return result;
-            
+
         } catch (Exception x) {
             logger.error("Failed to decode password", x);
         }
         return null;
     }
-    
-    public static void flush( char[] charArray) {
+
+    public static void flush(char[] charArray) {
         if (charArray == null) return;
         for (int i = 0; i < charArray.length; i++) {
             charArray[i] = '\0';
         }
     }
 
-    public static void flush( byte[] charArray) {
+    public static void flush(byte[] charArray) {
         if (charArray == null) return;
         for (int i = 0; i < charArray.length; i++) {
             charArray[i] = 0;

app/src/full/java/kellinwood/security/zipsigner/optional/SignatureBlockGenerator.java

@@ -1,14 +1,19 @@
+
 package kellinwood.security.zipsigner.optional;
 
 import kellinwood.security.zipsigner.KeySet;
-import org.spongycastle.cert.jcajce.JcaCertStore;
-import org.spongycastle.cms.*;
-import org.spongycastle.cms.jcajce.JcaSignerInfoGeneratorBuilder;
-import org.spongycastle.operator.ContentSigner;
-import org.spongycastle.operator.DigestCalculatorProvider;
-import org.spongycastle.operator.jcajce.JcaContentSignerBuilder;
-import org.spongycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
-import org.spongycastle.util.Store;
+import org.bouncycastle.cert.jcajce.JcaCertStore;
+import org.bouncycastle.cms.CMSProcessableByteArray;
+import org.bouncycastle.cms.CMSSignedData;
+import org.bouncycastle.cms.CMSSignedDataGenerator;
+import org.bouncycastle.cms.CMSTypedData;
+import org.bouncycastle.cms.SignerInfoGenerator;
+import org.bouncycastle.cms.jcajce.JcaSignerInfoGeneratorBuilder;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.DigestCalculatorProvider;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
+import org.bouncycastle.operator.jcajce.JcaDigestCalculatorProviderBuilder;
+import org.bouncycastle.util.Store;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -33,17 +38,17 @@ public class SignatureBlockGenerator {
 
             CMSSignedDataGenerator gen = new CMSSignedDataGenerator();
 
-            JcaContentSignerBuilder jcaContentSignerBuilder = new JcaContentSignerBuilder(keySet.getSignatureAlgorithm()).setProvider("SC");
+            JcaContentSignerBuilder jcaContentSignerBuilder = new JcaContentSignerBuilder(keySet.getSignatureAlgorithm()).setProvider("BC");
             ContentSigner sha1Signer = jcaContentSignerBuilder.build(keySet.getPrivateKey());
 
-            JcaDigestCalculatorProviderBuilder jcaDigestCalculatorProviderBuilder = new JcaDigestCalculatorProviderBuilder().setProvider("SC");
+            JcaDigestCalculatorProviderBuilder jcaDigestCalculatorProviderBuilder = new JcaDigestCalculatorProviderBuilder().setProvider("BC");
             DigestCalculatorProvider digestCalculatorProvider = jcaDigestCalculatorProviderBuilder.build();
 
-            JcaSignerInfoGeneratorBuilder jcaSignerInfoGeneratorBuilder = new JcaSignerInfoGeneratorBuilder( digestCalculatorProvider);
+            JcaSignerInfoGeneratorBuilder jcaSignerInfoGeneratorBuilder = new JcaSignerInfoGeneratorBuilder(digestCalculatorProvider);
             jcaSignerInfoGeneratorBuilder.setDirectSignature(true);
             SignerInfoGenerator signerInfoGenerator = jcaSignerInfoGeneratorBuilder.build(sha1Signer, keySet.getPublicKey());
 
-            gen.addSignerInfoGenerator( signerInfoGenerator);
+            gen.addSignerInfoGenerator(signerInfoGenerator);
 
             gen.addCertificates(certs);
 

app/src/full/java/kellinwood/zipio/CentralEnd.java

@@ -13,15 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package kellinwood.zipio;
 
-import java.io.IOException;
+package kellinwood.zipio;
 
 import kellinwood.logging.LoggerInterface;
 import kellinwood.logging.LoggerManager;
 
-public class CentralEnd 
-{
+import java.io.IOException;
+
+public class CentralEnd {
     public int signature = 0x06054b50; // end of central dir signature    4 bytes
     public short numberThisDisk = 0;   // number of this disk             2 bytes     
     public short centralStartDisk = 0; // number of the disk with the start of the central directory  2 bytes
@@ -34,73 +34,70 @@ public class CentralEnd
 
     private static LoggerInterface log;
 
-    public static CentralEnd read(ZipInput input) throws IOException
-    {
+    public static CentralEnd read(ZipInput input) throws IOException {
 
         int signature = input.readInt();
         if (signature != 0x06054b50) {
             // back up to the signature
-            input.seek( input.getFilePointer() - 4);
+            input.seek(input.getFilePointer() - 4);
             return null;
         }
 
         CentralEnd entry = new CentralEnd();
 
-        entry.doRead( input);
+        entry.doRead(input);
         return entry;
     }
 
     public static LoggerInterface getLogger() {
-        if (log == null) log = LoggerManager.getLogger( CentralEnd.class.getName());
+        if (log == null) log = LoggerManager.getLogger(CentralEnd.class.getName());
         return log;
     }
 
 
-    private void doRead( ZipInput input) throws IOException
-    {
+    private void doRead(ZipInput input) throws IOException {
 
         boolean debug = getLogger().isDebugEnabled();
 
         numberThisDisk = input.readShort();
-        if (debug) log.debug( String.format("This disk number: 0x%04x", numberThisDisk));
+        if (debug) log.debug(String.format("This disk number: 0x%04x", numberThisDisk));
 
         centralStartDisk = input.readShort();
-        if (debug) log.debug( String.format("Central dir start disk number: 0x%04x", centralStartDisk));
+        if (debug) log.debug(String.format("Central dir start disk number: 0x%04x", centralStartDisk));
 
         numCentralEntries = input.readShort();
-        if (debug) log.debug( String.format("Central entries on this disk: 0x%04x", numCentralEntries));
+        if (debug) log.debug(String.format("Central entries on this disk: 0x%04x", numCentralEntries));
 
         totalCentralEntries = input.readShort();
-        if (debug) log.debug( String.format("Total number of central entries: 0x%04x", totalCentralEntries));
+        if (debug) log.debug(String.format("Total number of central entries: 0x%04x", totalCentralEntries));
 
         centralDirectorySize = input.readInt();
-        if (debug) log.debug( String.format("Central directory size: 0x%08x", centralDirectorySize));
+        if (debug) log.debug(String.format("Central directory size: 0x%08x", centralDirectorySize));
 
         centralStartOffset = input.readInt();
-        if (debug) log.debug( String.format("Central directory offset: 0x%08x", centralStartOffset));
+        if (debug) log.debug(String.format("Central directory offset: 0x%08x", centralStartOffset));
 
         short zipFileCommentLen = input.readShort();
         fileComment = input.readString(zipFileCommentLen);
-        if (debug) log.debug( ".ZIP file comment: " + fileComment);
+        if (debug) log.debug(".ZIP file comment: " + fileComment);
 
 
     }
 
 
-    public void write( ZipOutput output) throws IOException
-    {
+    public void write(ZipOutput output) throws IOException {
 
         boolean debug = getLogger().isDebugEnabled();
 
-        output.writeInt( signature);
-        output.writeShort( numberThisDisk);
-        output.writeShort( centralStartDisk);
-        output.writeShort( numCentralEntries);
-        output.writeShort( totalCentralEntries);
-        output.writeInt( centralDirectorySize );
-        output.writeInt( centralStartOffset );
-        output.writeShort( (short)fileComment.length());
-        output.writeString( fileComment);
+        output.writeInt(signature);
+        output.writeShort(numberThisDisk);
+        output.writeShort(centralStartDisk);
+        output.writeShort(numCentralEntries);
+        output.writeShort(totalCentralEntries);
+        output.writeInt(centralDirectorySize);
+        output.writeInt(centralStartOffset);
+        output.writeShort((short) fileComment.length());
+        output.writeString(fileComment);
 
 
     }

app/src/full/java/kellinwood/zipio/ZioEntry.java

@@ -13,23 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package kellinwood.zipio;
 
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.File;
-import java.io.OutputStream;
-import java.io.SequenceInputStream;
-import java.util.Date;
-import java.util.zip.CRC32;
-import java.util.zip.Inflater;
-import java.util.zip.InflaterInputStream;
+package kellinwood.zipio;
 
 import kellinwood.logging.LoggerInterface;
 import kellinwood.logging.LoggerManager;
 
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.SequenceInputStream;
+import java.util.Date;
+import java.util.Locale;
+import java.util.zip.CRC32;
+import java.util.zip.Inflater;
+import java.util.zip.InflaterInputStream;
+
 public class ZioEntry implements Cloneable {
 
     private ZipInput zipInput;
@@ -51,48 +53,47 @@ public class ZioEntry implements Cloneable {
     private short diskNumberStart;
     private short internalAttributes;
     private int externalAttributes;
-    
+
     private int localHeaderOffset;
     private long dataPosition = -1;
     private byte[] data = null;
     private ZioEntryOutputStream entryOut = null;
-    
+
 
     private static byte[] alignBytes = new byte[4];
-    
+
     private static LoggerInterface log;
 
-    public ZioEntry( ZipInput input) {
+    public ZioEntry(ZipInput input) {
         zipInput = input;
     }
 
     public static LoggerInterface getLogger() {
-        if (log == null) log = LoggerManager.getLogger( ZioEntry.class.getName());
+        if (log == null) log = LoggerManager.getLogger(ZioEntry.class.getName());
         return log;
     }
 
-    public ZioEntry( String name) {
+    public ZioEntry(String name) {
         filename = name;
         fileComment = "";
         compression = 8;
         extraData = new byte[0];
-        setTime( System.currentTimeMillis());
+        setTime(System.currentTimeMillis());
     }
 
-    
-    public ZioEntry( String name, String sourceDataFile)
-        throws IOException
-    {
-        zipInput = new ZipInput( sourceDataFile);
+
+    public ZioEntry(String name, String sourceDataFile)
+            throws IOException {
+        zipInput = new ZipInput(sourceDataFile);
         filename = name;
         fileComment = "";
         this.compression = 0;
-        this.size = (int)zipInput.getFileLength();
+        this.size = (int) zipInput.getFileLength();
         this.compressedSize = this.size;
 
-        if (getLogger().isDebugEnabled()) 
-            getLogger().debug(String.format("Computing CRC for %s, size=%d",sourceDataFile,size));
-        
+        if (getLogger().isDebugEnabled())
+            getLogger().debug(String.format(Locale.ENGLISH, "Computing CRC for %s, size=%d", sourceDataFile, size));
+
         // compute CRC
         CRC32 crc = new CRC32();
 
@@ -100,27 +101,25 @@ public class ZioEntry implements Cloneable {
 
         int numRead = 0;
         while (numRead != size) {
-            int count = zipInput.read( buffer, 0, Math.min( buffer.length, (this.size - numRead)));
+            int count = zipInput.read(buffer, 0, Math.min(buffer.length, (this.size - numRead)));
             if (count > 0) {
-                crc.update( buffer, 0, count);
+                crc.update(buffer, 0, count);
                 numRead += count;
             }
         }
 
-        this.crc32 = (int)crc.getValue();
+        this.crc32 = (int) crc.getValue();
 
         zipInput.seek(0);
         this.dataPosition = 0;
         extraData = new byte[0];
-        setTime( new File(sourceDataFile).lastModified());
+        setTime(new File(sourceDataFile).lastModified());
     }
-    
-    
 
-    public ZioEntry( String name, String sourceDataFile, short compression, int crc32, int compressedSize, int size)
-        throws IOException
-    {
-        zipInput = new ZipInput( sourceDataFile);
+
+    public ZioEntry(String name, String sourceDataFile, short compression, int crc32, int compressedSize, int size)
+            throws IOException {
+        zipInput = new ZipInput(sourceDataFile);
         filename = name;
         fileComment = "";
         this.compression = compression;
@@ -129,39 +128,35 @@ public class ZioEntry implements Cloneable {
         this.size = size;
         this.dataPosition = 0;
         extraData = new byte[0];
-        setTime( new File(sourceDataFile).lastModified());
+        setTime(new File(sourceDataFile).lastModified());
     }
-    
+
     // Return a copy with a new name
-    public ZioEntry getClonedEntry( String newName) 
-    {
-        
+    public ZioEntry getClonedEntry(String newName) {
+
         ZioEntry clone;
         try {
-            clone = (ZioEntry)this.clone();
-        } 
-        catch (CloneNotSupportedException e) 
-        {
+            clone = (ZioEntry) this.clone();
+        } catch (CloneNotSupportedException e) {
             throw new IllegalStateException("clone() failed!");
         }
         clone.setName(newName);
         return clone;
     }
-    
-    public void readLocalHeader() throws IOException
-    {
+
+    public void readLocalHeader() throws IOException {
         ZipInput input = zipInput;
         int tmp;
         boolean debug = getLogger().isDebugEnabled();
 
-        input.seek( localHeaderOffset);
+        input.seek(localHeaderOffset);
 
-        if (debug) getLogger().debug( String.format("FILE POSITION: 0x%08x", input.getFilePointer()));
+        if (debug) getLogger().debug(String.format("FILE POSITION: 0x%08x", input.getFilePointer()));
 
         // 0 	4 	Local file header signature = 0x04034b50
         int signature = input.readInt();
         if (signature != 0x04034b50) {
-            throw new IllegalStateException( String.format("Local header not found at pos=0x%08x, file=%s", input.getFilePointer(), filename));
+            throw new IllegalStateException(String.format("Local header not found at pos=0x%08x, file=%s", input.getFilePointer(), filename));
         }
 
         // This method is usually called just before the data read, so
@@ -172,38 +167,46 @@ public class ZioEntry implements Cloneable {
 
         int tmpInt;
         short tmpShort;
-        
+
         // 4 	2 	Version needed to extract (minimum)
-        /* versionRequired */ tmpShort =  input.readShort();
+        /* versionRequired */
+        tmpShort = input.readShort();
         if (debug) log.debug(String.format("Version required: 0x%04x", tmpShort /*versionRequired*/));
 
         // 6 	2 	General purpose bit flag
-        /* generalPurposeBits */ tmpShort = input.readShort();
+        /* generalPurposeBits */
+        tmpShort = input.readShort();
         if (debug) log.debug(String.format("General purpose bits: 0x%04x", tmpShort /* generalPurposeBits */));
-        
+
         // 8 	2 	Compression method
-        /* compression */ tmpShort = input.readShort();
+        /* compression */
+        tmpShort = input.readShort();
         if (debug) log.debug(String.format("Compression: 0x%04x", tmpShort /* compression */));
 
         // 10 	2 	File last modification time
-        /* modificationTime */ tmpShort = input.readShort();
+        /* modificationTime */
+        tmpShort = input.readShort();
         if (debug) log.debug(String.format("Modification time: 0x%04x", tmpShort /* modificationTime */));
 
         // 12 	2 	File last modification date
-        /* modificationDate */ tmpShort = input.readShort();
+        /* modificationDate */
+        tmpShort = input.readShort();
         if (debug) log.debug(String.format("Modification date: 0x%04x", tmpShort /* modificationDate */));
 
         // 14 	4 	CRC-32
-        /* crc32 */ tmpInt = input.readInt();
+        /* crc32 */
+        tmpInt = input.readInt();
         if (debug) log.debug(String.format("CRC-32: 0x%04x", tmpInt /*crc32*/));
 
         // 18 	4 	Compressed size
-        /* compressedSize*/ tmpInt = input.readInt();
+        /* compressedSize*/
+        tmpInt = input.readInt();
         if (debug) log.debug(String.format("Compressed size: 0x%04x", tmpInt /*compressedSize*/));
 
         // 22 	4 	Uncompressed size
-        /* size */ tmpInt = input.readInt();
-        if (debug) log.debug(String.format("Size: 0x%04x", tmpInt /*size*/ ));
+        /* size */
+        tmpInt = input.readInt();
+        if (debug) log.debug(String.format("Size: 0x%04x", tmpInt /*size*/));
 
         // 26 	2 	File name length (n)
         short fileNameLen = input.readShort();
@@ -218,46 +221,45 @@ public class ZioEntry implements Cloneable {
         if (debug) log.debug("Filename: " + filename);
 
         // Extra data
-        byte[] extra = input.readBytes( extraLen);
+        byte[] extra = input.readBytes(extraLen);
 
         // Record the file position of this entry's data.
         dataPosition = input.getFilePointer();
-        if (debug) log.debug(String.format("Data position: 0x%08x",dataPosition));
+        if (debug) log.debug(String.format("Data position: 0x%08x", dataPosition));
 
     }
 
-    public void writeLocalEntry( ZipOutput output) throws IOException
-    {
+    public void writeLocalEntry(ZipOutput output) throws IOException {
         if (data == null && dataPosition < 0 && zipInput != null) {
             readLocalHeader();
         }
-        
-        localHeaderOffset = (int)output.getFilePointer();
+
+        localHeaderOffset = (int) output.getFilePointer();
 
         boolean debug = getLogger().isDebugEnabled();
-        
+
         if (debug) {
-            getLogger().debug( String.format("Writing local header at 0x%08x - %s", localHeaderOffset, filename));
+            getLogger().debug(String.format("Writing local header at 0x%08x - %s", localHeaderOffset, filename));
         }
-        
+
         if (entryOut != null) {
             entryOut.close();
             size = entryOut.getSize();
-            data = ((ByteArrayOutputStream)entryOut.getWrappedStream()).toByteArray();
+            data = ((ByteArrayOutputStream) entryOut.getWrappedStream()).toByteArray();
             compressedSize = data.length;
             crc32 = entryOut.getCRC();
         }
-        
-        output.writeInt( 0x04034b50);
-        output.writeShort( versionRequired);
-        output.writeShort( generalPurposeBits);
-        output.writeShort( compression);
-        output.writeShort( modificationTime);
-        output.writeShort( modificationDate);
-        output.writeInt( crc32);
-        output.writeInt( compressedSize);
-        output.writeInt( size);
-        output.writeShort( (short)filename.length());
+
+        output.writeInt(0x04034b50);
+        output.writeShort(versionRequired);
+        output.writeShort(generalPurposeBits);
+        output.writeShort(compression);
+        output.writeShort(modificationTime);
+        output.writeShort(modificationDate);
+        output.writeInt(crc32);
+        output.writeInt(compressedSize);
+        output.writeInt(size);
+        output.writeShort((short) filename.length());
 
         numAlignBytes = 0;
 
@@ -265,77 +267,74 @@ public class ZioEntry implements Cloneable {
         if (compression == 0) {
 
             long dataPos = output.getFilePointer() + // current position
-            2 +                                  // plus size of extra data length
-            filename.length() +                  // plus filename
-            extraData.length;                    // plus extra data
+                    2 +                                  // plus size of extra data length
+                    filename.length() +                  // plus filename
+                    extraData.length;                    // plus extra data
 
-            short dataPosMod4 = (short)(dataPos % 4);
+            short dataPosMod4 = (short) (dataPos % 4);
 
             if (dataPosMod4 > 0) {
-                numAlignBytes = (short)(4 - dataPosMod4);
+                numAlignBytes = (short) (4 - dataPosMod4);
             }
         }
 
-        
+
         // 28 	2 	Extra field length (m)
-        output.writeShort( (short)(extraData.length + numAlignBytes));
+        output.writeShort((short) (extraData.length + numAlignBytes));
 
         // 30 	n 	File name
-        output.writeString( filename);
+        output.writeString(filename);
 
         // Extra data
-        output.writeBytes( extraData);
+        output.writeBytes(extraData);
 
         // Zipalign bytes
         if (numAlignBytes > 0) {
-            output.writeBytes( alignBytes, 0, numAlignBytes);
+            output.writeBytes(alignBytes, 0, numAlignBytes);
         }
 
-        if (debug) getLogger().debug(String.format("Data position 0x%08x", output.getFilePointer()));
+        if (debug) getLogger().debug(String.format(Locale.ENGLISH, "Data position 0x%08x", output.getFilePointer()));
         if (data != null) {
-            output.writeBytes( data);
-            if (debug) getLogger().debug(String.format("Wrote %d bytes", data.length));
-        }
-        else {
+            output.writeBytes(data);
+            if (debug) getLogger().debug(String.format(Locale.ENGLISH, "Wrote %d bytes", data.length));
+        } else {
 
             if (debug) getLogger().debug(String.format("Seeking to position 0x%08x", dataPosition));
-            zipInput.seek( dataPosition);
-            
-            int bufferSize = Math.min( compressedSize, 8096);
+            zipInput.seek(dataPosition);
+
+            int bufferSize = Math.min(compressedSize, 8096);
             byte[] buffer = new byte[bufferSize];
             long totalCount = 0;
-            
+
             while (totalCount != compressedSize) {
-                int numRead = zipInput.in.read( buffer, 0, (int)Math.min( compressedSize -  totalCount, bufferSize));  
+                int numRead = zipInput.in.read(buffer, 0, (int) Math.min(compressedSize - totalCount, bufferSize));
                 if (numRead > 0) {
                     output.writeBytes(buffer, 0, numRead);
-                    if (debug) getLogger().debug(String.format("Wrote %d bytes", numRead));
+                    if (debug) getLogger().debug(String.format(Locale.ENGLISH, "Wrote %d bytes", numRead));
                     totalCount += numRead;
-                }
-                else throw new IllegalStateException(String.format("EOF reached while copying %s with %d bytes left to go", filename, compressedSize -  totalCount));
+                } else
+                    throw new IllegalStateException(String.format(Locale.ENGLISH, "EOF reached while copying %s with %d bytes left to go", filename, compressedSize - totalCount));
             }
         }
-    }		
-    
-    public static ZioEntry read(ZipInput input) throws IOException
-    {
+    }
+
+    public static ZioEntry read(ZipInput input) throws IOException {
 
         // 0    4   Central directory header signature = 0x02014b50
         int signature = input.readInt();
         if (signature != 0x02014b50) {
             // back up to the signature
-            input.seek( input.getFilePointer() - 4);
+            input.seek(input.getFilePointer() - 4);
             return null;
         }
 
-        ZioEntry entry = new ZioEntry( input);
+        ZioEntry entry = new ZioEntry(input);
 
-        entry.doRead( input);
+        entry.doRead(input);
         return entry;
     }
 
-    private void doRead( ZipInput input) throws IOException
-    {
+    private void doRead(ZipInput input) throws IOException {
 
         boolean debug = getLogger().isDebugEnabled();
 
@@ -352,7 +351,7 @@ public class ZioEntry implements Cloneable {
         if (debug) log.debug(String.format("General purpose bits: 0x%04x", generalPurposeBits));
         // Bits 1, 2, 3, and 11 are allowed to be set (first bit is bit zero).  Any others are a problem.
         if ((generalPurposeBits & 0xF7F1) != 0x0000) {
-            throw new IllegalStateException("Can't handle general purpose bits == "+String.format("0x%04x",generalPurposeBits));
+            throw new IllegalStateException("Can't handle general purpose bits == " + String.format("0x%04x", generalPurposeBits));
         }
 
         // 8    2   Compression method
@@ -406,13 +405,13 @@ public class ZioEntry implements Cloneable {
         filename = input.readString(fileNameLen);
         if (debug) log.debug("Filename: " + filename);
 
-        extraData = input.readBytes( extraLen);
+        extraData = input.readBytes(extraLen);
 
-        fileComment = input.readString( fileCommentLen);
+        fileComment = input.readString(fileCommentLen);
         if (debug) log.debug("File comment: " + fileComment);
 
-        generalPurposeBits = (short)(generalPurposeBits & 0x0800); // Don't write a data descriptor, preserve UTF-8 encoded filename bit
-        
+        generalPurposeBits = (short) (generalPurposeBits & 0x0800); // Don't write a data descriptor, preserve UTF-8 encoded filename bit
+
         // Don't write zero-length entries with compression.
         if (size == 0) {
             compressedSize = 0;
@@ -422,19 +421,21 @@ public class ZioEntry implements Cloneable {
 
     }
 
-    /** Returns the entry's data. */
-    public byte[] getData() throws IOException
-    {
+    /**
+     * Returns the entry's data.
+     */
+    public byte[] getData() throws IOException {
         if (data != null) return data;
-        
+
         byte[] tmpdata = new byte[size];
-        
+
         InputStream din = getInputStream();
         int count = 0;
-        
+
         while (count != size) {
-            int numRead = din.read( tmpdata, count, size-count);
-            if (numRead < 0) throw new IllegalStateException(String.format("Read failed, expecting %d bytes, got %d instead", size, count));
+            int numRead = din.read(tmpdata, count, size - count);
+            if (numRead < 0)
+                throw new IllegalStateException(String.format(Locale.ENGLISH, "Read failed, expecting %d bytes, got %d instead", size, count));
             count += numRead;
         }
         return tmpdata;
@@ -447,70 +448,68 @@ public class ZioEntry implements Cloneable {
 
     // Returns an input stream for reading the entry's data. 
     public InputStream getInputStream(OutputStream monitorStream) throws IOException {
-        
+
         if (entryOut != null) {
             entryOut.close();
             size = entryOut.getSize();
-            data = ((ByteArrayOutputStream)entryOut.getWrappedStream()).toByteArray();
+            data = ((ByteArrayOutputStream) entryOut.getWrappedStream()).toByteArray();
             compressedSize = data.length;
             crc32 = entryOut.getCRC();
             entryOut = null;
-            InputStream rawis = new ByteArrayInputStream( data);
+            InputStream rawis = new ByteArrayInputStream(data);
             if (compression == 0) return rawis;
             else {
                 // Hacky, inflate using a sequence of input streams that returns 1 byte more than the actual length of the data.  
                 // This extra dummy byte is required by InflaterInputStream when the data doesn't have the header and crc fields (as it is in zip files). 
-                return new InflaterInputStream( new SequenceInputStream(rawis, new ByteArrayInputStream(new byte[1])), new Inflater( true));
+                return new InflaterInputStream(new SequenceInputStream(rawis, new ByteArrayInputStream(new byte[1])), new Inflater(true));
             }
         }
-        
+
         ZioEntryInputStream dataStream;
         dataStream = new ZioEntryInputStream(this);
-        if (monitorStream != null) dataStream.setMonitorStream( monitorStream);
-        if (compression != 0)  {
+        if (monitorStream != null) dataStream.setMonitorStream(monitorStream);
+        if (compression != 0) {
             // Note: When using nowrap=true with Inflater it is also necessary to provide 
             // an extra "dummy" byte as input. This is required by the ZLIB native library 
             // in order to support certain optimizations.
             dataStream.setReturnDummyByte(true);
-            return new InflaterInputStream( dataStream, new Inflater( true));
-        }
-        else return dataStream;
+            return new InflaterInputStream(dataStream, new Inflater(true));
+        } else return dataStream;
     }
 
     // Returns an output stream for writing an entry's data.
-    public OutputStream getOutputStream() 
-    {
-        entryOut = new ZioEntryOutputStream( compression, new ByteArrayOutputStream());
+    public OutputStream getOutputStream() {
+        entryOut = new ZioEntryOutputStream(compression, new ByteArrayOutputStream());
         return entryOut;
     }
 
 
-    public void write( ZipOutput output) throws IOException {
+    public void write(ZipOutput output) throws IOException {
         boolean debug = getLogger().isDebugEnabled();
 
 
-        output.writeInt( 0x02014b50);
-        output.writeShort( versionMadeBy);
-        output.writeShort( versionRequired);
-        output.writeShort( generalPurposeBits);
-        output.writeShort( compression);
-        output.writeShort( modificationTime);
-        output.writeShort( modificationDate);
-        output.writeInt( crc32);
-        output.writeInt( compressedSize);
-        output.writeInt( size);
-        output.writeShort( (short)filename.length());
-        output.writeShort( (short)(extraData.length + numAlignBytes));
-        output.writeShort( (short)fileComment.length());
-        output.writeShort( diskNumberStart);
-        output.writeShort( internalAttributes);
-        output.writeInt( externalAttributes);
-        output.writeInt( localHeaderOffset);
-        
-        output.writeString( filename);
-        output.writeBytes( extraData);
-        if (numAlignBytes > 0) output.writeBytes( alignBytes, 0, numAlignBytes);
-        output.writeString( fileComment);
+        output.writeInt(0x02014b50);
+        output.writeShort(versionMadeBy);
+        output.writeShort(versionRequired);
+        output.writeShort(generalPurposeBits);
+        output.writeShort(compression);
+        output.writeShort(modificationTime);
+        output.writeShort(modificationDate);
+        output.writeInt(crc32);
+        output.writeInt(compressedSize);
+        output.writeInt(size);
+        output.writeShort((short) filename.length());
+        output.writeShort((short) (extraData.length + numAlignBytes));
+        output.writeShort((short) fileComment.length());
+        output.writeShort(diskNumberStart);
+        output.writeShort(internalAttributes);
+        output.writeInt(externalAttributes);
+        output.writeInt(localHeaderOffset);
+
+        output.writeString(filename);
+        output.writeBytes(extraData);
+        if (numAlignBytes > 0) output.writeBytes(alignBytes, 0, numAlignBytes);
+        output.writeString(fileComment);
 
     }
 
@@ -518,13 +517,13 @@ public class ZioEntry implements Cloneable {
      * Returns timetamp in Java format
      */
     public long getTime() {
-        int year = (int)(((modificationDate >> 9) & 0x007f) + 80);
-        int month = (int)(((modificationDate >> 5) & 0x000f) - 1);
-        int day = (int)(modificationDate & 0x001f);
-        int hour = (int)((modificationTime >> 11) & 0x001f);
-        int minute = (int)((modificationTime >> 5) & 0x003f);
-        int seconds = (int)((modificationTime << 1) & 0x003e);
-        Date d = new Date( year, month, day, hour, minute, seconds);
+        int year = (int) (((modificationDate >> 9) & 0x007f) + 80);
+        int month = (int) (((modificationDate >> 5) & 0x000f) - 1);
+        int day = (int) (modificationDate & 0x001f);
+        int hour = (int) ((modificationTime >> 11) & 0x001f);
+        int minute = (int) ((modificationTime >> 5) & 0x003f);
+        int seconds = (int) ((modificationTime << 1) & 0x003e);
+        Date d = new Date(year, month, day, hour, minute, seconds);
         return d.getTime();
     }
 
@@ -537,32 +536,33 @@ public class ZioEntry implements Cloneable {
         int year = d.getYear() + 1900;
         if (year < 1980) {
             dtime = (1 << 21) | (1 << 16);
-        }
-        else {
+        } else {
             dtime = (year - 1980) << 25 | (d.getMonth() + 1) << 21 |
-            d.getDate() << 16 | d.getHours() << 11 | d.getMinutes() << 5 |
-            d.getSeconds() >> 1;
+                    d.getDate() << 16 | d.getHours() << 11 | d.getMinutes() << 5 |
+                    d.getSeconds() >> 1;
         }
 
-        modificationDate = (short)(dtime >> 16);
-        modificationTime = (short)(dtime & 0xFFFF);
+        modificationDate = (short) (dtime >> 16);
+        modificationTime = (short) (dtime & 0xFFFF);
     }
 
     public boolean isDirectory() {
         return filename.endsWith("/");
     }
-    
+
     public String getName() {
         return filename;
     }
-    
-    public void setName( String filename) {
+
+    public void setName(String filename) {
         this.filename = filename;
     }
-    
-    /** Use 0 (STORED), or 8 (DEFLATE). */
-    public void setCompression( int compression) {
-        this.compression = (short)compression;
+
+    /**
+     * Use 0 (STORED), or 8 (DEFLATE).
+     */
+    public void setCompression(int compression) {
+        this.compression = (short) compression;
     }
 
     public short getVersionMadeBy() {

app/src/full/java/kellinwood/zipio/ZioEntryInputStream.java

@@ -13,18 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.zipio;
 
+import kellinwood.logging.LoggerInterface;
+import kellinwood.logging.LoggerManager;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.io.RandomAccessFile;
-
-import kellinwood.logging.LoggerInterface;
-import kellinwood.logging.LoggerManager;
+import java.util.Locale;
 
 
-/** Input stream used to read just the data from a zip file entry. */
+/**
+ * Input stream used to read just the data from a zip file entry.
+ */
 public class ZioEntryInputStream extends InputStream {
 
     RandomAccessFile raf;
@@ -34,36 +38,35 @@ public class ZioEntryInputStream extends InputStream {
     boolean debug;
     boolean returnDummyByte = false;
     OutputStream monitor = null;
-    
-    public ZioEntryInputStream( ZioEntry entry) throws IOException {
 
-        log = LoggerManager.getLogger( this.getClass().getName());
+    public ZioEntryInputStream(ZioEntry entry) throws IOException {
+
+        log = LoggerManager.getLogger(this.getClass().getName());
         debug = log.isDebugEnabled();
         offset = 0;
         size = entry.getCompressedSize();
         raf = entry.getZipInput().in;
         long dpos = entry.getDataPosition();
         if (dpos >= 0) {
-            if (debug) log.debug(String.format("Seeking to %d", entry.getDataPosition()));
-            raf.seek( entry.getDataPosition());
-        }
-        else {
+            if (debug) log.debug(String.format(Locale.ENGLISH, "Seeking to %d", entry.getDataPosition()));
+            raf.seek(entry.getDataPosition());
+        } else {
             // seeks to, then reads, the local header, causing the 
             // file pointer to be positioned at the start of the data.
             entry.readLocalHeader();
         }
-        
+
     }
 
-    public void setReturnDummyByte( boolean returnExtraByte) {
+    public void setReturnDummyByte(boolean returnExtraByte) {
         returnDummyByte = returnExtraByte;
     }
-    
+
     // For debugging, if the monitor is set we write all data read to the monitor.
     public void setMonitorStream(OutputStream monitorStream) {
         monitor = monitorStream;
     }
-    
+
     @Override
     public void close() throws IOException {
     }
@@ -76,7 +79,7 @@ public class ZioEntryInputStream extends InputStream {
     @Override
     public int available() throws IOException {
         int available = size - offset;
-        if (debug) log.debug(String.format("Available = %d", available));
+        if (debug) log.debug(String.format(Locale.ENGLISH, "Available = %d", available));
         if (available == 0 && returnDummyByte) return 1;
         else return available;
     }
@@ -87,22 +90,20 @@ public class ZioEntryInputStream extends InputStream {
             if (returnDummyByte) {
                 returnDummyByte = false;
                 return 0;
-            }
-            else return -1;
+            } else return -1;
         }
         int b = raf.read();
         if (b >= 0) {
             if (monitor != null) monitor.write(b);
             if (debug) log.debug("Read 1 byte");
             offset += 1;
-        }
-        else if (debug) log.debug("Read 0 bytes");        
+        } else if (debug) log.debug("Read 0 bytes");
         return b;
     }
 
     @Override
     public int read(byte[] b, int off, int len) throws IOException {
-        return readBytes( b, off, len);
+        return readBytes(b, off, len);
     }
 
     private int readBytes(byte[] b, int off, int len) throws IOException {
@@ -111,29 +112,28 @@ public class ZioEntryInputStream extends InputStream {
                 returnDummyByte = false;
                 b[off] = 0;
                 return 1;
-            }
-            else return -1;
-        }        
-        int numToRead = Math.min( len, available());
+            } else return -1;
+        }
+        int numToRead = Math.min(len, available());
         int numRead = raf.read(b, off, numToRead);
         if (numRead > 0) {
             if (monitor != null) monitor.write(b, off, numRead);
             offset += numRead;
         }
-        if (debug) log.debug(String.format("Read %d bytes for read(b,%d,%d)", numRead, off, len));
+        if (debug) log.debug(String.format(Locale.ENGLISH, "Read %d bytes for read(b,%d,%d)", numRead, off, len));
         return numRead;
     }
 
     @Override
     public int read(byte[] b) throws IOException {
-        return readBytes( b, 0, b.length);
+        return readBytes(b, 0, b.length);
     }
 
     @Override
     public long skip(long n) throws IOException {
-        long numToSkip = Math.min( n, available());
-        raf.seek( raf.getFilePointer() + numToSkip);
-        if (debug) log.debug(String.format("Skipped %d bytes", numToSkip));                
+        long numToSkip = Math.min(n, available());
+        raf.seek(raf.getFilePointer() + numToSkip);
+        if (debug) log.debug(String.format(Locale.ENGLISH, "Skipped %d bytes", numToSkip));
         return numToSkip;
     }
 }

app/src/full/java/kellinwood/zipio/ZioEntryOutputStream.java

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.zipio;
 
-import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.zip.CRC32;
@@ -28,25 +28,31 @@ public class ZioEntryOutputStream extends OutputStream {
     int crcValue = 0;
     OutputStream wrapped;
     OutputStream downstream;
-    
-    public ZioEntryOutputStream( int compression, OutputStream wrapped) 
-    {
+    Deflater deflater;
+
+    public ZioEntryOutputStream(int compression, OutputStream wrapped) {
         this.wrapped = wrapped;
-        if (compression != 0)
-            downstream = new DeflaterOutputStream( wrapped, new Deflater( Deflater.BEST_COMPRESSION, true));
-        else downstream = wrapped;
+        if (compression != 0) {
+            deflater = new Deflater(Deflater.BEST_COMPRESSION, true);
+            downstream = new DeflaterOutputStream(wrapped, deflater);
+        } else {
+            downstream = wrapped;
+        }
     }
-    
+
     public void close() throws IOException {
         downstream.flush();
         downstream.close();
-        crcValue = (int)crc.getValue();
+        crcValue = (int) crc.getValue();
+        if (deflater != null) {
+            deflater.end();
+        }
     }
 
     public int getCRC() {
         return crcValue;
     }
-    
+
     public void flush() throws IOException {
         downstream.flush();
     }
@@ -58,14 +64,14 @@ public class ZioEntryOutputStream extends OutputStream {
     }
 
     public void write(byte[] b, int off, int len) throws IOException {
-        downstream.write( b, off, len);
-        crc.update( b, off, len);
+        downstream.write(b, off, len);
+        crc.update(b, off, len);
         size += len;
     }
 
     public void write(int b) throws IOException {
-        downstream.write( b);
-        crc.update( b);
+        downstream.write(b);
+        crc.update(b);
         size += 1;
     }
 
@@ -73,10 +79,9 @@ public class ZioEntryOutputStream extends OutputStream {
         return size;
     }
 
-    public OutputStream getWrappedStream()
-    {
+    public OutputStream getWrappedStream() {
         return wrapped;
     }
-    
+
 }
 

app/src/full/java/kellinwood/zipio/ZipInput.java

@@ -13,16 +13,19 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.zipio;
 
+import kellinwood.logging.LoggerInterface;
+import kellinwood.logging.LoggerManager;
+
+import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
 import java.io.RandomAccessFile;
-import java.text.DateFormat;
-import java.text.SimpleDateFormat;
 import java.util.Collection;
-import java.util.Date;
 import java.util.LinkedHashMap;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
@@ -30,16 +33,10 @@ import java.util.jar.Manifest;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-
-import kellinwood.logging.LoggerInterface;
-import kellinwood.logging.LoggerManager;
-
 /**
  *
  */
-public class ZipInput 
-{
-
+public class ZipInput implements Closeable {
     static LoggerInterface log;
 
     public String inputFilename;
@@ -47,14 +44,13 @@ public class ZipInput
     long fileLength;
     int scanIterations = 0;
 
-    Map<String,ZioEntry> zioEntries = new LinkedHashMap<String,ZioEntry>();
+    Map<String, ZioEntry> zioEntries = new LinkedHashMap<String, ZioEntry>();
     CentralEnd centralEnd;
     Manifest manifest;
 
-    public ZipInput( String filename) throws IOException
-    {
+    public ZipInput(String filename) throws IOException {
         this.inputFilename = filename;
-        in = new RandomAccessFile( new File( inputFilename), "r");
+        in = new RandomAccessFile(new File(inputFilename), "r");
         fileLength = in.length();
     }
 
@@ -70,127 +66,131 @@ public class ZipInput
     public long getFileLength() {
         return fileLength;
     }
-    
-    public static ZipInput read( String filename) throws IOException {
-        ZipInput zipInput = new ZipInput( filename);
+
+    public static ZipInput read(String filename) throws IOException {
+        ZipInput zipInput = new ZipInput(filename);
         zipInput.doRead();
         return zipInput;
     }
-    
-    
-    public ZioEntry getEntry( String filename) {
+
+
+    public ZioEntry getEntry(String filename) {
         return zioEntries.get(filename);
     }
-    
-    public Map<String,ZioEntry> getEntries() {
+
+    public Map<String, ZioEntry> getEntries() {
         return zioEntries;
     }
-    
-    /** Returns the names of immediate children in the directory with the given name.
-     *  The path value must end with a "/" character.  Use a value of "/" 
-     *  to get the root entries.
+
+    /**
+     * Returns the names of immediate children in the directory with the given name.
+     * The path value must end with a "/" character.  Use a value of "/"
+     * to get the root entries.
      */
-    public Collection<String> list(String path) 
-    {
+    public Collection<String> list(String path) {
         if (!path.endsWith("/")) throw new IllegalArgumentException("Invalid path -- does not end with '/'");
-        
+
         if (path.startsWith("/")) path = path.substring(1);
-       
-        Pattern p = Pattern.compile( String.format("^%s([^/]+/?).*", path));
-        
+
+        Pattern p = Pattern.compile(String.format("^%s([^/]+/?).*", path));
+
         Set<String> names = new TreeSet<String>();
-        
+
         for (String name : zioEntries.keySet()) {
             Matcher m = p.matcher(name);
             if (m.matches()) names.add(m.group(1));
         }
         return names;
     }
-    
+
     public Manifest getManifest() throws IOException {
         if (manifest == null) {
             ZioEntry e = zioEntries.get("META-INF/MANIFEST.MF");
             if (e != null) {
-                manifest = new Manifest( e.getInputStream());
+                manifest = new Manifest(e.getInputStream());
             }
         }
-        return manifest; 
+        return manifest;
     }
 
-    /** Scan the end of the file for the end of central directory record (EOCDR).
-        Returns the file offset of the EOCD signature.  The size parameter is an
-        initial buffer size (e.g., 256).
+    /**
+     * Scan the end of the file for the end of central directory record (EOCDR).
+     * Returns the file offset of the EOCD signature.  The size parameter is an
+     * initial buffer size (e.g., 256).
      */
-    public long scanForEOCDR( int size) throws IOException {
-        if (size > fileLength || size > 65536) throw new IllegalStateException( "End of central directory not found in " + inputFilename);
+    public long scanForEOCDR(int size) throws IOException {
+        if (size > fileLength || size > 65536)
+            throw new IllegalStateException("End of central directory not found in " + inputFilename);
 
-        int scanSize = (int)Math.min( fileLength, size);
+        int scanSize = (int) Math.min(fileLength, size);
 
         byte[] scanBuf = new byte[scanSize];
 
-        in.seek( fileLength - scanSize);
+        in.seek(fileLength - scanSize);
 
-        in.readFully( scanBuf);
+        in.readFully(scanBuf);
 
         for (int i = scanSize - 22; i >= 0; i--) {
             scanIterations += 1;
-            if (scanBuf[i] == 0x50 && scanBuf[i+1] == 0x4b && scanBuf[i+2] == 0x05 && scanBuf[i+3] == 0x06) {
+            if (scanBuf[i] == 0x50 && scanBuf[i + 1] == 0x4b && scanBuf[i + 2] == 0x05 && scanBuf[i + 3] == 0x06) {
                 return fileLength - scanSize + i;
             }
         }
 
-        return scanForEOCDR( size * 2);
+        return scanForEOCDR(size * 2);
     }
-                              
-        
-    private void doRead()
-    {
+
+
+    private void doRead() {
         try {
 
-            long posEOCDR = scanForEOCDR( 256);
-            in.seek( posEOCDR);
-            centralEnd = CentralEnd.read( this);
+            long posEOCDR = scanForEOCDR(256);
+            in.seek(posEOCDR);
+            centralEnd = CentralEnd.read(this);
 
             boolean debug = getLogger().isDebugEnabled();
             if (debug) {
-                getLogger().debug(String.format("EOCD found in %d iterations", scanIterations));
-                getLogger().debug(String.format("Directory entries=%d, size=%d, offset=%d/0x%08x", centralEnd.totalCentralEntries,
-                                                centralEnd.centralDirectorySize, centralEnd.centralStartOffset, centralEnd.centralStartOffset));
+                getLogger().debug(String.format(Locale.ENGLISH, "EOCD found in %d iterations", scanIterations));
+                getLogger().debug(String.format(Locale.ENGLISH, "Directory entries=%d, size=%d, offset=%d/0x%08x", centralEnd.totalCentralEntries,
+                        centralEnd.centralDirectorySize, centralEnd.centralStartOffset, centralEnd.centralStartOffset));
 
-                ZipListingHelper.listHeader( getLogger());
+                ZipListingHelper.listHeader(getLogger());
             }
 
-            in.seek( centralEnd.centralStartOffset);            
+            in.seek(centralEnd.centralStartOffset);
 
             for (int i = 0; i < centralEnd.totalCentralEntries; i++) {
                 ZioEntry entry = ZioEntry.read(this);
-                zioEntries.put( entry.getName(), entry);
-                if (debug) ZipListingHelper.listEntry( getLogger(), entry);
+                zioEntries.put(entry.getName(), entry);
+                if (debug) ZipListingHelper.listEntry(getLogger(), entry);
             }
 
-        }
-        catch (Throwable t) {
+        } catch (Throwable t) {
             t.printStackTrace();
-        }    	
+        }
     }
 
+    @Override
     public void close() {
-        if (in != null) try { in.close(); } catch( Throwable t) {}
+        if (in != null) try {
+            in.close();
+        } catch (Throwable t) {
+        }
     }
 
     public long getFilePointer() throws IOException {
-        return in.getFilePointer(); 
+        return in.getFilePointer();
     }
 
-    public void seek( long position) throws IOException {
+    public void seek(long position) throws IOException {
         in.seek(position);
     }
 
     public byte readByte() throws IOException {
         return in.readByte();
     }
-    
-    public int readInt() throws IOException{
+
+    public int readInt() throws IOException {
         int result = 0;
         for (int i = 0; i < 4; i++) {
             result |= (in.readUnsignedByte() << (8 * i));
@@ -206,7 +206,7 @@ public class ZipInput
         return result;
     }
 
-    public String readString( int length) throws IOException {
+    public String readString(int length) throws IOException {
 
         byte[] buffer = new byte[length];
         for (int i = 0; i < length; i++) {
@@ -215,7 +215,7 @@ public class ZipInput
         return new String(buffer);
     }
 
-    public byte[] readBytes( int length) throws IOException {
+    public byte[] readBytes(int length) throws IOException {
 
         byte[] buffer = new byte[length];
         for (int i = 0; i < length; i++) {
@@ -224,10 +224,9 @@ public class ZipInput
         return buffer;
     }
 
-    public int read( byte[] b, int offset, int length) throws IOException {
-        return in.read( b, offset, length);
+    public int read(byte[] b, int offset, int length) throws IOException {
+        return in.read(b, offset, length);
     }
-
 }
 
 

app/src/full/java/kellinwood/zipio/ZipListingHelper.java

@@ -13,41 +13,40 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.zipio;
 
-import java.util.Date;
+import kellinwood.logging.LoggerInterface;
+
 import java.text.DateFormat;
 import java.text.SimpleDateFormat;
-import kellinwood.logging.LoggerInterface;
-import kellinwood.logging.LoggerManager;
+import java.util.Date;
+import java.util.Locale;
 
 /**
  *
  */
-public class ZipListingHelper
-{
+public class ZipListingHelper {
 
-    static DateFormat dateFormat = new SimpleDateFormat("MM-dd-yy HH:mm");
-    
-    public static void listHeader(LoggerInterface log)
-    {
+    static DateFormat dateFormat = new SimpleDateFormat("MM-dd-yy HH:mm", Locale.ENGLISH);
+
+    public static void listHeader(LoggerInterface log) {
         log.debug(" Length   Method    Size  Ratio   Date   Time   CRC-32    Name");
         log.debug("--------  ------  ------- -----   ----   ----   ------    ----");
-        
+
     }
 
-    public static void listEntry(LoggerInterface log, ZioEntry entry)
-    {
+    public static void listEntry(LoggerInterface log, ZioEntry entry) {
         int ratio = 0;
         if (entry.getSize() > 0) ratio = (100 * (entry.getSize() - entry.getCompressedSize())) / entry.getSize();
-        log.debug(String.format("%8d  %6s %8d %4d%% %s  %08x  %s",
-                                entry.getSize(),
-                                entry.getCompression() == 0 ? "Stored" : "Defl:N",
-                                entry.getCompressedSize(),
-                                ratio,
-                                dateFormat.format( new Date( entry.getTime())),
-                                entry.getCrc32(),
-                                entry.getName()));
+        log.debug(String.format(Locale.ENGLISH, "%8d  %6s %8d %4d%% %s  %08x  %s",
+                entry.getSize(),
+                entry.getCompression() == 0 ? "Stored" : "Defl:N",
+                entry.getCompressedSize(),
+                ratio,
+                dateFormat.format(new Date(entry.getTime())),
+                entry.getCrc32(),
+                entry.getName()));
     }
 }
 

app/src/full/java/kellinwood/zipio/ZipOutput.java

@@ -13,24 +13,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package kellinwood.zipio;
 
+import kellinwood.logging.LoggerInterface;
+import kellinwood.logging.LoggerManager;
+
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
-import java.util.List;
-import java.util.LinkedList;
 import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.List;
 import java.util.Set;
-import kellinwood.logging.LoggerInterface;
-import kellinwood.logging.LoggerManager;
 
 /**
  *
  */
-public class ZipOutput 
-{
+public class ZipOutput {
 
     static LoggerInterface log;
 
@@ -40,71 +41,68 @@ public class ZipOutput
 
     List<ZioEntry> entriesWritten = new LinkedList<ZioEntry>();
     Set<String> namesWritten = new HashSet<String>();
-    
-    public ZipOutput( String filename) throws IOException
-    {
+
+    public ZipOutput(String filename) throws IOException {
         this.outputFilename = filename;
-        File ofile = new File( outputFilename);
+        File ofile = new File(outputFilename);
         init(ofile);
     }
-    
-    public ZipOutput( File outputFile) throws IOException
-    {
+
+    public ZipOutput(File outputFile) throws IOException {
         this.outputFilename = outputFile.getAbsolutePath();
         File ofile = outputFile;
         init(ofile);
     }
-        
-    private void init( File ofile) throws IOException
-    {
+
+    private void init(File ofile) throws IOException {
         if (ofile.exists()) ofile.delete();
-        out = new FileOutputStream( ofile);
-        if (getLogger().isDebugEnabled()) ZipListingHelper.listHeader( getLogger());
-        
+        out = new FileOutputStream(ofile);
+        if (getLogger().isDebugEnabled()) ZipListingHelper.listHeader(getLogger());
+
     }
 
-    public ZipOutput( OutputStream os) throws IOException
-    {
+    public ZipOutput(OutputStream os) throws IOException {
         out = os;
     }
-    
+
     private static LoggerInterface getLogger() {
         if (log == null) log = LoggerManager.getLogger(ZipOutput.class.getName());
         return log;
     }
 
-    public void write( ZioEntry entry) throws IOException {
+    public void write(ZioEntry entry) throws IOException {
         String entryName = entry.getName();
-        if (namesWritten.contains( entryName)) {
+        if (namesWritten.contains(entryName)) {
             getLogger().warning("Skipping duplicate file in output: " + entryName);
             return;
         }
-        entry.writeLocalEntry( this);
-        entriesWritten.add( entry);
-        namesWritten.add( entryName);
-        if (getLogger().isDebugEnabled()) ZipListingHelper.listEntry( getLogger(), entry);
-        
+        entry.writeLocalEntry(this);
+        entriesWritten.add(entry);
+        namesWritten.add(entryName);
+        if (getLogger().isDebugEnabled()) ZipListingHelper.listEntry(getLogger(), entry);
+
     }
 
 
-    
-    public void close() throws IOException
-    {
+    public void close() throws IOException {
         CentralEnd centralEnd = new CentralEnd();
-        
-        centralEnd.centralStartOffset = (int)getFilePointer();
-        centralEnd.numCentralEntries = centralEnd.totalCentralEntries = (short)entriesWritten.size();
-        
+
+        centralEnd.centralStartOffset = (int) getFilePointer();
+        centralEnd.numCentralEntries = centralEnd.totalCentralEntries = (short) entriesWritten.size();
+
         for (ZioEntry entry : entriesWritten) {
-            entry.write( this);
+            entry.write(this);
         }
-        
-        centralEnd.centralDirectorySize = (int)(getFilePointer() - centralEnd.centralStartOffset);
+
+        centralEnd.centralDirectorySize = (int) (getFilePointer() - centralEnd.centralStartOffset);
         centralEnd.fileComment = "";
-        
-        centralEnd.write( this);
-        
-        if (out != null) try { out.close(); } catch( Throwable t) {}
+
+        centralEnd.write(this);
+
+        if (out != null) try {
+            out.close();
+        } catch (Throwable t) {
+        }
     }
 
     public int getFilePointer() throws IOException {
@@ -112,44 +110,44 @@ public class ZipOutput
     }
 
 
-    public void writeInt( int value) throws IOException{
+    public void writeInt(int value) throws IOException {
         byte[] data = new byte[4];
         for (int i = 0; i < 4; i++) {
-            data[i] = (byte)(value & 0xFF);
+            data[i] = (byte) (value & 0xFF);
             value = value >> 8;
         }
-        out.write( data);
+        out.write(data);
         filePointer += 4;
     }
 
-    public void writeShort( short value) throws IOException {
+    public void writeShort(short value) throws IOException {
         byte[] data = new byte[2];
         for (int i = 0; i < 2; i++) {
-            data[i] = (byte)(value & 0xFF);
-            value = (short)(value >> 8);
+            data[i] = (byte) (value & 0xFF);
+            value = (short) (value >> 8);
         }
-        out.write( data);
+        out.write(data);
         filePointer += 2;
     }
 
-    public void writeString( String value) throws IOException {
+    public void writeString(String value) throws IOException {
 
         byte[] data = value.getBytes();
-        out.write( data);
+        out.write(data);
         filePointer += data.length;
     }
 
-    public void writeBytes( byte[] value) throws IOException {
+    public void writeBytes(byte[] value) throws IOException {
 
-        out.write( value);
+        out.write(value);
         filePointer += value.length;
     }
 
-    public void writeBytes( byte[] value, int offset, int length) throws IOException {
+    public void writeBytes(byte[] value, int offset, int length) throws IOException {
 
-        out.write( value, offset, length);
+        out.write(value, offset, length);
         filePointer += length;
-    }    
+    }
 
 }
 

app/src/full/java/org/fdroid/fdroid/nearby/BluetoothClient.java

@@ -0,0 +1,32 @@
+package org.fdroid.fdroid.nearby;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothSocket;
+
+import java.io.IOException;
+
+public class BluetoothClient {
+    private static final String TAG = "BluetoothClient";
+
+    private final BluetoothDevice device;
+
+    public BluetoothClient(String macAddress) {
+        device = BluetoothAdapter.getDefaultAdapter().getRemoteDevice(macAddress);
+    }
+
+    public BluetoothConnection openConnection() throws IOException {
+
+        BluetoothConnection connection = null;
+        try {
+            BluetoothSocket socket = device.createInsecureRfcommSocketToServiceRecord(BluetoothConstants.fdroidUuid());
+            connection = new BluetoothConnection(socket);
+            connection.open();
+            return connection;
+        } finally {
+            if (connection != null) {
+                connection.closeQuietly();
+            }
+        }
+    }
+}

app/src/full/java/org/fdroid/fdroid/nearby/BluetoothManager.java

@@ -0,0 +1,179 @@
+package org.fdroid.fdroid.nearby;
+
+import android.bluetooth.BluetoothAdapter;
+import android.bluetooth.BluetoothDevice;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.os.Process;
+import android.text.TextUtils;
+import android.util.Log;
+
+import org.fdroid.fdroid.R;
+import org.fdroid.fdroid.Utils;
+import org.fdroid.fdroid.nearby.peers.BluetoothPeer;
+
+import java.lang.ref.WeakReference;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+/**
+ * Manage the {@link android.bluetooth.BluetoothAdapter}in a {@link HandlerThread}.
+ * The start process is in {@link HandlerThread#onLooperPrepared()} so that it is
+ * always started before any messages get delivered from the queue.
+ *
+ * @see BonjourManager
+ * @see LocalRepoManager
+ */
+public class BluetoothManager {
+    private static final String TAG = "BluetoothManager";
+
+    public static final String ACTION_FOUND = "BluetoothNewPeer";
+    public static final String EXTRA_PEER = "extraBluetoothPeer";
+
+    public static final String ACTION_STATUS = "BluetoothStatus";
+    public static final String EXTRA_STATUS = "BluetoothStatusExtra";
+    public static final int STATUS_STARTING = 0;
+    public static final int STATUS_STARTED = 1;
+    public static final int STATUS_STOPPING = 2;
+    public static final int STATUS_STOPPED = 3;
+    public static final int STATUS_ERROR = 0xffff;
+
+    private static final int STOP = 5709;
+
+    private static WeakReference<Context> context;
+    private static Handler handler;
+    private static volatile HandlerThread handlerThread;
+    private static BluetoothAdapter bluetoothAdapter;
+
+    /**
+     * Stops the Bluetooth adapter, triggering a status broadcast via {@link #ACTION_STATUS}.
+     * {@link #STATUS_STOPPED} can be broadcast multiple times for the same session,
+     * so make sure {@link android.content.BroadcastReceiver}s handle duplicates.
+     */
+    public static void stop(Context context) {
+        BluetoothManager.context = new WeakReference<>(context);
+        if (handler == null || handlerThread == null || !handlerThread.isAlive()) {
+            Log.w(TAG, "handlerThread is already stopped, doing nothing!");
+            sendBroadcast(STATUS_STOPPED, null);
+            return;
+        }
+        sendBroadcast(STATUS_STOPPING, null);
+        handler.sendEmptyMessage(STOP);
+    }
+
+    /**
+     * Starts the service, triggering a status broadcast via {@link #ACTION_STATUS}.
+     * {@link #STATUS_STARTED} can be broadcast multiple times for the same session,
+     * so make sure {@link android.content.BroadcastReceiver}s handle duplicates.
+     */
+    public static void start(final Context context) {
+        BluetoothManager.context = new WeakReference<>(context);
+        if (handlerThread != null && handlerThread.isAlive()) {
+            sendBroadcast(STATUS_STARTED, null);
+            return;
+        }
+        sendBroadcast(STATUS_STARTING, null);
+
+        final BluetoothServer bluetoothServer = new BluetoothServer(context.getFilesDir());
+        handlerThread = new HandlerThread("BluetoothManager", Process.THREAD_PRIORITY_LESS_FAVORABLE) {
+            @Override
+            protected void onLooperPrepared() {
+                LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(context);
+                localBroadcastManager.registerReceiver(bluetoothDeviceFound,
+                        new IntentFilter(BluetoothDevice.ACTION_FOUND));
+                bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
+                String name = bluetoothAdapter.getName();
+                if (name != null) {
+                    SwapService.putBluetoothNameBeforeSwap(name);
+                }
+                if (!bluetoothAdapter.enable()) {
+                    sendBroadcast(STATUS_ERROR, context.getString(R.string.swap_error_cannot_start_bluetooth));
+                    return;
+                }
+                bluetoothServer.start();
+                if (bluetoothAdapter.startDiscovery()) {
+                    sendBroadcast(STATUS_STARTED, null);
+                } else {
+                    sendBroadcast(STATUS_ERROR, context.getString(R.string.swap_error_cannot_start_bluetooth));
+                }
+                for (BluetoothDevice device : bluetoothAdapter.getBondedDevices()) {
+                    sendFoundBroadcast(context, device);
+                }
+            }
+        };
+        handlerThread.start();
+        handler = new Handler(handlerThread.getLooper()) {
+            @Override
+            public void handleMessage(Message msg) {
+                LocalBroadcastManager localBroadcastManager = LocalBroadcastManager.getInstance(context);
+                localBroadcastManager.unregisterReceiver(bluetoothDeviceFound);
+                bluetoothServer.close();
+                if (bluetoothAdapter != null) {
+                    bluetoothAdapter.cancelDiscovery();
+                    if (!SwapService.wasBluetoothEnabledBeforeSwap()) {
+                        bluetoothAdapter.disable();
+                    }
+                    String name = SwapService.getBluetoothNameBeforeSwap();
+                    if (name != null) {
+                        bluetoothAdapter.setName(name);
+                    }
+                }
+                handlerThread.quit();
+                handlerThread = null;
+                sendBroadcast(STATUS_STOPPED, null);
+            }
+        };
+    }
+
+    public static void restart(Context context) {
+        stop(context);
+        try {
+            handlerThread.join(10000);
+        } catch (InterruptedException | NullPointerException e) {
+            // ignored
+        }
+        start(context);
+    }
+
+    public static void setName(Context context, String name) {
+        // TODO
+    }
+
+    public static boolean isAlive() {
+        return handlerThread != null && handlerThread.isAlive();
+    }
+
+    private static void sendBroadcast(int status, String message) {
+
+        Intent intent = new Intent(ACTION_STATUS);
+        intent.putExtra(EXTRA_STATUS, status);
+        if (!TextUtils.isEmpty(message)) {
+            intent.putExtra(Intent.EXTRA_TEXT, message);
+        }
+        LocalBroadcastManager.getInstance(context.get()).sendBroadcast(intent);
+    }
+
+    private static final BroadcastReceiver bluetoothDeviceFound = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            sendFoundBroadcast(context, (BluetoothDevice) intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE));
+        }
+    };
+
+    private static void sendFoundBroadcast(Context context, BluetoothDevice device) {
+        BluetoothPeer bluetoothPeer = BluetoothPeer.getInstance(device);
+        if (bluetoothPeer == null) {
+            Utils.debugLog(TAG, "IGNORING: " + device);
+            return;
+        }
+        Intent intent = new Intent(ACTION_FOUND);
+        intent.putExtra(EXTRA_PEER, bluetoothPeer);
+        intent.putExtra(BluetoothDevice.EXTRA_DEVICE, device);
+        LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
+    }
+}

app/src/full/java/org/fdroid/fdroid/nearby/BluetoothServer.java

@@ -1,4 +1,4 @@
-package org.fdroid.fdroid.net.bluetooth;
+package org.fdroid.fdroid.nearby;
 
 import android.bluetooth.BluetoothAdapter;
 import android.bluetooth.BluetoothServerSocket;
@@ -7,14 +7,14 @@ import android.util.Log;
 import android.webkit.MimeTypeMap;
 
 import org.fdroid.fdroid.Utils;
-import org.fdroid.fdroid.localrepo.type.BluetoothSwap;
-import org.fdroid.fdroid.net.bluetooth.httpish.Request;
-import org.fdroid.fdroid.net.bluetooth.httpish.Response;
+import org.fdroid.fdroid.nearby.httpish.Request;
+import org.fdroid.fdroid.nearby.httpish.Response;
 
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.HttpURLConnection;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
@@ -26,6 +26,7 @@ import fi.iki.elonen.NanoHTTPD;
  * Act as a layer on top of LocalHTTPD server, by forwarding requests served
  * over bluetooth to that server.
  */
+@SuppressWarnings("LineLength")
 public class BluetoothServer extends Thread {
 
     private static final String TAG = "BluetoothServer";
@@ -34,18 +35,9 @@ public class BluetoothServer extends Thread {
     private final List<ClientConnection> clients = new ArrayList<>();
 
     private final File webRoot;
-    private final BluetoothSwap swap;
-    private boolean isRunning;
 
-    public BluetoothServer(BluetoothSwap swap, File webRoot) {
+    public BluetoothServer(File webRoot) {
         this.webRoot = webRoot;
-        this.swap = swap;
-
-        start();
-    }
-
-    public boolean isRunning() {
-        return isRunning;
     }
 
     public void close() {
@@ -64,15 +56,12 @@ public class BluetoothServer extends Thread {
     @Override
     public void run() {
 
-        isRunning = true;
-        BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
+        final BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
 
         try {
             serverSocket = adapter.listenUsingInsecureRfcommWithServiceRecord("FDroid App Swap", BluetoothConstants.fdroidUuid());
         } catch (IOException e) {
             Log.e(TAG, "Error starting Bluetooth server socket, will stop the server now", e);
-            swap.stop();
-            isRunning = false;
             return;
         }
 
@@ -82,6 +71,11 @@ public class BluetoothServer extends Thread {
                 break;
             }
 
+            if (!adapter.isEnabled()) {
+                Utils.debugLog(TAG, "User disabled Bluetooth from outside, stopping.");
+                break;
+            }
+
             try {
                 BluetoothSocket clientSocket = serverSocket.accept();
                 if (clientSocket != null) {
@@ -97,7 +91,6 @@ public class BluetoothServer extends Thread {
                 Log.e(TAG, "Error receiving client connection over Bluetooth server socket, will continue listening for other clients", e);
             }
         }
-        isRunning = false;
     }
 
     private static class ClientConnection extends Thread {
@@ -151,7 +144,7 @@ public class BluetoothServer extends Thread {
             Response.Builder builder = null;
 
             try {
-                int statusCode = 404;
+                int statusCode = HttpURLConnection.HTTP_NOT_FOUND;
                 int totalSize = -1;
 
                 if (request.getMethod().equals(Request.Methods.HEAD)) {

app/src/full/java/org/fdroid/fdroid/nearby/BonjourManager.java

@@ -0,0 +1,287 @@
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+import android.content.Intent;
+import android.net.wifi.WifiManager;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.os.Process;
+import android.text.TextUtils;
+import android.util.Log;
+
+import org.fdroid.fdroid.FDroidApp;
+import org.fdroid.fdroid.Preferences;
+import org.fdroid.fdroid.Utils;
+import org.fdroid.fdroid.nearby.peers.BonjourPeer;
+
+import java.io.IOException;
+import java.lang.ref.WeakReference;
+import java.net.InetAddress;
+import java.util.HashMap;
+
+import javax.jmdns.JmDNS;
+import javax.jmdns.ServiceEvent;
+import javax.jmdns.ServiceInfo;
+import javax.jmdns.ServiceListener;
+
+import androidx.core.content.ContextCompat;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+/**
+ * Manage {@link JmDNS} in a {@link HandlerThread}.  The start process is in
+ * {@link HandlerThread#onLooperPrepared()} so that it is always started before
+ * any messages get delivered from the queue.
+ */
+public class BonjourManager {
+    private static final String TAG = "BonjourManager";
+
+    public static final String ACTION_FOUND = "BonjourNewPeer";
+    public static final String ACTION_REMOVED = "BonjourPeerRemoved";
+    public static final String EXTRA_BONJOUR_PEER = "extraBonjourPeer";
+
+    public static final String ACTION_STATUS = "BonjourStatus";
+    public static final String EXTRA_STATUS = "BonjourStatusExtra";
+    public static final int STATUS_STARTING = 0;
+    public static final int STATUS_STARTED = 1;
+    public static final int STATUS_STOPPING = 2;
+    public static final int STATUS_STOPPED = 3;
+    public static final int STATUS_VISIBLE = 4;
+    public static final int STATUS_NOT_VISIBLE = 5;
+    public static final int STATUS_ERROR = 0xffff;
+
+    public static final String HTTP_SERVICE_TYPE = "_http._tcp.local.";
+    public static final String HTTPS_SERVICE_TYPE = "_https._tcp.local.";
+
+    private static final int STOP = 5709;
+    private static final int VISIBLE = 4151873;
+    private static final int NOT_VISIBLE = 144151873;
+
+    private static WeakReference<Context> context;
+    private static Handler handler;
+    private static volatile HandlerThread handlerThread;
+    private static ServiceInfo pairService;
+    private static JmDNS jmdns;
+    private static WifiManager.MulticastLock multicastLock;
+
+    public static boolean isAlive() {
+        return handlerThread != null && handlerThread.isAlive();
+    }
+
+    /**
+     * Stops the Bonjour/mDNS, triggering a status broadcast via {@link #ACTION_STATUS}.
+     * {@link #STATUS_STOPPED} can be broadcast multiple times for the same session,
+     * so make sure {@link android.content.BroadcastReceiver}s handle duplicates.
+     */
+    public static void stop(Context context) {
+        BonjourManager.context = new WeakReference<>(context);
+        if (handler == null || handlerThread == null || !handlerThread.isAlive()) {
+            sendBroadcast(STATUS_STOPPED, null);
+            return;
+        }
+        sendBroadcast(STATUS_STOPPING, null);
+        handler.sendEmptyMessage(STOP);
+    }
+
+    public static void setVisible(Context context, boolean visible) {
+        BonjourManager.context = new WeakReference<>(context);
+        if (handler == null || handlerThread == null || !handlerThread.isAlive()) {
+            Log.e(TAG, "handlerThread is stopped, not changing visibility!");
+            return;
+        }
+        if (visible) {
+            handler.sendEmptyMessage(VISIBLE);
+        } else {
+            handler.sendEmptyMessage(NOT_VISIBLE);
+        }
+    }
+
+    /**
+     * Starts the service, triggering a status broadcast via {@link #ACTION_STATUS}.
+     * {@link #STATUS_STARTED} can be broadcast multiple times for the same session,
+     * so make sure {@link android.content.BroadcastReceiver}s handle duplicates.
+     */
+    public static void start(Context context) {
+        start(context,
+                Preferences.get().getLocalRepoName(),
+                Preferences.get().isLocalRepoHttpsEnabled(),
+                httpServiceListener, httpsServiceListener);
+    }
+
+    /**
+     * Testable version, not for regular use.
+     *
+     * @see #start(Context)
+     */
+    static void start(final Context context,
+                      final String localRepoName, final boolean useHttps,
+                      final ServiceListener httpServiceListener, final ServiceListener httpsServiceListener) {
+        BonjourManager.context = new WeakReference<>(context);
+        if (handlerThread != null && handlerThread.isAlive()) {
+            sendBroadcast(STATUS_STARTED, null);
+            return;
+        }
+        sendBroadcast(STATUS_STARTING, null);
+
+        final WifiManager wifiManager = ContextCompat.getSystemService(context, WifiManager.class);
+        handlerThread = new HandlerThread("BonjourManager", Process.THREAD_PRIORITY_LESS_FAVORABLE) {
+            @Override
+            protected void onLooperPrepared() {
+                try {
+                    InetAddress address = InetAddress.getByName(FDroidApp.ipAddressString);
+                    jmdns = JmDNS.create(address);
+                    jmdns.addServiceListener(HTTP_SERVICE_TYPE, httpServiceListener);
+                    jmdns.addServiceListener(HTTPS_SERVICE_TYPE, httpsServiceListener);
+
+                    multicastLock = wifiManager.createMulticastLock(context.getPackageName());
+                    multicastLock.setReferenceCounted(false);
+                    multicastLock.acquire();
+
+                    sendBroadcast(STATUS_STARTED, null);
+                } catch (IOException e) {
+                    if (handler != null) {
+                        handler.removeMessages(VISIBLE);
+                        handler.sendMessageAtFrontOfQueue(handler.obtainMessage(STOP));
+                    }
+                    Log.e(TAG, "Error while registering jmdns service", e);
+                    sendBroadcast(STATUS_ERROR, e.getLocalizedMessage());
+                }
+            }
+        };
+        handlerThread.start();
+        handler = new Handler(handlerThread.getLooper()) {
+
+            @Override
+            public void handleMessage(Message msg) {
+                switch (msg.what) {
+                    case VISIBLE:
+                        handleVisible(localRepoName, useHttps);
+                        break;
+                    case NOT_VISIBLE:
+                        handleNotVisible();
+                        break;
+                    case STOP:
+                        handleStop();
+                        break;
+                }
+            }
+
+            private void handleVisible(String localRepoName, boolean useHttps) {
+                HashMap<String, String> values = new HashMap<>();
+                values.put(BonjourPeer.PATH, "/fdroid/repo");
+                values.put(BonjourPeer.NAME, localRepoName);
+                values.put(BonjourPeer.FINGERPRINT, FDroidApp.repo.fingerprint);
+                String type;
+                if (useHttps) {
+                    values.put(BonjourPeer.TYPE, "fdroidrepos");
+                    type = HTTPS_SERVICE_TYPE;
+                } else {
+                    values.put(BonjourPeer.TYPE, "fdroidrepo");
+                    type = HTTP_SERVICE_TYPE;
+                }
+                ServiceInfo newPairService = ServiceInfo.create(type, localRepoName, FDroidApp.port, 0, 0, values);
+                if (!newPairService.equals(pairService)) try {
+                    if (pairService != null) {
+                        jmdns.unregisterService(pairService);
+                    }
+                    jmdns.registerService(newPairService);
+                    pairService = newPairService;
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    sendBroadcast(STATUS_ERROR, e.getLocalizedMessage());
+                    return;
+                }
+                sendBroadcast(STATUS_VISIBLE, null);
+            }
+
+            private void handleNotVisible() {
+                if (pairService != null) {
+                    jmdns.unregisterService(pairService);
+                    pairService = null;
+                }
+                sendBroadcast(STATUS_NOT_VISIBLE, null);
+            }
+
+            private void handleStop() {
+                if (multicastLock != null) {
+                    multicastLock.release();
+                }
+                if (jmdns != null) {
+                    jmdns.unregisterAllServices();
+                    Utils.closeQuietly(jmdns);
+                    pairService = null;
+                    jmdns = null;
+                }
+                handlerThread.quit();
+                handlerThread = null;
+                sendBroadcast(STATUS_STOPPED, null);
+            }
+
+        };
+    }
+
+    public static void restart(Context context) {
+        restart(context,
+                Preferences.get().getLocalRepoName(),
+                Preferences.get().isLocalRepoHttpsEnabled(),
+                httpServiceListener, httpsServiceListener);
+    }
+
+    /**
+     * Testable version, not for regular use.
+     *
+     * @see #restart(Context)
+     */
+    static void restart(final Context context,
+                        final String localRepoName, final boolean useHttps,
+                        final ServiceListener httpServiceListener, final ServiceListener httpsServiceListener) {
+        stop(context);
+        try {
+            handlerThread.join(10000);
+        } catch (InterruptedException | NullPointerException e) {
+            // ignored
+        }
+        start(context, localRepoName, useHttps, httpServiceListener, httpsServiceListener);
+    }
+
+    private static void sendBroadcast(String action, ServiceInfo serviceInfo) {
+        BonjourPeer bonjourPeer = BonjourPeer.getInstance(serviceInfo);
+        if (bonjourPeer == null) {
+            Utils.debugLog(TAG, "IGNORING: " + serviceInfo);
+            return;
+        }
+        Intent intent = new Intent(action);
+        intent.putExtra(EXTRA_BONJOUR_PEER, bonjourPeer);
+        LocalBroadcastManager.getInstance(context.get()).sendBroadcast(intent);
+    }
+
+    private static void sendBroadcast(int status, String message) {
+
+        Intent intent = new Intent(ACTION_STATUS);
+        intent.putExtra(EXTRA_STATUS, status);
+        if (!TextUtils.isEmpty(message)) {
+            intent.putExtra(Intent.EXTRA_TEXT, message);
+        }
+        LocalBroadcastManager.getInstance(context.get()).sendBroadcast(intent);
+    }
+
+    private static final ServiceListener httpServiceListener = new SwapServiceListener();
+    private static final ServiceListener httpsServiceListener = new SwapServiceListener();
+
+    private static class SwapServiceListener implements ServiceListener {
+        @Override
+        public void serviceAdded(ServiceEvent serviceEvent) {
+            // ignored, we only need resolved info
+        }
+
+        @Override
+        public void serviceRemoved(ServiceEvent serviceEvent) {
+            sendBroadcast(ACTION_REMOVED, serviceEvent.getInfo());
+        }
+
+        @Override
+        public void serviceResolved(ServiceEvent serviceEvent) {
+            sendBroadcast(ACTION_FOUND, serviceEvent.getInfo());
+        }
+    }
+}

app/src/full/java/org/fdroid/fdroid/nearby/LocalHTTPD.java

@@ -0,0 +1,505 @@
+package org.fdroid.fdroid.nearby;
+
+/*
+ * #%L
+ * NanoHttpd-Webserver
+ * %%
+ * Copyright (C) 2012 - 2015 nanohttpd
+ * %%
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the nanohttpd nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software without
+ *    specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
+ * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ * #L%
+ */
+
+import android.content.Context;
+import android.net.Uri;
+
+import org.fdroid.fdroid.BuildConfig;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+import java.lang.ref.WeakReference;
+import java.net.URLEncoder;
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.StringTokenizer;
+import java.util.TimeZone;
+
+import javax.net.ssl.SSLServerSocketFactory;
+
+import fi.iki.elonen.NanoHTTPD;
+import fi.iki.elonen.NanoHTTPD.Response.IStatus;
+
+/**
+ * A HTTP server for serving the files that are being swapped via WiFi, etc.
+ * The only changes were to remove unneeded extras like {@code main()}, the
+ * plugin interface, and custom CORS header manipulation.
+ * <p>
+ * This is mostly just synced from {@code SimpleWebServer.java} from NanoHTTPD.
+ *
+ * @see <a href="https://github.com/NanoHttpd/nanohttpd/blob/nanohttpd-project-2.3.1/webserver/src/main/java/fi/iki/elonen/SimpleWebServer.java">webserver/src/main/java/fi/iki/elonen/SimpleWebServer.java</a>
+ */
+public class LocalHTTPD extends NanoHTTPD {
+    private static final String TAG = "LocalHTTPD";
+
+    /**
+     * Default Index file names.
+     */
+    public static final String[] INDEX_FILE_NAMES = {"index.html"};
+
+    private final WeakReference<Context> context;
+
+    protected List<File> rootDirs;
+
+    // Date format specified by RFC 7231 section 7.1.1.1.
+    private static final DateFormat RFC_1123 = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss 'GMT'", Locale.US);
+
+    static {
+        RFC_1123.setLenient(false);
+        RFC_1123.setTimeZone(TimeZone.getTimeZone("GMT"));
+    }
+
+    /**
+     * Configure and start the webserver.  This also sets the MIME Types only
+     * for files that should be downloadable when a browser is used to display
+     * the swap repo, rather than the F-Droid client.  The other file types
+     * should not be added because it could expose exploits to the browser.
+     */
+    public LocalHTTPD(Context context, String hostname, int port, File webRoot, boolean useHttps) {
+        super(hostname, port);
+        rootDirs = Collections.singletonList(webRoot);
+        this.context = new WeakReference<>(context.getApplicationContext());
+        if (useHttps) {
+            enableHTTPS();
+        }
+        MIME_TYPES = new HashMap<>(); // ignore nanohttpd's list
+        MIME_TYPES.put("apk", "application/vnd.android.package-archive");
+        MIME_TYPES.put("html", "text/html");
+        MIME_TYPES.put("png", "image/png");
+        MIME_TYPES.put("xml", "application/xml");
+    }
+
+    private boolean canServeUri(String uri, File homeDir) {
+        boolean canServeUri;
+        File f = new File(homeDir, uri);
+        canServeUri = f.exists();
+        return canServeUri;
+    }
+
+    /**
+     * URL-encodes everything between "/"-characters. Encodes spaces as '%20'
+     * instead of '+'.
+     */
+    private String encodeUri(String uri) {
+        String newUri = "";
+        StringTokenizer st = new StringTokenizer(uri, "/ ", true);
+        while (st.hasMoreTokens()) {
+            String tok = st.nextToken();
+            if ("/".equals(tok)) {
+                newUri += "/";
+            } else if (" ".equals(tok)) {
+                newUri += "%20";
+            } else {
+                try {
+                    newUri += URLEncoder.encode(tok, "UTF-8");
+                } catch (UnsupportedEncodingException ignored) {
+                }
+            }
+        }
+        return newUri;
+    }
+
+    private String findIndexFileInDirectory(File directory) {
+        for (String fileName : LocalHTTPD.INDEX_FILE_NAMES) {
+            File indexFile = new File(directory, fileName);
+            if (indexFile.isFile()) {
+                return fileName;
+            }
+        }
+        return null;
+    }
+
+    protected Response getForbiddenResponse(String s) {
+        return newFixedLengthResponse(Response.Status.FORBIDDEN, NanoHTTPD.MIME_PLAINTEXT, "FORBIDDEN: " + s);
+    }
+
+    protected Response getInternalErrorResponse(String s) {
+        return newFixedLengthResponse(Response.Status.INTERNAL_ERROR, NanoHTTPD.MIME_PLAINTEXT, "INTERNAL ERROR: " + s);
+    }
+
+    protected Response getNotFoundResponse() {
+        return newFixedLengthResponse(Response.Status.NOT_FOUND, NanoHTTPD.MIME_PLAINTEXT, "Error 404, file not found.");
+    }
+
+    protected String listDirectory(String uri, File f) {
+        String heading = "Directory " + uri;
+        StringBuilder msg =
+                new StringBuilder("<html><head><title>" + heading + "</title><style><!--\n" + "span.dirname { font-weight: bold; }\n" + "span.filesize { font-size: 75%; }\n"
+                        + "// -->\n" + "</style>" + "</head><body><h1>" + heading + "</h1>");
+
+        String up = null;
+        if (uri.length() > 1) {
+            String u = uri.substring(0, uri.length() - 1);
+            int slash = u.lastIndexOf('/');
+            if (slash >= 0 && slash < u.length()) {
+                up = uri.substring(0, slash + 1);
+            }
+        }
+
+        List<String> files = Arrays.asList(f.list(new FilenameFilter() {
+
+            @Override
+            public boolean accept(File dir, String name) {
+                return new File(dir, name).isFile();
+            }
+        }));
+        Collections.sort(files);
+        List<String> directories = Arrays.asList(f.list(new FilenameFilter() {
+
+            @Override
+            public boolean accept(File dir, String name) {
+                return new File(dir, name).isDirectory();
+            }
+        }));
+        Collections.sort(directories);
+        if (up != null || directories.size() + files.size() > 0) {
+            msg.append("<ul>");
+            if (up != null || directories.size() > 0) {
+                msg.append("<section class=\"directories\">");
+                if (up != null) {
+                    msg.append("<li><a rel=\"directory\" href=\"").append(up).append("\"><span class=\"dirname\">..</span></a></li>");
+                }
+                for (String directory : directories) {
+                    String dir = directory + "/";
+                    msg.append("<li><a rel=\"directory\" href=\"").append(encodeUri(uri + dir)).append("\"><span class=\"dirname\">").append(dir).append("</span></a></li>");
+                }
+                msg.append("</section>");
+            }
+            if (files.size() > 0) {
+                msg.append("<section class=\"files\">");
+                for (String file : files) {
+                    msg.append("<li><a href=\"").append(encodeUri(uri + file)).append("\"><span class=\"filename\">").append(file).append("</span></a>");
+                    File curFile = new File(f, file);
+                    long len = curFile.length();
+                    msg.append("&nbsp;<span class=\"filesize\">(");
+                    if (len < 1024) {
+                        msg.append(len).append(" bytes");
+                    } else if (len < 1024 * 1024) {
+                        msg.append(len / 1024).append(".").append(len % 1024 / 10 % 100).append(" KB");
+                    } else {
+                        msg.append(len / (1024 * 1024)).append(".").append(len % (1024 * 1024) / 10000 % 100).append(" MB");
+                    }
+                    msg.append(")</span></li>");
+                }
+                msg.append("</section>");
+            }
+            msg.append("</ul>");
+        }
+        msg.append("</body></html>");
+        return msg.toString();
+    }
+
+    /**
+     * {@link Response#setKeepAlive(boolean)} alone does not seem to stop
+     * setting the {@code Connection} header to {@code keep-alive}, so also
+     * just directly set that header.
+     */
+    public static Response addResponseHeaders(Response response) {
+        response.setKeepAlive(false);
+        response.setGzipEncoding(false);
+        response.addHeader("Connection", "close");
+        response.addHeader("Content-Security-Policy",
+                "default-src 'none'; img-src 'self'; style-src 'self' 'unsafe-inline';");
+        return response;
+    }
+
+    public static Response newFixedLengthResponse(String msg) {
+        return addResponseHeaders(NanoHTTPD.newFixedLengthResponse(msg));
+    }
+
+    public static Response newFixedLengthResponse(Response.IStatus status, String mimeType,
+                                                  InputStream data, long totalBytes) {
+        return addResponseHeaders(NanoHTTPD.newFixedLengthResponse(status, mimeType, data, totalBytes));
+    }
+
+    public static Response newFixedLengthResponse(IStatus status, String mimeType, String message) {
+        Response response = NanoHTTPD.newFixedLengthResponse(status, mimeType, message);
+        addResponseHeaders(response);
+        response.addHeader("Accept-Ranges", "bytes");
+        return response;
+    }
+
+    private Response respond(Map<String, String> headers, IHTTPSession session, String uri) {
+        return defaultRespond(headers, session, uri);
+    }
+
+    private Response defaultRespond(Map<String, String> headers, IHTTPSession session, String uri) {
+        // Remove URL arguments
+        uri = uri.trim().replace(File.separatorChar, '/');
+        if (uri.indexOf('?') >= 0) {
+            uri = uri.substring(0, uri.indexOf('?'));
+        }
+
+        // Prohibit getting out of current directory
+        if (uri.contains("../")) {
+            return getForbiddenResponse("Won't serve ../ for security reasons.");
+        }
+
+        boolean canServeUri = false;
+        File homeDir = null;
+        for (int i = 0; !canServeUri && i < this.rootDirs.size(); i++) {
+            homeDir = this.rootDirs.get(i);
+            canServeUri = canServeUri(uri, homeDir);
+        }
+        if (!canServeUri) {
+            return getNotFoundResponse();
+        }
+
+        // Browsers get confused without '/' after the directory, send a
+        // redirect.
+        File f = new File(homeDir, uri);
+        if (f.isDirectory() && !uri.endsWith("/")) {
+            uri += "/";
+            Response res =
+                    newFixedLengthResponse(Response.Status.REDIRECT, NanoHTTPD.MIME_HTML, "<html><body>Redirected: <a href=\"" + uri + "\">" + uri + "</a></body></html>");
+            res.addHeader("Location", uri);
+            return res;
+        }
+
+        if (f.isDirectory()) {
+            // First look for index files (index.html, index.htm, etc) and if
+            // none found, list the directory if readable.
+            String indexFile = findIndexFileInDirectory(f);
+            if (indexFile == null) {
+                if (f.canRead()) {
+                    // No index file, list the directory if it is readable
+                    return newFixedLengthResponse(Response.Status.OK, NanoHTTPD.MIME_HTML, listDirectory(uri, f));
+                } else {
+                    return getForbiddenResponse("No directory listing.");
+                }
+            } else {
+                return respond(headers, session, uri + indexFile);
+            }
+        }
+        String mimeTypeForFile = getMimeTypeForFile(uri);
+        Response response = serveFile(uri, headers, f, mimeTypeForFile);
+        return response != null ? response : getNotFoundResponse();
+    }
+
+    @Override
+    public Response serve(IHTTPSession session) {
+        Map<String, String> header = session.getHeaders();
+        Map<String, String> parms = session.getParms();
+        String uri = session.getUri();
+
+        if (BuildConfig.DEBUG) {
+            System.out.println(session.getMethod() + " '" + uri + "' ");
+
+            Iterator<String> e = header.keySet().iterator();
+            while (e.hasNext()) {
+                String value = e.next();
+                System.out.println("  HDR: '" + value + "' = '" + header.get(value) + "'");
+            }
+            e = parms.keySet().iterator();
+            while (e.hasNext()) {
+                String value = e.next();
+                System.out.println("  PRM: '" + value + "' = '" + parms.get(value) + "'");
+            }
+        }
+
+        if (session.getMethod() == Method.POST) {
+            try {
+                session.parseBody(new HashMap<String, String>());
+            } catch (IOException e) {
+                return newFixedLengthResponse(Response.Status.INTERNAL_ERROR, MIME_PLAINTEXT,
+                        "Internal server error, check logcat on server for details.");
+            } catch (ResponseException re) {
+                return newFixedLengthResponse(re.getStatus(), MIME_PLAINTEXT, re.getMessage());
+            }
+
+            return handlePost(session);
+        }
+
+        for (File homeDir : this.rootDirs) {
+            // Make sure we won't die of an exception later
+            if (!homeDir.isDirectory()) {
+                return getInternalErrorResponse("given path is not a directory (" + homeDir + ").");
+            }
+        }
+        return respond(Collections.unmodifiableMap(header), session, uri);
+    }
+
+    private Response handlePost(IHTTPSession session) {
+        Uri uri = Uri.parse(session.getUri());
+        switch (uri.getPath()) {
+            case "/request-swap":
+                if (!session.getParms().containsKey("repo")) {
+                    return newFixedLengthResponse(Response.Status.BAD_REQUEST, MIME_PLAINTEXT,
+                            "Requires 'repo' parameter to be posted.");
+                }
+                SwapWorkflowActivity.requestSwap(context.get(), session.getParms().get("repo"));
+                return newFixedLengthResponse(Response.Status.OK, MIME_PLAINTEXT, "Swap request received.");
+        }
+        return newFixedLengthResponse("");
+    }
+
+    /**
+     * Serves file from homeDir and its' subdirectories (only). Uses only URI,
+     * ignores all headers and HTTP parameters.
+     */
+    Response serveFile(String uri, Map<String, String> header, File file, String mime) {
+        Response res;
+        try {
+            // Calculate etag
+            String etag = Integer.toHexString((file.getAbsolutePath() + file.lastModified() + "" + file.length()).hashCode());
+
+            // Support (simple) skipping:
+            long startFrom = 0;
+            long endAt = -1;
+            String range = header.get("range");
+            if (range != null) {
+                if (range.startsWith("bytes=")) {
+                    range = range.substring("bytes=".length());
+                    int minus = range.indexOf('-');
+                    try {
+                        if (minus > 0) {
+                            startFrom = Long.parseLong(range.substring(0, minus));
+                            endAt = Long.parseLong(range.substring(minus + 1));
+                        }
+                    } catch (NumberFormatException ignored) {
+                    }
+                }
+            }
+
+            // get if-range header. If present, it must match etag or else we
+            // should ignore the range request
+            String ifRange = header.get("if-range");
+            boolean headerIfRangeMissingOrMatching = (ifRange == null || etag.equals(ifRange));
+
+            String ifNoneMatch = header.get("if-none-match");
+            boolean headerIfNoneMatchPresentAndMatching = ifNoneMatch != null && ("*".equals(ifNoneMatch) || ifNoneMatch.equals(etag));
+
+            // Change return code and add Content-Range header when skipping is
+            // requested
+            long fileLen = file.length();
+
+            if (headerIfRangeMissingOrMatching && range != null && startFrom >= 0 && startFrom < fileLen) {
+                // range request that matches current etag
+                // and the startFrom of the range is satisfiable
+                if (headerIfNoneMatchPresentAndMatching) {
+                    // range request that matches current etag
+                    // and the startFrom of the range is satisfiable
+                    // would return range from file
+                    // respond with not-modified
+                    res = newFixedLengthResponse(Response.Status.NOT_MODIFIED, mime, "");
+                    res.addHeader("ETag", etag);
+                } else {
+                    if (endAt < 0) {
+                        endAt = fileLen - 1;
+                    }
+                    long newLen = endAt - startFrom + 1;
+                    if (newLen < 0) {
+                        newLen = 0;
+                    }
+
+                    FileInputStream fis = new FileInputStream(file);
+                    fis.skip(startFrom);
+
+                    res = newFixedLengthResponse(Response.Status.PARTIAL_CONTENT, mime, fis, newLen);
+                    res.addHeader("Accept-Ranges", "bytes");
+                    res.addHeader("Content-Length", "" + newLen);
+                    res.addHeader("Content-Range", "bytes " + startFrom + "-" + endAt + "/" + fileLen);
+                    res.addHeader("ETag", etag);
+                    res.addHeader("Last-Modified", RFC_1123.format(new Date(file.lastModified())));
+                }
+            } else {
+
+                if (headerIfRangeMissingOrMatching && range != null && startFrom >= fileLen) {
+                    // return the size of the file
+                    // 4xx responses are not trumped by if-none-match
+                    res = newFixedLengthResponse(Response.Status.RANGE_NOT_SATISFIABLE, NanoHTTPD.MIME_PLAINTEXT, "");
+                    res.addHeader("Content-Range", "bytes */" + fileLen);
+                    res.addHeader("ETag", etag);
+                } else if (range == null && headerIfNoneMatchPresentAndMatching) {
+                    // full-file-fetch request
+                    // would return entire file
+                    // respond with not-modified
+                    res = newFixedLengthResponse(Response.Status.NOT_MODIFIED, mime, "");
+                    res.addHeader("ETag", etag);
+                } else if (!headerIfRangeMissingOrMatching && headerIfNoneMatchPresentAndMatching) {
+                    // range request that doesn't match current etag
+                    // would return entire (different) file
+                    // respond with not-modified
+
+                    res = newFixedLengthResponse(Response.Status.NOT_MODIFIED, mime, "");
+                    res.addHeader("ETag", etag);
+                } else {
+                    // supply the file
+                    res = newFixedFileResponse(file, mime);
+                    res.addHeader("Content-Length", "" + fileLen);
+                    res.addHeader("ETag", etag);
+                    res.addHeader("Last-Modified", RFC_1123.format(new Date(file.lastModified())));
+                }
+            }
+        } catch (IOException ioe) {
+            res = getForbiddenResponse("Reading file failed.");
+        }
+
+        return addResponseHeaders(res);
+    }
+
+    private Response newFixedFileResponse(File file, String mime) throws FileNotFoundException {
+        Response res;
+        res = newFixedLengthResponse(Response.Status.OK, mime, new FileInputStream(file), (int) file.length());
+        addResponseHeaders(res);
+        res.addHeader("Accept-Ranges", "bytes");
+        return res;
+    }
+
+    private void enableHTTPS() {
+        try {
+            LocalRepoKeyStore localRepoKeyStore = LocalRepoKeyStore.get(context.get());
+            SSLServerSocketFactory factory = NanoHTTPD.makeSSLSocketFactory(
+                    localRepoKeyStore.getKeyStore(),
+                    localRepoKeyStore.getKeyManagers());
+            makeSecure(factory, null);
+        } catch (LocalRepoKeyStore.InitException | IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

app/src/full/java/org/fdroid/fdroid/nearby/LocalHTTPDManager.java

@@ -0,0 +1,129 @@
+package org.fdroid.fdroid.nearby;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Message;
+import android.os.Process;
+import android.util.Log;
+
+import org.fdroid.fdroid.FDroidApp;
+import org.fdroid.fdroid.Preferences;
+
+import java.io.IOException;
+import java.net.BindException;
+import java.util.Random;
+
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+/**
+ * Manage {@link LocalHTTPD} in a {@link HandlerThread};
+ */
+public class LocalHTTPDManager {
+    private static final String TAG = "LocalHTTPDManager";
+
+    public static final String ACTION_STARTED = "LocalHTTPDStarted";
+    public static final String ACTION_STOPPED = "LocalHTTPDStopped";
+    public static final String ACTION_ERROR = "LocalHTTPDError";
+
+    private static final int STOP = 5709;
+
+    private static Handler handler;
+    private static volatile HandlerThread handlerThread;
+    private static LocalHTTPD localHttpd;
+
+    public static void start(Context context) {
+        start(context, Preferences.get().isLocalRepoHttpsEnabled());
+    }
+
+    /**
+     * Testable version, not for regular use.
+     *
+     * @see #start(Context)
+     */
+    static void start(final Context context, final boolean useHttps) {
+        if (handlerThread != null && handlerThread.isAlive()) {
+            Log.w(TAG, "handlerThread is already running, doing nothing!");
+            return;
+        }
+
+        handlerThread = new HandlerThread("LocalHTTPD", Process.THREAD_PRIORITY_LESS_FAVORABLE) {
+            @Override
+            protected void onLooperPrepared() {
+                localHttpd = new LocalHTTPD(
+                        context,
+                        FDroidApp.ipAddressString,
+                        FDroidApp.port,
+                        context.getFilesDir(),
+                        useHttps);
+                try {
+                    localHttpd.start();
+                    Intent intent = new Intent(ACTION_STARTED);
+                    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
+                } catch (BindException e) {
+                    int prev = FDroidApp.port;
+                    FDroidApp.port = FDroidApp.port + new Random().nextInt(1111);
+                    WifiStateChangeService.start(context, null);
+                    Intent intent = new Intent(ACTION_ERROR);
+                    intent.putExtra(Intent.EXTRA_TEXT,
+                            "port " + prev + " occupied, trying on " + FDroidApp.port + ": ("
+                                    + e.getLocalizedMessage() + ")");
+                    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                    Intent intent = new Intent(ACTION_ERROR);
+                    intent.putExtra(Intent.EXTRA_TEXT, e.getLocalizedMessage());
+                    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
+                }
+            }
+        };
+        handlerThread.start();
+        handler = new Handler(handlerThread.getLooper()) {
+            @Override
+            public void handleMessage(Message msg) {
+                localHttpd.stop();
+                handlerThread.quit();
+                handlerThread = null;
+            }
+        };
+    }
+
+    public static void stop(Context context) {
+        if (handler == null || handlerThread == null || !handlerThread.isAlive()) {
+            Log.w(TAG, "handlerThread is already stopped, doing nothing!");
+            handlerThread = null;
+            return;
+        }
+        handler.sendEmptyMessage(STOP);
+        Intent stoppedIntent = new Intent(ACTION_STOPPED);
+        LocalBroadcastManager.getInstance(context).sendBroadcast(stoppedIntent);
+    }
+
+    /**
+     * Run {@link #stop(Context)}, wait for it to actually stop, then run
+     * {@link #start(Context)}.
+     */
+    public static void restart(Context context) {
+        restart(context, Preferences.get().isLocalRepoHttpsEnabled());
+    }
+
+    /**
+     * Testable version, not for regular use.
+     *
+     * @see #restart(Context)
+     */
+    static void restart(Context context, boolean useHttps) {
+        stop(context);
+        try {
+            handlerThread.join(10000);
+        } catch (InterruptedException | NullPointerException e) {
+            // ignored
+        }
+        start(context, useHttps);
+    }
+
+    public static boolean isAlive() {
+        return handlerThread != null && handlerThread.isAlive();
+    }
+}

app/src/full/java/org/fdroid/fdroid/nearby/LocalRepoKeyStore.java

@@ -1,23 +1,23 @@
-package org.fdroid.fdroid.localrepo;
+package org.fdroid.fdroid.nearby;
 
 import android.content.Context;
 import android.util.Log;
 
+import org.bouncycastle.asn1.ASN1Sequence;
+import org.bouncycastle.asn1.x500.X500Name;
+import org.bouncycastle.asn1.x509.GeneralName;
+import org.bouncycastle.asn1.x509.GeneralNames;
+import org.bouncycastle.asn1.x509.SubjectPublicKeyInfo;
+import org.bouncycastle.asn1.x509.Time;
+import org.bouncycastle.asn1.x509.X509Extension;
+import org.bouncycastle.cert.X509CertificateHolder;
+import org.bouncycastle.cert.X509v3CertificateBuilder;
+import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter;
+import org.bouncycastle.operator.ContentSigner;
+import org.bouncycastle.operator.OperatorCreationException;
+import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder;
 import org.fdroid.fdroid.FDroidApp;
 import org.fdroid.fdroid.Utils;
-import org.spongycastle.asn1.ASN1Sequence;
-import org.spongycastle.asn1.x500.X500Name;
-import org.spongycastle.asn1.x509.GeneralName;
-import org.spongycastle.asn1.x509.GeneralNames;
-import org.spongycastle.asn1.x509.SubjectPublicKeyInfo;
-import org.spongycastle.asn1.x509.Time;
-import org.spongycastle.asn1.x509.X509Extension;
-import org.spongycastle.cert.X509CertificateHolder;
-import org.spongycastle.cert.X509v3CertificateBuilder;
-import org.spongycastle.cert.jcajce.JcaX509CertificateConverter;
-import org.spongycastle.operator.ContentSigner;
-import org.spongycastle.operator.OperatorCreationException;
-import org.spongycastle.operator.jcajce.JcaContentSignerBuilder;
 
 import java.io.File;
 import java.io.FileInputStream;
@@ -54,6 +54,7 @@ import kellinwood.security.zipsigner.ZipSigner;
 
 // TODO Address exception handling in a uniform way throughout
 
+@SuppressWarnings("LineLength")
 public final class LocalRepoKeyStore {
 
     private static final String TAG = "LocalRepoKeyStore";
@@ -161,8 +162,8 @@ public final class LocalRepoKeyStore {
             KeyManager defaultKeyManager = keyManagerFactory.getKeyManagers()[0];
             KeyManager wrappedKeyManager = new KerplappKeyManager(
                     (X509KeyManager) defaultKeyManager);
-            keyManagers = new KeyManager[] {
-                wrappedKeyManager,
+            keyManagers = new KeyManager[]{
+                    wrappedKeyManager,
             };
         } catch (UnrecoverableKeyException | KeyStoreException | NoSuchAlgorithmException | CertificateException | OperatorCreationException | IOException e) {
             Log.e(TAG, "Error loading keystore", e);
@@ -253,7 +254,7 @@ public final class LocalRepoKeyStore {
     private void addToStore(String alias, KeyPair kp, Certificate cert) throws KeyStoreException,
             NoSuchAlgorithmException, CertificateException, IOException, UnrecoverableKeyException {
         Certificate[] chain = {
-            cert,
+                cert,
         };
         keyStore.setKeyEntry(alias, kp.getPrivate(),
                 "".toCharArray(), chain);
@@ -271,8 +272,8 @@ public final class LocalRepoKeyStore {
         keyManagerFactory.init(keyStore, "".toCharArray());
         KeyManager defaultKeyManager = keyManagerFactory.getKeyManagers()[0];
         KeyManager wrappedKeyManager = new KerplappKeyManager((X509KeyManager) defaultKeyManager);
-        keyManagers = new KeyManager[] {
-            wrappedKeyManager,
+        keyManagers = new KeyManager[]{
+                wrappedKeyManager,
         };
     }