Updates for the new i2p android 0.9.35 release.

Use the parent fragment's Context, which should be more reliable than the one
from the WebView.

.mtn-ignore

@@ -0,0 +1,52 @@
+# Just to try and prevent some noob disasters.
+# Use mtn add --no-respect-ignore foo.jar to ignore this ignore list
+_jsp\.java$
+\.bz2$
+\.class$
+\.diff$
+\.exe$
+\.fba$
+\.gz$
+\.jar$
+\.out$
+\.patch$
+\.sig$
+\.sud$
+\.su2$
+\.tar$
+\.war$
+\.zip$
+^\.
+^build/
+^pkg-temp/
+~$
+/build/
+/classes/
+
+# Android-specific ignores
+^lib/client/libs
+^routerjars/libs
+local.properties
+signing.properties
+
+#IntelliJ IDEA
+^.idea
+.*.iml
+.*.ipr
+.*.iws
+
+#Gradle
+build
+
+# I2P-specific ignores
+^app/src/main/res/drawable/i2plogo.png
+^app/src/main/res/raw/blocklist_txt
+^app/src/main/res/raw/hosts_txt
+^app/src/main/res/raw/.*_ht
+^app/src/main/res/raw/license_
+^app/src/main/res/raw/certificates_zip
+^app/src/main/assets/themes/console/images
+^app/src/main/assets/themes/console/light/console.css
+^app/src/main/assets/themes/console/light/images/header.png
+^scripts/build.number
+^scripts/version.properties

.tx/config

@@ -0,0 +1,18 @@
+[main]
+host = https://www.transifex.com
+lang_map = he: iw, id: in, pt_BR: pt-rBR, ru_RU: ru, sv_SE: sv, tr_TR: tr, uk_UA: uk, yi: ji, zh_CN: zh, zh_TW: zh-rTW
+
+[I2P.android]
+file_filter = app/src/main/res/values-<lang>/strings.xml
+minimum_perc = 50
+source_file = app/src/main/res/values/strings.xml
+source_lang = en
+type = ANDROID
+
+[I2P.android_lib_helper]
+file_filter = lib/helper/src/main/res/values-<lang>/strings.xml
+minimum_perc = 50
+source_file = lib/helper/src/main/res/values/strings.xml
+source_lang = en
+type = ANDROID
+

CHANGELOG

@@ -0,0 +1,107 @@
+0.9.33 / 2018-02-18
+ * Translation updates
+
+0.9.32 / 2017-11-28
+ * Fixed "Application Not Responding" error when restarting all tunnels
+ * Fixed crashes when:
+   * opening the console menu
+   * starting the router
+   * starting the router for the first time
+   * viewing tunnels
+   * viewing the addressbook
+   * opening the addressbook menu
+   * configuring addressbook subscriptions
+   * using a configuration wizard
+   * loading a B64 Destination from file
+   * viewing tunnel settings
+   * saving tunnel settings
+   * installing a tunnel's recommended app without a market app
+   * installing a browser without a market app
+   * rotating the screen while using the built-in browser
+ * Added a "sync" icon to more clearly indicate tunnel "starting" status
+ * Updated Firefox browser config instructions for Firefox Quantum
+ * Translation updates
+
+0.9.31 / 2017-08-19
+ * Fixed various crashes in the Tunnels UI
+ * Updated Firefox browser config instructions
+ * Minor bug fixes
+ * Dependency and translation updates
+
+0.9.30 / 2017-05-20
+ * Fixed crashes when creating or deleting tunnels, or adding names to the
+   private addressbook
+ * Minor bug fixes
+ * Dependency and translation updates
+
+0.9.29 / 2017-03-27
+ * Dependency and translation updates
+
+0.9.28 / 2017-01-02
+ * Bug fixes and translation updates
+
+0.9.27 / 2016-11-20 / 64ff68efe98c345acb6ba1d0432fa49d1d650358
+ * Removed kytv's IRC server from default tunnel list
+ * Translation updates
+
+0.9.26 / 2016-06-13 / b003272c8b504bb0d904edca2e95359a57c9a52c
+ * Fixed "I2CP already listening" bug
+ * Fixed crash when adding tunnel to empty list
+ * Translation updates
+
+0.9.25 / 2016-04-17 / 46d45a878a2b73394b26ca27dbe6c696dedcf1c3
+ * Fixed a bug on Samsung Android 4.2 devices
+ * Dependency improvements
+ * Translation updates
+
+0.9.22 / 2015-10-10 / 0f73ef90b81e2cf3d55f0ea2b0a16e1f10da40ad
+ * Updated browser config guide
+ * Bug fixes and translation updates
+
+0.9.20 / 2015-06-18 / 5fdaabeb5fa955caac90f1390adbdeaeae42fdf1
+ * Simplified the main interface
+ * Language can be configured
+ * Tunnels can now be edited
+ * Material design improvements
+ * Better support for tablets
+ * Improved graph rendering
+ * Bug fixes and translation updates
+
+0.9.19.1 / 2015-04-15 / ed86e7e85161dbe3f15932fd4d195c551f8e2c71
+ * Fixed crash when opening advanced settings
+
+0.9.19 / 2015-04-13 / 3cfb748946a5876dc06d5f81d811b142a88846f7
+ * Made internal state handling more stable
+ * Added graceful shutdown support
+ * Updated libjbigi to use GMP 6.0.0
+ * New libjbigi binary for armeabi-v7a to speed up newer devices
+ * Improved logging
+ * Bug fixes and translation updates
+
+0.9.18 / 2015-03-04 / c2f4831a1617f4ce716a08640446fdd992c751ff
+ * I2P can start automatically when phone boots (configure in Setting)
+ * Updated browser configuration guides for Orfox and Firefox
+ * Tunnels for postman's mail server added to defaults (for new installs)
+ * Settings options for configuring UDP and TCP ports
+ * Bug fixes and translation updates
+
+0.9.17.1 / 2014-12-14 / cd8bb5e3ac4238efac12179c78c4fa517fcaabec
+ * Fixed crashes in addressbook and netDb status page
+ * Fixed crash when opening an IRC client tunnel
+ * Updated translations
+
+0.9.17 / 2014-12-01 / bcf947f433876f643e0f6dff81aac88848b797d3
+ * Migrated to the new Material design from Android Lollipop
+ * Added a browser configuration guide
+ * Improved the help screen
+ * Upgraded the I2P router to 0.9.17
+ * Various bug fixes and translation updates
+
+0.9.15.1 / 2014-10-16 / 9cc4e80134cf9becb3838ed3cc78e0bed1363165
+ * Fixed a configuration bug
+
+0.9.15 / 2014-10-16 / 9b51f78b791c28a580d57f1a5019c94493de6231
+ * Upgraded the I2P router to 0.9.15
+ * Added a help screen with some basic information
+ * Logs can now be copied to the clipboard
+ * Various user interface improvements and fixes

INSTALL-headless.txt

@@ -1,44 +0,0 @@
-Headless I2P installation instructions
-
-1) java -jar i2pinstall.exe -console       (you've already done this)
-
-This will run the installer in text mode, including running the postinstall.sh
-script. After that, you may run 'sh i2prouter start'
-which will start the router and attempt to launch a browser.
-
-If you do not have an X server running, the browser launch will probably fail, and
-you may use:
-  lynx http://localhost:7657/index.jsp
-to configure the router.
-
-If you're having trouble, swing by http://forum.i2p2.de/, check the
-website at http://www.i2p2.de/, or get on irc://irc.freenode.net/#i2p
-
-I2P will create and store files and configuration data in the user directory
-~/.i2p/ on Linux and %APPDATA%\I2P\ on Windows. This directory is created
-when I2P is run for the first time. It also creates files in the system
-temporary directory specified by the Java Virtual Machine.
-To change the location of these directories, or to configure I2P to
-put all files in this directory (the so-called "portable" configuration),
-edit the files i2prouter (Linux) and wrapper.config (Linux and Windows)
-where there are comments labeled "PORTABLE". Do this before you
-run I2P for the first time.
-
-To run I2P explicitly:
-   (*nix): sh i2prouter start
-   (win*): I2P.exe
-
-To stop the router (gracefully):
-   lynx http://localhost:7657/configservice.jsp ("Shutdown gracefully")
-
-To stop the router (immediately):
-   sh i2prouter stop
-
-To uninstall I2P:
-   rm -rf $i2pInstallDir
-
-Supported JVMs:
-  Windows: Latest available from http://java.sun.com/ (1.5+ supported)
-  Linux:   Latest available from http://java.sun.com/ (1.5+ supported)
-  FreeBSD: Sun 1.5-compatible (NIO required)
-  various: http://www.kaffe.org/ Sun 1.5-compatible (NIO required)

INSTALL.txt

@@ -1,32 +0,0 @@
-I2P source installation instructions
-
-Prerequisites to build from source:
-	Java SDK (preferably Sun) 1.5.0 or higher (1.6 recommended)
-	Apache Ant 1.7.0 or higher
-	Optional, For multilanguage support: The xgettext, msgfmt, and msgmerge tools installed
-	from the GNU gettext package http://www.gnu.org/software/gettext/
-
-To build and install I2P from source, you must first build
-and package up the appropriate installer by running:
-
-  ant pkg
-
-
-This will produce a few key files:
-* install.jar:    the GUI and console installer
-* i2pinstall.exe: the GUI and console installer wrapped for cross-platform execution
-* i2pupdate.zip:  the update package
-
-From there, you can run the headless (console mode) installer:
-  java -jar i2pinstall.exe -console
-
-Or run the GUI installer:
-  java -jar i2pinstall.exe
-
-Or move the update file into an existing installation directory and restart.
-
-Supported JVMs:
-  Windows: Latest available from http://java.sun.com/ (1.5+ supported)
-  Linux:   Latest available from http://java.sun.com/ (1.5+ supported)
-  FreeBSD: Sun 1.5-compatible (NIO required)
-  various: http://www.kaffe.org/ Sun 1.5-compatible (NIO required)

LICENSE.txt

@@ -25,209 +25,26 @@ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
 
+===================================
 
-LICENSES
---------
+License for the Android App:
 
-Core:
-Public domain except as listed below:
+   Copyright 2011 The I2P Project
 
-   ElGamal and DSA code:
-   Copyright (c) 2003, TheCrypto
-   See licenses/LICENSE-ElGamalDSA.txt
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use these files except in compliance with the License.
+   You may obtain a copy of the License at
 
-   SHA256 and HMAC-SHA256:
-   Copyright (c) 2000 - 2004 The Legion Of The Bouncy Castle
-   See licenses/LICENSE-SHA256.txt
+       http://www.apache.org/licenses/LICENSE-2.0
 
-   AES code:
-   Under the Cryptix (MIT) license, written by the Cryptix team
-   (That's what our website says but all our AES code looks like it is public domain)
-
-   Crypto filters:
-   From the xlattice app - http://xlattice.sourceforge.net/
-   See licenses/LICENSE-BSD.txt
-
-   SNTP code:
-   Copyright (c) 2004, Adam Buckley
-   See licenses/LICENSE-SNTP.txt
-
-   PRNG:
-   Copyright (C) 2001, 2002, Free Software Foundation, Inc.
-   See licenses/LICENSE-LGPLv2.1.txt
-
-   GMP 4.1.3:
-   Copyright 1991, 1996, 1999, 2000 Free Software Foundation, Inc.
-   See licenses/LICENSE-LGPLv2.1.txt
-
-   HashCash code:
-   Copyright 2006 Gregory Rubin grrubin@gmail.com
-   See licenses/LICENSE-HashCash.txt
+   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.
 
 
-
-Router:
-Public domain except as listed below:
-   UPnP.java:
-   From freenet
-   See licenses/LICENSE-GPLv2.txt
-
-   UPnP subsystem 1.7:
-   Copyright (C) 2003-2006 Satoshi Konno
-   See licenses/LICENSE-UPnP.txt
-
-   GeoIP data free to use, courtesy http://ip-to-country.webhosting.info/
+===================================
 
 
-Installer:
-   Launch4j 3.0.1:
-   Copyright (c) 2004, 2008 Grzegorz Kowal
-   See licenses/LICENSE-Launch4j.txt (in binary packages)
-   See installer/lib/launch4j/LICENSE.txt (in source packages)
-   The following projects are used by Launch4j...
-	MinGW binutils (http://www.mingw.org/)
-
-	Commons BeanUtils (http://jakarta.apache.org/commons/beanutils/)
-
- 	Commons Logging (http://jakarta.apache.org/commons/logging/)
-        See licenses/LICENSE-Apache1.1.txt
-        See licenses/NOTICE-Commons-Logging.txt
-
-	XStream (http://xstream.codehaus.org/)
-        Copyright (c) 2003-2004, Joe Walnes
-        See licenses/LICENSE-XStream.txt
-
-	JGoodies Forms (http://www.jgoodies.com/freeware/forms/)
-        Copyright (c) 2002-2004 JGoodies Karsten Lentzsch. All rights reserved.
-        See licenses/LICENSE-JGoodies-Forms.txt
-
-	JGoodies Looks (http://www.jgoodies.com/freeware/looks/)
-        Copyright (c) 2003 JGoodies Karsten Lentzsch. All rights reserved.
-        See licenses/LICENSE-JGoodies-Looks.txt
-
-	Foxtrot (http://foxtrot.sourceforge.net/)
-        Copyright (c) 2002, Simone Bordet & Marco Cravero. All rights reserved.
-        See licenses/LICENSE-Foxtrot.txt
-
-	Nuvola Icon Theme (http://www.icon-king.com)
-        See licenses/LICENSE-LGPLv2.1.txt
-
-	Forms were created using Abeille Forms Designer (https://abeille.dev.java.net/)
-
-   Izpack 4.3.0:
-   Copyright (c) 2001-2008 Julien Ponge
-   See licenses/LICENSE-Apache2.0.txt
-
-
-
-Wrapper 3.1.1:
-   Copyright (c) 1999, 2004 Tanuki Software
-   See licenses/LICENSE-Wrapper.txt
-
-
-
-Applications:
-
-   Addressbook:
-   Copyright (c) 2004 Ragnarok
-   See licenses/LICENSE-Addressbook.txt
-
-   BOB:
-   Copyright (C) sponge
-   DWTFYWTPL
-
-   I2PSnark:
-   Copyright (C) 2003 Mark J. Wielaard
-   See licenses/LICENSE-GPLv2.txt
-
-   I2PTunnel:
-   (c) 2003 - 2004 mihi
-   GPLv2 with exception.
-   See licenses/LICENSE-I2PTunnel.txt
-   See licenses/LICENSE-GPLv2.txt
-
-   I2PTunnel SOCKS Proxy:
-   Copyright (c) 2004 by human
-   GPLv2 with exception.
-   See licenses/LICENSE-I2PTunnel.txt
-   See licenses/LICENSE-GPLv2.txt
-
-   I2PTunnel UDP and Streamr:
-   By welterde.
-   See licenses/LICENSE-GPLv2.txt
-
-   Jetty 5.1.12:
-   Copyright 2000-2004 Mort Bay Consulting Pty. Ltd.
-   See licenses/LICENSE-Apache1.1.txt
-   See licenses/LICENSE-Apache2.0.txt
-   See licenses/NOTICE-Commons-Logging.txt
-
-   JRobin 1.4.0:
-   See licenses/LICENSE-LGPLv2.1.txt
-
-   Ministreaming Lib:
-   By mihi.
-   See licenses/LICENSE-BSD.txt
-
-   Proxyscript:
-   By Cervantes.
-   Public domain.
-
-   Router console:
-   Public domain.
-       Flag icons: public domain, courtesy mjames@gmail.com http://www.famfamfam.com/
-
-       GeoIP Data:
-       Copyright (c) 2003 Direct Information Pvt. Ltd. All Rights Reserved.
-       See licenses/LICENSE-GeoIP.txt
-
-   SAM:
-   Public domain.
-
-   Streaming Lib:
-   Public domain.
-
-   SusiDNS:
-   Copyright (C) 2005 <susi23@mail.i2p>
-   See licenses/LICENSE-GPLv2.txt
-
-   SusiMail:
-   Copyright (C) 2004-2005  <susi23@mail.i2p>
-   See licenses/LICENSE-GPLv2.txt
-
-   Systray:
-   Public domain.
-      Bundles systray4j code:
-      See licenses/LICENSE-GPLv2.txt
-
-
-
-Other Applications and Libraries
---------------------------------
-The following applications and libraries are not used or bundled in
-binary packages, therefore the licenses are not included in binary
-distributions. See the source package for the additional license information.
-
-   Admin Manager:
-   Public domain
-
-   Atalk:
-   Public domain
-
-   Desktopgui
-   Copyright (c) Mathias De Maré
-   See apps/desktopgui/LICENSE
-
-   SAM C Library:
-   Copyright (c) 2004, Matthew P. Cashdollar <mpc@innographx.com>
-   See apps/sam/c/doc/license.txt
-
-   SAM C# Library:
-   Public domain.
-   See apps/sam/csharp/README
-
-   SAM Perl Library:
-   See licenses/LICENSE-GPLv2.txt
-
-   SAM Python Library:
-   Public domain.
+See the file licenses/LICENSE-Apache2.0.txt

Makefile.gcj

@@ -1,132 +0,0 @@
-# Makefile for building native I2P binaries and libraries with GCJ
-#
-# WARNING: Do not use this yet, as it may explode (etc).
-#
-GCJ=gcj #/usr/local/gcc-4.0.2/bin/gcj
-EXTRA_LD_PATH= #/usr/local/gcc-4.0.2/lib
-ANT=ant #/opt/apache-ant-1.6.5/bin/ant
-ANT_TARGET=build2
-NATIVE_DIR=native
-
-## 
-# Define what jar files get into libi2p.so.  The current setup is
-# *incredibly* lazy, throwing everything in the .so, rather than
-# give each .jar file its own .so.
-#  i2p.jar: base SDK
-#  mstreaming.jar: streaming API
-#  streaming.jar: full streaming lib implementation
-#  i2ptunnel.jar: I2PTunnel proxy
-#  sam.jar: SAM bridge and API
-#  i2psnark.jar: bittorrent client
-#  router.jar: full I2P router
-#  jbigi.jar: collection of native optimized GMP routines for crypto
-JAR_BASE=i2p.jar mstreaming.jar streaming.jar
-JAR_CLIENTS=i2ptunnel.jar sam.jar
-JAR_ROUTER=router.jar
-JAR_JBIGI=jbigi.jar
-JAR_CONSOLE=\
-            javax.servlet.jar \
-            commons-el.jar \
-            commons-logging.jar \
-	    jasper-runtime.jar \
-            jasper-compiler.jar \
-            org.mortbay.jetty.jar \
-	    routerconsole.jar
-LIBI2P_JARS=${JAR_BASE} ${JAR_CLIENTS} ${JAR_ROUTER} ${JAR_JBIGI}
-LIBSAM_JARS=${JAR_BASE} sam.jar
-LIBROUTER_JARS=i2p.jar ${JAR_ROUTER} ${JAR_JBIGI}
-LIBCONSOLE_JARS=${LIBROUTER_JARS} ${JAR_CONSOLE}
-LIBSNARK_JARS=${LIBROUTER_JARS} i2psnark.jar
-# update:
-# similar error with gcj 4.3.3.
-#
-# unfortunately, its not quite ready for most end users, as the
-# ${JAR_CONSOLE} fails to compile with: 
-# org/apache/commons/logging/impl/LogKitLogger.java: In class 'org.apache.commons.logging.impl.LogKitLogger':
-# .../LogKitLogger.java: In constructor '(java.lang.String)':
-# .../LogKitLogger.java:91: error: cannot find file for class org.apache.log.Hierarchy
-# .../LogKitLogger.java:91: error: cannot find file for class org.apache.log.Hierarchy
-# .../LogKitLogger.java:104: error: cannot find file for class org.apache.log.Hierarchy
-# .../LogKitLogger.java:104: confused by earlier errors, bailing out
-
-#${JAR_CONSOLE}\
-#${JAR_XML} \
-#${JAR_SUCKER}
-#${JAR_CONSOLE}
-
-SYSTEM_PROPS=-DloggerFilenameOverride=logs/log-router-@.txt \
-             -Dorg.mortbay.http.Version.paranoid=true \
-	     -Dorg.mortbay.util.FileResource.checkAliases=false \
-	     -Dorg.mortbay.xml.XmlParser.NotValidating=true
-#SYSTEM_PROPS=-Di2p.weakPRNG=true
-OPTIMIZE=-O2
-#OPTIMIZE=-O3
-
-LD_LIBRARY_PATH=${EXTRA_LD_PATH}:.
-
-all: jars native
-	@echo "* Build complete"
-
-jars:
-	@${ANT} ${ANT_TARGET}
-
-clean: native_clean
-
-native: native_clean native_shared
-	@echo "* Native code build in ${NATIVE}"
-
-native_clean:
-	@rm -rf ${NATIVE_DIR}
-	@mkdir ${NATIVE_DIR}
-
-native_shared: libi2p.so
-	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2p_dsa --main=net.i2p.crypto.DSAEngine 
-	@echo "* i2p_dsa is a simple test app with the DSA engine and Fortuna PRNG to make sure crypto is working"
-	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/prng --main=gnu.crypto.prng.FortunaStandalone
-	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2ptunnel --main=net.i2p.i2ptunnel.I2PTunnel 
-	@echo "* i2ptunnel is mihi's I2PTunnel CLI"
-	@echo "  run it as ./i2ptunnel -cli to avoid awt complaints"
-	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2ptunnelctl --main=net.i2p.i2ptunnel.TunnelControllerGroup 
-	@echo "* i2ptunnelctl is a controller for I2PTunnel, reading i2ptunnel.config"
-	@echo "  and launching the appropriate proxies"
-	#@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2psnark --main=org.klomp.snark.Snark
-	#@echo "* i2psnark is an anonymous bittorrent client"
-	@cd build ; ${GCJ} ${OPTIMIZE} -fjni -L../${NATIVE_DIR} -li2p ${SYSTEM_PROPS} -o ../${NATIVE_DIR}/i2prouter --main=net.i2p.router.Router 
-	@echo "* i2prouter is the main I2P router"
-	@echo "  it can be used, and while the router console won't load,"
-	@echo "  i2ptunnel will, so it will start all the proxies defined in i2ptunnel.config"
-
-libi2p.so:
-	@echo "* Building $@"
-	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBI2P_JARS} ; cd .. )
-	@ls -l ${NATIVE_DIR}/$@
-	@echo "* $@ built"
-
-sam: jars libi2psam.so
-
-libi2psam.so:
-	@echo "* Building $@"
-	@rm -f ${NATIVE_DIR}/$@
-	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBSAM_JARS} ; cd .. )
-	@ls -l ${NATIVE_DIR}/$@
-	@echo "* $@ built"
-
-router: jars libi2prouter.so
-
-libi2prouter.so:
-	@echo "* Building $@"
-	@rm -f ${NATIVE_DIR}/$@
-	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBROUTER_JARS} ; cd .. )
-	@ls -l ${NATIVE_DIR}/$@
-	@echo "* $@ built"
-
-console: jars libi2pconsole.so
-
-# doesn't work, see above
-libi2pconsole.so:
-	@echo "* Building $@"
-	@rm -f ${NATIVE_DIR}/$@
-	@(cd build ; time ${GCJ} ${OPTIMIZE} -fPIC -fjni -shared -o ../${NATIVE_DIR}/$@ ${LIBCONSOLE_JARS} ; cd .. )
-	@ls -l ${NATIVE_DIR}/$@
-	@echo "* $@ built"
-

README.md

@@ -0,0 +1,157 @@
+# I2P Android
+
+## Build process
+
+### Dependencies:
+
+- Java SDK (preferably Oracle/Sun or OpenJDK) 1.6.0 or higher
+- Apache Ant 1.8.0 or higher
+- I2P source
+- Android SDK for API 21
+- Android Build Tools 21.1.2
+- Android Support Repository
+- Gradle 2.2.1
+
+### Gradle
+
+The build system is based on Gradle. There are several methods for setting Gradle up:
+
+* It can be downloaded from [the Gradle website](http://www.gradle.org/downloads).
+
+* Most distributions will have Gradle packages. Be careful to check the
+  provided version; Debian and Ubuntu have old versions in their main
+  repositories. There is a [PPA](https://launchpad.net/~cwchien/+archive/gradle)
+  for Ubuntu with the latest version of Gradle.
+
+* A Gradle wrapper is provided in the codebase. It takes all the same commands
+  as the regular `gradle` command. The first time that any command is run, it
+  will automatically download, cache and use the correct version of Gradle.
+  This is the simplest way to get started with the codebase. To use it, replace
+  `gradle` with `./gradlew` (or `./gradlew.bat` on Windows) in the commands
+  below.
+
+Gradle will pull dependencies over the clearnet by default. To send all Gradle
+connections from your user over Tor, create a `gradle.properties` file in
+`~/.gradle/` containing:
+
+```
+systemProp.socksProxyHost=localhost
+systemProp.socksProxyPort=9150
+```
+
+### Preparation
+
+1. Download the Android SDK. The simplest method is to download [Android Studio](https://developer.android.com/sdk/installing/studio.html).
+
+  * If you are using an existing Android SDK, install the Android Support
+    Repository via the SDK Manager.
+
+2. Check out the [`i2p.i2p`](https://github.com/i2p/i2p.i2p) repository.
+
+3. Create a `local.properties` file in `i2p.android.base/lib/client` containing:
+
+    ```
+    ndk.dir=/path/to/ndk
+    ```
+
+3. Create a `local.properties` file in `i2p.android.base/routerjars` containing:
+
+    ```
+    i2psrc=/path/to/i2p.i2p
+    ```
+
+### Building from the command line
+
+1. Create a `local.properties` file in `i2p.android.base` containing:
+
+    ```
+    sdk.dir=/path/to/android-studio/sdk
+    ```
+
+2. `gradle assembleDebug`
+
+3. The APK will be placed in `i2p.android.base/app/build/outputs/apk`.
+
+### Building with Android Studio
+
+1. Import `i2p.android.base` into Android Studio. (This creates the `local.properties` file automatically).
+
+2. Build and run the app (`Shift+F10`).
+
+### Signing release builds
+
+1. Create a `signing.properties` file in `i2p.android.base` containing:
+
+    ```
+    STORE_FILE=/path/to/android.keystore
+    STORE_PASSWORD=store.password
+    KEY_ALIAS=key.alias
+    KEY_PASSWORD=key.password
+    ```
+
+2. `gradle assembleRelease`
+
+## Client library
+
+### "Uploading" to the local Maven repository (to use a local build of the library in a project)
+
+1. `gradle :client:installArchives`
+
+2. Add the local Maven repository to your project. For Gradle projects, add the following above any existing repositories (so it is checked first):
+
+    ```
+    repositories {
+        mavenLocal()
+    }
+    ```
+
+### Uploading to Maven Central via Sonatype OSSRH
+
+1. Add the following lines to your `~/.gradle/gradle.properties` (filling in the blanks):
+
+    ```
+    signing.keyId=
+    signing.password=
+    signing.secretKeyRingFile=/path/to/secring.gpg
+    NEXUS_USERNAME=
+    NEXUS_PASSWORD=
+    ```
+
+2. `gradle :client:uploadArchives`
+
+### Commands from the old build instructions that might be useful
+
+```
+# Create the android 4.4 (API 19) virtual device
+# (don't make a custom hardware profile)
+../android-sdk-linux/tools/android create avd --name i2p --target android-19
+
+# then run the emulator:
+#  This may take a LONG time the first time (half an hour or more)...
+#  Run the debugger to ensure it is making progress
+#   -no-boot-anim for faster boot
+#   -dns-server 8.8.8.8 if the router can't reseed
+#     ../android-sdk-linux/tools/emulator -avd i2p -no-boot-anim -dns-server 8.8.8.8 &
+../android-sdk-linux/tools/emulator -avd i2p &
+
+# or to talk to a real device in debug mode:
+# You have to do this if you get a permission error -
+# Stop ddms, unplug the device, do the following,
+# then plug in the device, then start ddms
+adb kill-server
+sudo adb start-server
+adb devices
+
+# Anyway, with I2P installed, click on the I2P icon on your device and enjoy!
+
+#other helpful commands
+../android-sdk-linux/platform-tools/adb shell
+../android-sdk-linux/platform-tools/adb pull /some/file/on/emulator some-local-dir/
+
+# copy the Dev Tools app from the emulator to your device
+adb -e pull /system/app/Development.apk ./Development.apk
+adb -d install Development.apk
+
+# reinstall an existing apk onto the emulator
+adb -e install -r bin/I2PAndroid-debug.apk
+```

README.txt

@@ -1,31 +0,0 @@
-Prerequisites to build from source:
-	Java SDK (preferably Sun) 1.5.0 or higher (1.6 recommended)
-	Apache Ant 1.7.0 or higher
-	Optional, For multilanguage support: The xgettext, msgfmt, and msgmerge tools installed
-	from the GNU gettext package http://www.gnu.org/software/gettext/
-
-To build:
-	ant pkg
-	Run 'ant' with no arguments to see other build options.
-	See INSTALL.txt or http://www.i2p2.de/download.html for installation instructions.
-
-Documentation:
-	http://www.i2p2.de/
-	API: run 'ant javadoc' then start at build/javadoc/index.html
-
-Latest release:
-	http://www.i2p2.de/download.html
-
-To get development branch from source control:
-	http://www.i2p2.de/newdevelopers.html
-
-FAQ:
-	http://www.i2p2.de/faq.html
-
-Need help?
-	IRC irc.freenode.net #i2p
-	http://forum.i2p2.de/
-
-Licenses:
-	See LICENSE.txt
-

RELEASE-PROCESS.md

@@ -0,0 +1,20 @@
+1. Check out a clean copy of i2p.i2p at the correct release version.
+2. Edit `routerjars/local.properties` to use the clean i2p.i2p copy.
+3. Pull the latest translations with `tx pull -a` and commit them. (If you don't have the `tx` command, do `pip install transifex-client` )
+4. Ensure that `signing.properties` contains the details of the release key.
+5. Edit `gradle.properties` to bump the I2P version.
+6. Edit `app/build.gradle` to bump the Android version number.
+7. If the helper has changed since the last release, edit
+   `lib/helper/gradle.properties` to bump the version.
+8. `./gradlew clean assembleRelease`
+9. `./gradlew :lib:client:uploadArchives`
+10. If the helper version was changed: `./gradlew :lib:helper:uploadArchives`
+11. Check on Sonatype that everything worked, and close/release.
+12. Update local fdroidserver repo
+13. `cp app/build/outputs/apk/free/release/app-free-release.apk path/to/fdroid/repo/I2P-VERSION.apk`
+14. Update `path/to/fdroid/metadata/net.i2p.android.txt`
+15. `fdroid update`
+16. Push to download server and put in place.
+17. Check F-Droid repo works, and app works.
+18. `mtn ci gradle.properties lib/helper/gradle.properties app/build.gradle`
+19. Push free and donate builds to Google Play.

Slackware/README

@@ -1,30 +0,0 @@
-ou will need atleast monotone > = 0.41 to get the most recent build source
-and connect it to an already running i2p router.
-
-OR:
-
-You may download the actual "stable" source from
-http://code.google.com/p/i2p/downloads/list
-
-You will need to follwing tools to build the i2p and i2p-base packages:
-
-bash >= 3.1.017
-requiredbuilder >= 0.16.3 ( http://www.stabellini.net/requiredbuilder.html )
-jre >= 6u11
-jdk >= 6u11
-apache-ant >= 1.7.1
-perl >= 5.10.0
-python >= 2.5.2
-
-Reccomended:
-monotone >= 0.41 ( http://pkgs.dr.ea.ms )
-
-See also:
-
-i2p/readme.txt
-
-AND
-
-i2p-base/readme.txt
-
-for information and handy tips.

Slackware/i2p-base/build.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<project basedir="." default="slackpkg">
-    <target name="slackpkg">
-        <echo message="Building Slackware package." />
-        <exec executable="./i2p-base.SlackBuild">
-        </exec>
-    </target>
-</project>

Slackware/i2p-base/doinst.sh

@@ -1,157 +0,0 @@
-#!/bin/sh
-#
-#
-# Now in the future we only need to look for '#I2P' and '#/I2P' 
-# for modifications to rc.local and rc.local_shutdown. 
-# I was a moron for not doing it this way in the first place :-) -- Sponge
-#
-#
-
-touch /etc/rc.d/rc.local
-touch /etc/rc.d/rc.local_shutdown
-
-echo
-echo -n "Check 1: /etc/rc.d/rc.local "
-I2PRCA=`grep -c /etc/rc.d/rc.local -e '/etc/rc.d/rc.i2p'`
-
-if [ $I2PRCA -eq 0 ] ; then
-	echo '#I2P' >> /etc/rc.d/rc.local
-	echo '( cd /tmp ; rm -Rf i2p-*.tmp )' >> /etc/rc.d/rc.local
-	echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local
-	echo "        sh /etc/rc.d/rc.i2p start" >> /etc/rc.d/rc.local
-	echo "fi" >> /etc/rc.d/rc.local
-	echo '#/I2P' >> /etc/rc.d/rc.local
-	echo "modified."
-else
-	echo -n "looks OK so far,"
-	# Fix old installs, or where people have modified.
-
-	echo -n " Check 1A: "
-	I2PRCC=`grep -c /etc/rc.d/rc.local -e 'i2p-\*\.tmp'`
-
-	if [ $I2PRCC -eq 0 ] ; then
-		DATA=$(cat /etc/rc.d/rc.local | sed -re 's/if \[ -x \/etc\/rc\.d\/rc\.i2p \] ; then/#I2P\n\( cd \/tmp ; rm -Rf i2p-*.tmp \)\nif \[ -x \/etc\/rc.d\/rc.i2p \] ; then/')
-		echo "${DATA}" > /etc/rc.d/rc.local
-		echo -n "additional modifications applied,"
-	else
-		echo -n "looks OK so far,"
-	fi
-
-	echo -n " Check 1B: "
-	I2PRCE=`grep -c /etc/rc.d/rc.local -e 'i2p-\*\.tmp'`
-	if [ $I2PRCE -eq 0 ] ; then
-		DATATOP=$(cat /etc/rc.d/rc.local | sed -n '0,/i2p-\*\.tmp/p' | sed '$d' )
-		DATABOT=$(cat /etc/rc.d/rc.local | sed -n '/i2p-\*\.tmp/,$p' | sed -n '/^fi/,$p' | sed "1d")
-		echo "${DATATOP}" > /etc/rc.d/rc.local
-		echo '#I2P' >> /etc/rc.d/rc.local
-		echo '( cd /tmp ; rm -Rf i2p-*.tmp )' >> /etc/rc.d/rc.local
-		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local
-		echo "        sh /etc/rc.d/rc.i2p start" >> /etc/rc.d/rc.local
-		echo "fi" >> /etc/rc.d/rc.local
-		echo '#/I2P' >> /etc/rc.d/rc.local
-		echo "${DATABOT}" >> /etc/rc.d/rc.local
-		
-		echo -n "additional modifications applied,"
-	else
-		echo -n "looks ok so far,"
-	fi
-	echo -n " Check 1C: "
-	I2PRCF=`grep -c /etc/rc.d/rc.local -e '#/I2P'`
-	if [ $I2PRCF -eq 0 ] ; then
-		DATATOP=$(cat /etc/rc.d/rc.local | sed -n '0,/^#I2P/p' | sed '$d' )
-		DATABOT=$(cat /etc/rc.d/rc.local | sed -n '/^#I2P/,$p' | sed -n '/^fi/,$p' | sed "1d")
-		echo "${DATATOP}" > /etc/rc.d/rc.local
-		echo '#I2P' >> /etc/rc.d/rc.local
-		echo '( cd /tmp ; rm -Rf i2p-*.tmp )' >> /etc/rc.d/rc.local
-		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local
-		echo "        sh /etc/rc.d/rc.i2p start" >> /etc/rc.d/rc.local
-		echo "fi" >> /etc/rc.d/rc.local
-		echo '#/I2P' >> /etc/rc.d/rc.local
-		echo "${DATABOT}" >> /etc/rc.d/rc.local
-
-		echo -n "additional modifications applied,"
-	else
-		echo -n "looks ok so far,"
-	fi
-	echo " Done."
-fi
-
-echo -n "Check 2: /etc/rc.d/rc.local_shutdown "
-I2PRCB=`grep -c /etc/rc.d/rc.local_shutdown -e '/etc/rc.d/rc.i2p'`
-if [ $I2PRCB -eq 0 ] ; then
-	echo "#I2P" >> /etc/rc.d/rc.local_shutdown
-	echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local_shutdown
-	echo "        sh /etc/rc.d/rc.i2p stop" >> /etc/rc.d/rc.local_shutdown
-	echo "fi" >> /etc/rc.d/rc.local_shutdown
-	echo "#/I2P" >> /etc/rc.d/rc.local_shutdown
-	echo "modified."
-else
-	echo -n "looks OK so far,"
-	# Fix old installs
-
-	echo -n " Check 1A: "
-	I2PRCG=`grep -c /etc/rc.d/rc.local_shutdown -e '#I2P'`
-	if [ $I2PRCG -eq 0 ] ; then
-		DATATOP=$(cat /etc/rc.d/rc.local_shutdown | sed -n '0,/^if \[ -x \/etc\/rc\.d\/rc\.i2p \] ; then/p' | sed '$d' )
-		DATABOT=$(cat /etc/rc.d/rc.local_shutdown | sed -n '/^if \[ -x \/etc\/rc\.d\/rc\.i2p \] ; then/,$p' | sed -n '/^fi/,$p' | sed "1d")
-		echo "${DATATOP}" > /etc/rc.d/rc.local_shutdown
-		echo '#I2P' >> /etc/rc.d/rc.local_shutdown
-		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local_shutdown
-		echo "        sh /etc/rc.d/rc.i2p stop" >> /etc/rc.d/rc.local_shutdown
-		echo "fi" >> /etc/rc.d/rc.local_shutdown
-		echo "#/I2P" >> /etc/rc.d/rc.local_shutdown
-		echo "${DATABOT}" >> /etc/rc.d/rc.local_shutdown
-		echo -n "additional modifications applied,"
-	else
-		echo -n "looks OK so far,"
-	fi
-	echo -n " Check 1B: "
-	I2PRCH=`grep -c /etc/rc.d/rc.local_shutdown -e '#/I2P'`
-	if [ $I2PRCH -eq 0 ] ; then
-		DATATOP=$(cat /etc/rc.d/rc.local_shutdown | sed -n '0,/^#I2P/p' | sed '$d' )
-		DATABOT=$(cat /etc/rc.d/rc.local_shutdown | sed -n '/^#I2P/,$p' | sed -n '/^fi/,$p' | sed "1d")
-		echo "${DATATOP}" > /etc/rc.d/rc.local_shutdown
-		echo '#I2P' >> /etc/rc.d/rc.local_shutdown
-		echo "if [ -x /etc/rc.d/rc.i2p ] ; then" >> /etc/rc.d/rc.local_shutdown
-		echo "        sh /etc/rc.d/rc.i2p stop" >> /etc/rc.d/rc.local_shutdown
-		echo "fi" >> /etc/rc.d/rc.local_shutdown
-		echo "#/I2P" >> /etc/rc.d/rc.local_shutdown
-		echo "${DATABOT}" >> /etc/rc.d/rc.local_shutdown
-		echo -n "additional modifications applied,"
-	else
-		echo -n "looks OK so far,"
-	fi
-	echo " Done."
-fi
-
-if [ -f /etc/rc.d/rc.i2p ] ; then
-	if [ -x /etc/rc.d/rc.i2p ] ; then
-		chmod +x /etc/rc.d/rc.i2p.new
-	fi
-	# Hopefully get admin's attention.
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -e "\007" ; sleep 0.3
-	echo "It apears that you already have /etc/rc.d/rc.i2p"
-	echo "You should replace it with /etc/rc.d/rc.i2p.new as soon as possible"
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -ne "\007" ; sleep 0.3
-	echo -e "\007" ; sleep 0.3
-else
-	mv /etc/rc.d/rc.i2p.new /etc/rc.d/rc.i2p
-	echo
-	echo "Installation finished. The i2p start/stop script has been"
-	echo "installed in /etc/rc.d . You should chmod +x"
-	echo '/etc/rc.d/rc.i2p to start it on boot.'
-	echo
-fi
-
-exit

Slackware/i2p-base/i2p-base.SlackBuild

@@ -1,57 +0,0 @@
-#!/bin/sh
-#
-# Heavily based on the Slackware 12.2 SlackBuild
-# Slackware build script for I2P
-#
-# PLEASE READ THIS:
-# How to start I2P:
-# After installpkg command, doinst.sh will execute a post-installation script
-# needed by I2P. After that you have to chmod +x /etc/rc.d/rc.i2p and start
-# I2P service with /etc/rc.d/rc.i2p start.
-#
-# Now tell your browser to user this proxy: localhost on port 4444 and open
-# this page: http://localhost:7657/index.jsp
-#
-# Here you can configure I2P, watch network status and navigate anonimously.
-# It's suggested to subscribe to various dns host, like i2host.i2p
-# For any additional information, visit i2host.i2p and forum.i2p
-#
-
-CWD=$(pwd)
-TMP=/tmp
-PKG=/$TMP/package-base-i2p
-NAME=i2p-base
-VERSION=0.0.2
-BUILD=1sponge
-ARCH=noarch
-INSTALL_DIR=opt
-
-# Less than slackware 13?
-SLKPLT=$(cat /etc/slackware-version | sed -re "s/(Slackware )([0-9]*)(.*)/\2/")
-if [ $SLKPLT -lt 13 ] ; then
-	EXT=tgz
-else
-	EXT=txz
-fi
-
-rm -rf $PKG
-mkdir -p $PKG
-cd $PKG
-chown -R root:root .
-
-mkdir -p $PKG/etc/rc.d
-mkdir -p $PKG/install
-sed "s|directory|/$INSTALL_DIR/i2p/i2prouter|g" "$CWD/rc.i2p_def" > $PKG/etc/rc.d/rc.i2p.new
-chmod 644 $PKG/etc/rc.d/rc.i2p.new
-cat "$CWD/doinst.sh" > $PKG/install/doinst.sh
-cat "$CWD/slack-desc" > $PKG/install/slack-desc
-
-cd $PKG
-#
-# Not really that important to exec this 
-# as there aren't any deps we don't know.
-#
-# requiredbuilder -v -y -s $CWD $PKG
-#
-cat "$CWD/slack-required" > $PKG/install/slack-required
-makepkg -l y -c n $CWD/${NAME}-$VERSION-$ARCH-$BUILD.$EXT

Slackware/i2p-base/rc.i2p_def

@@ -1,51 +0,0 @@
-#!/bin/sh
-# Start/stop i2p service.
-
-i2p_start() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory start )"
-}
-
-i2p_stop() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory stop )"
-}
-
-i2p_restart() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory restart)"
-}
-
-i2p_status() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory status )"
-}
-
-i2p_console() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory console )"
-}
-
-i2p_dump() {
- /bin/su - -c "( export PATH=\"$PATH:/usr/lib/java/bin:/usr/lib/java/jre/bin\"; directory dump )"
-}
-
-case "$1" in
-'start')
-  i2p_start
-  ;;
-'stop')
-  i2p_stop
-  ;;
-'restart')
-  i2p_restart
-  ;;
-'status')
-  i2p_status
-  ;;
-'console')
-  i2p_console
-  ;;
-'dump')
-  i2p_dump
-  ;;
-*)
-  echo "usage $0 start|stop|restart|status|console|dump"
-  ;;
-esac
-

Slackware/i2p-base/readme.txt

@@ -1,10 +0,0 @@
-An rc file called rc.i2p has been placed into the /etc/rc.d directory.
-If you want to change installation dir, change the variable INSTALL_DIR
-on base-i2p.SlackBuild and rebuild the package. You also will need to do the
-same for the i2p package.
-
-The install script will insert everything needed into /etc/rc.d/rc.local and
-into /etc/rc.d/rc.local_shutdown automatically.
-
-If you want to start I2P at boot you have to chmod +x /etc/rc.d/rc.i2p
-

Slackware/i2p-base/slack-desc

@@ -1,19 +0,0 @@
-# HOW TO EDIT THIS FILE:
-# The "handy ruler" below makes it easier to edit a package description.  Line
-# up the first '|' above the ':' following the base package name, and the '|' on
-# the right side marks the last column you can put a character in.  You must make
-# exactly 11 lines for the formatting to be correct.  It's also customary to
-# leave one space after the ':'.
-
-        |-----handy-ruler------------------------------------------------------|
-base-i2p: base-i2p (I2P anonymizing network base config files)
-base-i2p:
-base-i2p: I2P is an anonymizing network, offering a simple layer that
-base-i2p: identity-sensitive applications can use to securely communicate. All
-base-i2p: data is wrapped with several layers of encryption, and the network is
-base-i2p: both distributed and dynamic, with no trusted parties.
-base-i2p: Many applications are available that interface with I2P, including 
-base-i2p: mail, peer-peer file sharing, IRC chat, and others.
-base-i2p:
-base-i2p: This package provides the startup files.
-base-i2p:

Slackware/i2p-base/slack-required

@@ -1 +0,0 @@
-bash >= 3.1.017

Slackware/i2p/build.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
-<project basedir="." default="slackpkg">
-    <target name="slackpkg">
-        <echo message="Building Slackware package." />
-        <exec executable="./i2p.SlackBuild">
-        </exec>
-    </target>
-</project>

Slackware/i2p/doinst.sh

@@ -1,72 +0,0 @@
-#!/bin/sh
-
-INST_DIR=directory
-
-( cd install
-
-echo
-for i in *.config ; {
-	if [ -f $INST_DIR/$i ] ; then
-		echo "Please check ${INST_DIR}${i}, as there is a new version."
-		cp $i $INST_DIR/$i.new
-	else
-		cp $i $INST_DIR/$i
-	fi
-}
-
-)
-
-( cd $INST_DIR
-	if [ -f blocklist.txt ] ; then
-		echo "Please check ${INST_DIR}blocklist.txt, as there is a new version."
-	else
-		mv blocklist.txt.new blocklist.txt
-	fi
-)
-
-( cd $INST_DIR/eepsite
-	if [ -f jetty.xml ] ; then
-		rm jetty.xml.new
-	else
-		mv jetty.xml.new jetty.xml
-	fi
-)
-
-( cd $INST_DIR/eepsite/docroot
-	if [ -f index.html ] ; then
-		rm index.html.new
-	else
-		mv index.html.new index.html
-	fi
-	if [ -f favicon.ico ] ; then
-		rm favicon.ico.new
-	else
-		mv favicon.ico.new favicon.ico
-	fi
-)
-
-echo
-echo "FINISHING I2P INSTALLATION. PLEASE WAIT."
-
-cd $INST_DIR
-
-
-
-OS_ARCH=`uname -m`
-X86_64=`echo "$OS_ARCH" | grep x86_64`
-if [ "X$X86_64" = "X" ]; then
-        wrapperpath="./lib/wrapper/linux"
-else
-        wrapperpath="./lib/wrapper/linux64"
-fi
-cp $wrapperpath/libwrapper.so ./lib/
-cp $wrapperpath/wrapper.jar ./lib/
-cp $wrapperpath/i2psvc .
-rm -rf ./lib/wrapper
-chmod 744 ./i2psvc
-
-echo
-echo "Installation finished."
-echo
-
-exit

Slackware/i2p/i2p.SlackBuild

@@ -1,130 +0,0 @@
-#!/bin/sh
-#
-# Heavily based on the Slackware 12.2 SlackBuild
-# Slackware build script for I2P
-#
-# PLEASE READ THIS:
-# Probably you will never have to update I2P packages with upgradepkg,
-# just because I2P has an auto-update function.
-# Really you should not ever use any "upgrade" method.
-#
-# The correct way to upgrade is to: 
-# 1: install the upgrade
-# 2: remove the old package
-#
-# It is a terrible shame that upgradepkg doesn't do this, infact, 
-# it would actually be the correct way for *any* package!
-#
-#
-
-BUILD=1sponge
-INSTALL_DIR=opt
-NAME=i2p
-ARCH=noarch
-
-# Less than slackware 13?
-SLKPLT=$(cat /etc/slackware-version | sed -re "s/(Slackware )([0-9]*)(.*)/\2/")
-if [ $SLKPLT -lt 13 ] ; then
-	EXT=tgz
-else
-	EXT=txz
-fi
-
-
-#
-# This mess is here due to the totally moronic way i2p does versioning.
-# We correct it here.
-#
-ROUTER=$(echo -ne "_")$(cat ../../router/java/src/net/i2p/router/RouterVersion.java | grep -e "public final static long BUILD" | cut -f2 -d"=" | cut -f1 -d";" | sed -re "s/ //g")
-if [ "$ROUTER" == "_" ] ;  then
-	ROUTER="_0"
-fi
-
-#
-# That was the easy one, now for the tough one.
-#
-
-CORE=$(cat ../../core/java/src/net/i2p/CoreVersion.java | grep -e "public final static String VERSION" | cut -f2 -d'"' | sed -re "s/ //g")
-CORE1=$(echo -n $CORE.x.x | sed -re "s/(.*)\.(.*)\.(.*)\.(.*)/\1/")
-CORE2=$(echo -n $CORE.x | sed -re "s/(.*)\.(.*)\.(.*)\.(.*)/\1/")
-
-if [ "$CORE.x.x" == "$CORE1" ] ; then
-	CORE=$(echo -ne $CORE".0.0")
-fi
-if [ "$CORE.x" == "$CORE2" ] ; then
-	CORE=$(echo -ne $CORE".0")
-fi
-
-VERSION=$(echo $CORE$ROUTER)
-#
-# Whew!
-# OK, let's build i2p
-#
-
-CWD=$(pwd)
-TMP=/tmp
-
-PKG=$TMP/package-i2p
-rm -rf $PKG
-mkdir -p $PKG
-
-cd $CWD/../../
-
-ant distclean
-#ant dist
-ant tarball
-
-tar xjvf i2p.tar.bz2 -C $TMP
-
-cd $TMP/i2p
-chown -R root:root .
-
-mkdir -p $PKG/$INSTALL_DIR/
-cp -a ../i2p $PKG/$INSTALL_DIR/
-
-mkdir -p $PKG/install
-
-#############################################################################
-# Preconfigureation to make package smaller
-#############################################################################
-cd $PKG/$INSTALL_DIR/i2p
-
-# wrapper.config $INSTALL_PATH and $SYSTEM_java_io_tmpdir
-sed "s|\$INSTALL_PATH|$INSTALL_DIR/i2p|g" wrapper.config > a
-sed "s|\$SYSTEM_java_io_tmpdir|/var/tmp|g" a > wrapper.config
-# eepget %INSTALL_PATH
-sed "s|\$INSTALL_PATH|$INSTALL_DIR/i2p|g" eepget > a
-rm eepget
-mv a eepget
-# runplain.sh %INSTALL_PATH and %SYSTEM_java_io_tmpdir
-sed "s|%INSTALL_PATH|$INSTALL_DIR/i2p|g" runplain.sh > a
-sed "s|%SYSTEM_java_io_tmpdir|/var/tmp|g" a > runplain.sh
-# i2prouter %INSTALL_PATH and %SYSTEM_java_io_tmpdir
-sed "s|%INSTALL_PATH|$INSTALL_DIR/i2p|g" i2prouter > a
-sed "s|%SYSTEM_java_io_tmpdir|/var/tmp|g" a > i2prouter
-
-chmod 744 ./i2prouter
-chmod 744 ./osid
-chmod 744 ./runplain.sh
-chmod 744 ./eepget
-chmod 744 ./scripts/i2pbench.sh
-chmod 744 ./scripts/i2ptest.sh
-rm -Rf ./lib/*.dll ./*.bat ./*.exe ./installer ./icons ./a postinstall.sh
-
-mv $PKG/$INSTALL_DIR/i2p/*.config $PKG/install
-mv $PKG/$INSTALL_DIR/i2p/blocklist.txt $PKG/$INSTALL_DIR/i2p/blocklist.txt.new
-mv $PKG/$INSTALL_DIR/i2p/eepsite/jetty.xml $PKG/$INSTALL_DIR/i2p/eepsite/jetty.xml.new
-mv $PKG/$INSTALL_DIR/i2p/eepsite/docroot/index.html $PKG/$INSTALL_DIR/i2p/eepsite/docroot/index.html.new
-mv $PKG/$INSTALL_DIR/i2p/eepsite/docroot/favicon.ico $PKG/$INSTALL_DIR/i2p/eepsite/docroot/favicon.ico.new
-sed "s|directory|/$INSTALL_DIR/i2p/|g" $CWD/doinst.sh > $PKG/install/doinst.sh
-cat $CWD/slack-desc > $PKG/install/slack-desc
-
-cd $PKG
-#
-# requiredbuilder fucks up REALLY bad, and thinks java is perl?!
-# It also did not catch the shell requirements! BOOOOOOOOOOO! HISSSSSSSS!
-#
-# requiredbuilder -v -y -s $CWD $PKG
-#
-cat $CWD/slack-required > $PKG/install/slack-required
-makepkg -l y -c n $CWD/${NAME}-$VERSION-$ARCH-$BUILD.$EXT

Slackware/i2p/readme.txt

@@ -1,47 +0,0 @@
-Building:
-The i2p package will be installed in /opt/i2p 
-
-If you want to change installation dir, change the variable INSTALL_DIR
-on i2p.SlackBuild and rebuild the package. You will also need to do the same
-in the base-i2p package.
-
-Installation and Upgrade:
-Probably you will never have to update i2p packages. However if you do,
-be sure to installpkg first, then removepkg or custom config files can
-be lost with upgradepkg. I2P has an auto-update function. However using
-installpkg then removepkg lowers the demand on the I2P network as a 
-whole, and is by far faster.
-
-After installpkg command, doinst.sh will execute a postinstallation script
-needed by I2P.  Be sure to also install the base-i2p package.
-
-Optional:
-
-chmod +x /etc/rc.d/rc.i2p only if you want it to start on boot and stop on
-shutdown.
-
-How to start I2P:
-
-Start I2P service with-
-sh /etc/rc.d/rc.i2p start
-
-Now tell your browser to user this proxy: localhost on port 4444 and open
-this page: http://localhost:7657/index.jsp
-Here you can configure I2P, watch network status and navigate anonimously.
-It's suggested to subscribe to various addressbook hosts so that you can
-get to the many available eepsites and other service on I2P. These are not
-set up by default for security reasons. 
-
-Please see the faqs on http://www.i2p2.i2p/ or http://www.i2p2.de/ on how
-to subscribe to the various addressbook services.
-
-To stop I2P:
- /etc/rc.d/rc.i2p stop
-
-
-For any additional information:
-
-Within I2P- http://www.i2p2.i2p/, http://forum.i2p/, http://zzz.i2p
-
-Internet (not reccomended!) - http://www.i2p2.de/, http://forum.i2p2.de/
-

Slackware/i2p/slack-desc

@@ -1,19 +0,0 @@
-# HOW TO EDIT THIS FILE:
-# The "handy ruler" below makes it easier to edit a package description.  Line
-# up the first '|' above the ':' following the base package name, and the '|' on
-# the right side marks the last column you can put a character in.  You must make
-# exactly 11 lines for the formatting to be correct.  It's also customary to
-# leave one space after the ':'.
-
-   |-----handy-ruler----------------------------------------------------------|
-i2p: i2p (an anonymizing network)
-i2p:
-i2p: I2P is an anonymizing network, offering a simple layer that
-i2p: identity-sensitive applications can use to securely communicate. All
-i2p: data is wrapped with several layers of encryption, and the network is
-i2p: both distributed and dynamic, with no trusted parties.
-i2p: Many applications are available that interface with I2P, including 
-i2p: mail, peer-peer file sharing, IRC chat, and others.
-i2p: WARNING: To upgrade installpkg FIRST _THEN_ removepkg.
-i2p: For more information, see:  http://www.i2p2.de/
-i2p:

Slackware/i2p/slack-required

@@ -1,4 +0,0 @@
-jre >= 5
-i2p-base >= 0.0.1
-bash >= 3.1.017
-

TODO

@@ -0,0 +1,130 @@
+# Fixes
+
+- Create tunnel wizard
+    <zzz> hmm would be nice if they could be shared-client or have an option
+    <zzz> was setting up email tunnels
+- Browser
+    <zzzccc> Bug report: i2p browser treats 302 as an error
+    <zzzccc> Bug 2: rotate screen in i2p browser seems to go back one page
+- Console text change
+    <zzz> "download" and "upload" at the bottom of the status is a little misleading..
+    <zzz> maybe 'downstream bandwidth' or 'inbound usage' ?
+- Fix visibility of advanced tunnel parameter changes
+    <zzz> when I change an advanced tunnel param e.g. length or variance, the change isn't displayed, I have to go back and forward again to see the change
+
+# New UI fixes
+
+- Addressbook action items are in tunnel overflow menu after moving from console to tunnels
+- Material design:
+  - Style for addressbook headers
+  - Change console FAM icon when possible
+    <zzz> on the bottom right, the + and x icons might be better as a double-up arrow and double-down arrow?
+  - Use Material design for LongPressButton
+  - Highlight selected tunnel in two-pane mode
+
+# Short-term
+
+- Remove peers page (HTML version)
+- Add firewall help page showing current port settings
+- GMP 6
+- Fetch all JARs from Maven Central (ie. upload everything that I2P Android uses)
+- Disable uPnP when on cell networks
+    <zzz> spewing UPnP out into cell networks is a waste of time at best and a security risk at worst, but you really want it for wifi
+- Rewrite settings config handling
+- Rewrite InitActivities
+- I2PTunnel
+  - Improve tunnel list status indicators
+  - Icon overlay to indicate which tunnels are shared
+    - Or reorder / group tunnels?
+  - Show all messages somewhere
+    - Bottom toolbar?
+  - Icons/header images for tunnel types on details page
+  - Setting to close when not on WiFi
+- Progress feedback for addressbook subscriptions reload
+- Display release notes directly on new router version
+- Fill out help pages
+- Fix navigation to specific settings pages
+- Rewrite release notes to be release-specific
+- Fix release notes UI, either make back button use clear or add buttons
+- Notify user when autostart fails?
+- NetDB tablet view fixes
+  - Refresh detail fragment when changing tab
+  - Move list to correct item when changing tab
+  - Create nav history when viewing RI from LS
+- Handle NetDB null cases (failed lookup of requested hash in detail page)
+- Include GeoIP db for country info
+- Maybe change router-off mechanic for various pages? Enable as they become available?
+
+# Medium-term
+
+- SQLite naming service backend to store addresses more effectively
+  - Leverage for name completion in e.g. browsers
+- Create/edit tunnels while router is not running
+- Separate out shared tunnel config
+  - Convey to users that one config controls all shared tunnels
+- Network profiles
+  - User selects profile in settings
+  - Change network participation etc. based on profile
+  - Also look at connection type: Connectivity.isConnectionFast()
+- Expose log level overrides
+- Bug report feature
+- Replace peers page (native version)
+- Improve graphs
+  - Show fixed x range, not only available data
+  - Think about pan/zoom
+  - How to persist data across restarts?
+- Enable apps to specify when they don't need the router anymore
+
+# Silent Store approval checks to confirm/implement
+
+- Known Vulnerabilities
+  - Apps will be tested to ensure that they are not susceptible to known
+    publicly disclosed vulnerabilities. For example:
+    - Heartbleed
+    - Poodle
+    - MasterKey
+    - Common Path Traversal attacks
+    - Common SQL Injection attacks
+- Network Security Protocols
+  - All Apps that require transmission of data from the App to a system that
+    does not exist on the device must use, at a minimum, TLS1.1 standards.
+    However, Blackphone would prefer the usage of TLS1.2.
+  - Apps must not use algorithms for cryptographic purposes that are considered
+    obsolete or outdated i.e. MD5, SHA1, RC4, DES, or any encryption algorithm
+    that is weaker than AES128.
+- Transport Layer Protection
+  - All network communication should be encrypted
+  - Not vulnerable to SSl Strip
+- Data Leakage
+  - No storage of sensitive data outside of application sandbox
+  - Files should not be created with MODE_WORLD_READABLE or MODE_WORLD_WRITABLE
+  - Copy & Paste will be evaluated on a case by case basis
+  - App logs should not contain sensitive information
+- Authentication and Authorization
+  - Validate that authentication credentials are not stored on the device
+  - Must use an approved password-based key derivation function ie. PBKDF2, scrypt
+- Data-at-rest Encryption
+  - Must use at a minimum AES128 with modes CCM or GCM
+  - Should not store the encryption key on the file system
+- Permission Checks
+  - The App must function with all permissions disabled
+  - Apps must not hard crash if a permission is disabled
+  - Apps should ask users to enable permissions that are disabled if needed to
+    function properly and explain why the permission is necessary
+- Privacy Policy
+  - Apps must have a privacy policy that details how customer data is used,
+    stored, shared, etc...
+  - Apps must be configured with the customer opted out by default
+  - App logs should not contain PII
+- Error Handling
+  - Apps should follow best-practices for error handling and logging
+
+# Long-term
+
+- Reproducible builds
+- Extract RouterService into a library
+- Remote router support
+  - Implement a "router wrapper" that can represent a local or remote router
+  - Implement/use client APIs to talk to remote router
+    - I2CP
+    - I2PControl

android/AndroidManifest.xml

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-      package="net.i2p.router"
-      android:versionCode="1"
-      android:versionName="1.0.0">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <!-- 3 = 1.5, 2 = 1.1, 1 = 1.0; would probably work with 1 but don't have a 1.0 SDK to test against -->
-    <uses-sdk android:minSdkVersion="2" />
-    <application android:label="@string/app_name">
-        <activity android:name=".I2PAndroid"
-                  android:label="@string/app_name"
-                  android:launchMode="singleTask" >
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-    </application>
-</manifest> 

android/README.txt

@@ -1,29 +0,0 @@
-These instructions are for the 1.5 Android SDK.
-The build file is not compatible with the 1.1 SDK any more.
-1.6 and 2.0 SDKs are untested.
-
-#Unzip the android SDK in ../../
-#So then the android tools will be in ../../android-sdk-linux_x86-1.5_r2/tools/
-
-# create a file local.properties with the following line:
-# sdk-location=/path/to/your/android-sdk-linux_x86-1.5_r2
-
-#then build the android apk file:
-ant debug
-
-# Create the android 1.5 virtual device
-# (don't make a custom hardware profile)
-../../android-sdk-linux_x86-1.5_r2/tools/android create avd --name i2p --target 2
-
-#then run the emulator:
-../../android-sdk-linux_x86-1.5_r2/tools/emulator -avd i2p &
-
-#then wait a couple minutes until the emulator is up
-#then install the I2P app
-ant install
-
-#then run the debugger
-../../android-sdk-linux_x86-1.5_r2/tools/ddms &
-
-#to rebuild and reinstall to emulator:
-ant reinstall

android/build.xml

@@ -1,352 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project name=".I2PAndroid" default="help">
-
-    <!-- The local.properties file is created and updated by the 'android' tool.
-         It contain the path to the SDK. It should *NOT* be checked in in Version
-         Control Systems. -->
-    <property file="local.properties"/>
-
-    <!-- The build.properties file can be created by you and is never touched
-         by the 'android' tool. This is the place to change some of the default property values
-         used by the Ant rules.
-         Here are some properties you may want to change/update:
-
-         application-package
-             the name of your application package as defined in the manifest. Used by the
-             'uninstall' rule.
-         source-folder
-             the name of the source folder. Default is 'src'.
-         out-folder
-             the name of the output folder. Default is 'bin'.
-
-         Properties related to the SDK location or the project target should be updated
-          using the 'android' tool with the 'update' action.
-
-         This file is an integral part of the build system for your application and
-         should be checked in in Version Control Systems.
-
-         -->
-    <property file="build.properties"/>
-
-    <!-- The default.properties file is created and updated by the 'android' tool, as well
-         as ADT. 
-         This file is an integral part of the build system for your application and
-         should be checked in in Version Control Systems. -->
-    <property file="default.properties"/>
-
-    <!-- Custom Android task to deal with the project target, and import the proper rules.
-         This requires ant 1.6.0 or above. -->
-    <path id="android.antlibs">
-        <pathelement path="${sdk-location}/tools/lib/anttasks.jar" />
-        <pathelement path="${sdk-location}/tools/lib/sdklib.jar" />
-        <pathelement path="${sdk-location}/tools/lib/androidprefs.jar" />
-        <pathelement path="${sdk-location}/tools/lib/apkbuilder.jar" />
-        <pathelement path="${sdk-location}/tools/lib/jarutils.jar" />
-    </path>
-
-    <taskdef name="setup"
-        classname="com.android.ant.SetupTask"
-        classpathref="android.antlibs"/>
-
-    <!-- Execute the Android Setup task that will setup some properties specific to the target,
-         and import the rules files.
-         To customize the rules, copy/paste them below the task, and disable import by setting
-         the import attribute to false:
-            <setup import="false" />
-         
-         This will ensure that the properties are setup correctly but that your customized
-         targets are used.
-    -->
-    <setup import="false" />
-
-    <!--
-         ================================================================================
-         New I2P rules
-         ================================================================================
-    -->
-
-    <target name="buildrouter" depends="dirs" >
-        <!-- build router and core -->
-        <ant dir=".." target="buildrouter" />
-
-        <!-- router -->
-        <copy file="../build/router.jar" todir="${external-libs-folder}" />
-
-        <!-- core -->
-        <mkdir dir="tmp" />
-        <unjar src="../build/i2p.jar" dest="tmp/" />
-        <delete file="tmp/net/i2p/util/LogWriter.class" />
-        <!-- org.bouncycastle.crypto already in android
-             but we need a little trickery because our HMac is incompatible...
-             and the libs aren't in the SDK to compile against??? -->
-        <jar destfile="${external-libs-folder}/crypto.jar" >
-            <fileset dir="tmp/" >
-                <include name="org/bouncycastle/crypto/Digest.class" />
-                <include name="org/bouncycastle/crypto/Mac.class" />
-                <include name="org/bouncycastle/crypto/digests/GeneralDigest.class" />
-                <include name="org/bouncycastle/crypto/digests/MD5Digest.class" />
-            </fileset>
-        </jar>
-        <delete>
-            <fileset dir="tmp/" >
-                <include name="org/bouncycastle/crypto/Digest.class" />
-                <include name="org/bouncycastle/crypto/Mac.class" />
-                <include name="org/bouncycastle/crypto/digests/GeneralDigest.class" />
-                <include name="org/bouncycastle/crypto/digests/MD5Digest.class" />
-            </fileset>
-        </delete>
-<!--
-        <delete dir="tmp/org/bouncycastle/" />
-        <delete file="tmp/net/i2p/crypto/HMACGenerator.class" />
--->
-        <delete file="tmp/org/bouncycastle/" />
-        <!-- lots of unneeded stuff could be deleted here -->
-        <jar destfile="${external-libs-folder}/i2p.jar" basedir="tmp/" />
-
-        <!-- some resources -->
-        <mkdir dir="res/drawable/" />
-        <copy file="../installer/resources/themes/console/images/i2plogo.png" todir="res/drawable/" />
-        <copy file="../installer/resources/blocklist.txt" tofile="res/raw/blocklist_txt" />
-    </target>
-
-    <target name="hackcleanup">
-        <delete file="${external-libs-folder}/crypto.jar" />
-    </target>
-
-    <!--
-         ================================================================================
-         From here down copied from SDK platforms/android-1.1/templates/android_rules.xml
-         and then modified
-         ================================================================================
-    -->
-
-    <!--
-        This rules file is meant to be imported by the custom Ant task:
-            com.android.ant.AndroidInitTask
-
-        The following properties are put in place by the importing task:
-            android-jar, android-aidl, aapt, aidl, and dx
-
-        Additionnaly, the task sets up the following classpath reference:
-            android.target.classpath
-        This is used by the compiler task as the boot classpath.
-    -->
-
-    <!-- Custom tasks -->
-    <taskdef name="aaptexec"
-        classname="com.android.ant.AaptExecLoopTask"
-        classpathref="android.antlibs"/>
-
-    <taskdef name="apkbuilder"
-        classname="com.android.ant.ApkBuilderTask"
-        classpathref="android.antlibs"/>
-
-    <!-- Properties -->
-
-    <property name="android-tools" value="${sdk-location}/tools" />
-
-    <!-- Input directories -->
-    <property name="source-folder" value="src" />
-    <property name="gen-folder" value="gen" />
-    <property name="resource-folder" value="res" />
-    <property name="asset-folder" value="assets" />
-    <property name="source-location" value="${basedir}/${source-folder}" />
-
-    <!-- folder for the 3rd party java libraries -->
-    <property name="external-libs-folder" value="libs" />
-
-    <!-- folder for the native libraries -->
-    <property name="native-libs-folder" value="libs" />
-
-    <!-- Output directories -->
-    <property name="gen-folder" value="gen" />
-    <property name="out-folder" value="bin" />
-    <property name="out-classes" value="${out-folder}/classes" />
-    <property name="out-classes-location" value="${basedir}/${out-classes}"/>
-    <!-- out folders for a parent project if this project is an instrumentation project -->
-    <property name="main-out-folder" value="../${out-folder}" />
-    <property name="main-out-classes" value="${main-out-folder}/classes"/>
-
-    <!-- Intermediate files -->
-    <property name="dex-file" value="classes.dex" />
-    <property name="intermediate-dex" value="${out-folder}/${dex-file}" />
-    <!-- dx does not properly support incorrect / or \ based on the platform
-         and Ant cannot convert them because the parameter is not a valid path.
-         Because of this we have to compute different paths depending on the platform. -->
-    <condition property="intermediate-dex-location"
-            value="${basedir}\${intermediate-dex}"
-            else="${basedir}/${intermediate-dex}" >
-        <os family="windows"/>
-    </condition>
-
-    <!-- The final package file to generate -->
-    <property name="out-debug-package" value="${out-folder}/${ant.project.name}-debug.apk"/>
-
-    <!-- Tools -->
-    <condition property="exe" value=".exe" else=""><os family="windows"/></condition>
-    <property name="adb" value="${android-tools}/adb${exe}"/>
-
-    <!-- rules -->
-
-    <!-- Create the output directories if they don't exist yet. -->
-    <target name="dirs">
-        <echo>Creating output directories if needed...</echo>
-        <mkdir dir="${resource-folder}" />
-        <mkdir dir="${external-libs-folder}" />
-        <mkdir dir="${gen-folder}" />
-        <mkdir dir="${out-folder}" />
-        <mkdir dir="${out-classes}" />
-    </target>
-
-    <!-- Generate the R.java file for this project's resources. -->
-    <target name="resource-src" depends="dirs">
-        <echo>Generating R.java / Manifest.java from the resources...</echo>
-        <exec executable="${aapt}" failonerror="true">
-            <arg value="package" />
-            <arg value="-m" />
-            <arg value="-J" />
-            <arg path="${gen-folder}" />
-            <arg value="-M" />
-            <arg path="AndroidManifest.xml" />
-            <arg value="-S" />
-            <arg path="${resource-folder}" />
-            <arg value="-I" />
-            <arg path="${android-jar}" />
-        </exec>
-    </target>
-
-    <!-- Generate java classes from .aidl files. -->
-    <target name="aidl" depends="dirs">
-        <echo>Compiling aidl files into Java classes...</echo>
-        <apply executable="${aidl}" failonerror="true">
-            <arg value="-p${android-aidl}" />
-            <arg value="-I${source-folder}" />
-            <arg value="-o${gen-folder}" />
-            <fileset dir="${source-folder}">
-                <include name="**/*.aidl"/>
-            </fileset>
-        </apply>
-    </target>
-
-    <!-- Compile this project's .java files into .class files. -->
-    <!-- I2P add buildrouter -->
-    <target name="compile" depends="buildrouter, resource-src, aidl">
-        <javac encoding="ascii" target="1.5" debug="true" extdirs=""
-                destdir="${out-classes}"
-                bootclasspathref="android.target.classpath">
-            <src path="${source-folder}" />
-            <src path="${gen-folder}" />
-            <classpath>
-                <fileset dir="${external-libs-folder}" includes="*.jar"/>
-                <pathelement path="${main-out-classes}"/>
-            </classpath>
-         </javac>
-    </target>
-
-    <!-- Convert this project's .class files into .dex files. -->
-    <!-- I2P add hackcleanup -->
-    <target name="dex" depends="compile, hackcleanup">
-        <echo>Converting compiled files and external libraries into ${out-folder}/${dex-file}...</echo>
-        <apply executable="${dx}" failonerror="true" parallel="true">
-            <!-- I2P this is a bad sign that we need this -->
-            <arg value="-JXmx256m" />
-            <arg value="--dex" />
-            <arg value="--output=${intermediate-dex-location}" />
-            <arg path="${out-classes-location}" />
-            <fileset dir="${external-libs-folder}" includes="*.jar"/>
-        </apply>
-    </target>
-
-    <!-- Put the project's resources into the output package file
-         This actually can create multiple resource package in case
-         Some custom apk with specific configuration have been
-         declared in default.properties.
-         -->
-    <target name="package-resources">
-        <echo>Packaging resources</echo>
-        <aaptexec executable="${aapt}"
-                command="package"
-                manifest="AndroidManifest.xml"
-                resources="${resource-folder}"
-                assets="${asset-folder}"
-                androidjar="${android-jar}"
-                outfolder="${out-folder}"
-                basename="${ant.project.name}" />
-    </target>
-
-    <!-- Package the application and sign it with a debug key.
-         This is the default target when building. It is used for debug. -->
-    <target name="debug" depends="dex, package-resources">
-        <apkbuilder
-                outfolder="${out-folder}"
-                basename="${ant.project.name}"
-                signed="true"
-                verbose="false">
-            <file path="${intermediate-dex}" />
-            <sourcefolder path="${source-folder}" />
-            <jarfolder path="${external-libs-folder}" />
-            <nativefolder path="${native-libs-folder}" />
-        </apkbuilder>
-    </target>
-
-    <!-- Package the application without signing it.
-         This allows for the application to be signed later with an official publishing key. -->
-    <target name="release" depends="dex, package-resources">
-        <apkbuilder
-                outfolder="${out-folder}"
-                basename="${ant.project.name}"
-                signed="false"
-                verbose="false">
-            <file path="${intermediate-dex}" />
-            <sourcefolder path="${source-folder}" />
-            <jarfolder path="${external-libs-folder}" />
-            <nativefolder path="${native-libs-folder}" />
-        </apkbuilder>
-        <echo>All generated packages need to be signed with jarsigner before they are published.</echo>
-    </target>
-
-    <!-- Install the package on the default emulator -->
-    <target name="install" depends="debug">
-        <echo>Installing ${out-debug-package} onto default emulator...</echo>
-        <exec executable="${adb}" failonerror="true">
-            <arg value="install" />
-            <arg path="${out-debug-package}" />
-        </exec>
-    </target>
-
-    <target name="reinstall" depends="debug">
-        <echo>Installing ${out-debug-package} onto default emulator...</echo>
-        <exec executable="${adb}" failonerror="true">
-            <arg value="install" />
-            <arg value="-r" />
-            <arg path="${out-debug-package}" />
-        </exec>
-    </target>
-
-    <!-- Uinstall the package from the default emulator -->
-    <target name="uninstall">
-        <echo>Uninstalling ${application-package} from the default emulator...</echo>
-        <exec executable="${adb}" failonerror="true">
-            <arg value="uninstall" />
-            <arg path="${application-package}" />
-        </exec>
-    </target>
-    
-    <target name="help">
-        <!-- displays starts at col 13
-              |13                                                              80| -->
-        <echo>Android Ant Build. Available targets:</echo>
-        <echo>   help:      Displays this help.</echo>
-        <echo>   debug:     Builds the application and sign it with a debug key.</echo>
-        <echo>   release:   Builds the application. The generated apk file must be</echo>
-        <echo>              signed before it is published.</echo>
-        <echo>   install:   Installs the debug package onto a running emulator or</echo>
-        <echo>              device. This can only be used if the application has </echo>
-        <echo>              not yet been installed.</echo>
-        <echo>   reinstall: Installs the debug package on a running emulator or</echo>
-        <echo>              device that already has the application.</echo>
-        <echo>              The signatures must match.</echo>
-        <echo>   uninstall: uninstall the application from a running emulator or</echo>
-        <echo>              device.</echo>
-    </target>
-</project>

android/default.properties

@@ -1,11 +0,0 @@
-# This file is automatically generated by Android Tools.
-# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
-# 
-# This file must be checked in Version Control Systems.
-# 
-# To customize properties used by the Ant build system use,
-# "build.properties", and override values to adapt the script to your
-# project structure.
-
-# Project target.
-target=android-2

android/res/layout/main.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    android:orientation="vertical"
-    android:layout_width="fill_parent"
-    android:layout_height="fill_parent"
-    >
-<TextView  
-    android:layout_width="fill_parent" 
-    android:layout_height="wrap_content" 
-    android:text="Hello World, I2PAndroid"
-    />
-<ImageView  
-    android:layout_width="fill_parent" 
-    android:layout_height="wrap_content" 
-    android:src="@drawable/i2plogo"
-    />
-</LinearLayout>
-

android/res/raw/logger_config

@@ -1,3 +0,0 @@
-logger.defaultLevel=INFO
-logger.record.net.i2p.router.transport.FIFOBandwidthRefiller=ERROR
-logger.record.net.i2p.stat.Rate=ERROR

android/res/raw/router_config

@@ -1,16 +0,0 @@
-# initial router.config
-# temp directory
-i2p.dir.temp=/data/data/net.i2p.router/files/tmp
-i2p.dir.pid=/data/data/net.i2p.router/files/tmp
-# save memory
-prng.buffers=2
-router.decayingBloomFilterM=20
-stat.full=false
-i2np.udp.maxConnections=30
-# no I2CP
-i2p.dummyClientFacade=true
-# for now
-i2np.ntcp.enable=false
-# not on android
-i2np.upnp.enable=false
-routerconsole.geoip.enable=false

android/src/net/i2p/router/I2PAndroid.java

@@ -1,142 +0,0 @@
-package net.i2p.router;
-
-import android.app.Activity;
-import android.content.Context;
-import android.content.res.Resources;
-import android.content.res.Resources.NotFoundException;
-import android.os.Bundle;
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.InputStream;
-import java.io.IOException;
-import java.util.List;
-
-import net.i2p.router.Router;
-import net.i2p.router.RouterLaunch;
-// import net.i2p.util.NativeBigInteger;
-
-public class I2PAndroid extends Activity
-{
-    static Context _context;
-    private static final String DIR = "/data/data/net.i2p.router/files";
-
-    /** Called when the activity is first created. */
-    @Override
-    public void onCreate(Bundle savedInstanceState)
-    {
-        super.onCreate(savedInstanceState);
-        setContentView(R.layout.main);
-
-        _context = this;  // Activity extends Context
-        debugStuff();
-        initialize();
-        // 300ms per run
-        // 5x slower than java on my server and 50x slower than native on my server
-        // NativeBigInteger.main(null);
-    }
-
-    public void onRestart()
-    {
-        System.err.println("onRestart called");
-        super.onRestart();
-    }
-
-    public void onStart()
-    {
-        System.err.println("onStart called");
-        super.onStart();
-        RouterLaunch.main(null);
-        System.err.println("Router.main finished");
-    }
-
-    public void onResume()
-    {
-        System.err.println("onResume called");
-        super.onResume();
-    }
-
-    public void onPause()
-    {
-        System.err.println("onPause called");
-        super.onPause();
-    }
-
-    public void onStop()
-    {
-        System.err.println("onStop called");
-        super.onStop();
-
-        // from routerconsole ContextHelper
-        List contexts = RouterContext.listContexts();
-        if ( (contexts == null) || (contexts.size() <= 0) ) 
-            throw new IllegalStateException("No contexts. This is usually because the router is either starting up or shutting down.");
-        RouterContext ctx = (RouterContext)contexts.get(0);
-
-        // shutdown() doesn't return so use shutdownGracefully()
-        ctx.router().shutdownGracefully(Router.EXIT_HARD);
-        System.err.println("shutdown complete");
-    }
-
-    public void onDestroy()
-    {
-        System.err.println("onDestroy called");
-        super.onDestroy();
-    }
-
-    public static Context getContext() {
-        return _context;
-    }
-
-    private void debugStuff() {
-        System.err.println("java.io.tmpdir" + ": " + System.getProperty("java.io.tmpdir"));
-        System.err.println("java.vendor" + ": " + System.getProperty("java.vendor"));
-        System.err.println("java.version" + ": " + System.getProperty("java.version"));
-        System.err.println("os.arch" + ": " + System.getProperty("os.arch"));
-        System.err.println("os.name" + ": " + System.getProperty("os.name"));
-        System.err.println("os.version" + ": " + System.getProperty("os.version"));
-        System.err.println("user.dir" + ": " + System.getProperty("user.dir"));
-        System.err.println("user.home" + ": " + System.getProperty("user.home"));
-        System.err.println("user.name" + ": " + System.getProperty("user.name"));
-    }
-
-    private void initialize() {
-        // Until we can edit the router.config on the device,
-        // copy it from the resource every time.
-        // File f = new I2PFile("router.config");
-        // if (!f.exists()) {
-            copyResourceToFile(R.raw.router_config, "router.config");
-            copyResourceToFile(R.raw.logger_config, "logger.config");
-            copyResourceToFile(R.raw.blocklist_txt, "blocklist.txt");
-        // }
-
-        // Set up the locations so Router and WorkingDir can find them
-        System.setProperty("i2p.dir.base", DIR);
-        System.setProperty("i2p.dir.config", DIR);
-        System.setProperty("wrapper.logfile", DIR + "/wrapper.log");
-    }
-
-    private void copyResourceToFile(int resID, String f) {
-        InputStream in = null;
-        FileOutputStream out = null;
-
-        System.err.println("Creating file " + f + " from resource");
-        byte buf[] = new byte[4096];
-        try {
-            // Context methods
-            in = getResources().openRawResource(resID);
-            out = openFileOutput(f, 0);
-            
-            int read = 0;
-            while ( (read = in.read(buf)) != -1)
-                out.write(buf, 0, read);
-            
-        } catch (IOException ioe) {
-        } catch (Resources.NotFoundException nfe) {
-        } finally {
-            if (in != null) try { in.close(); } catch (IOException ioe) {}
-            if (out != null) try { out.close(); } catch (IOException ioe) {}
-        }
-    }
-    
-}

android/src/net/i2p/util/LogWriter.java

@@ -1,163 +0,0 @@
-package net.i2p.util;
-
-/*
- * public domain
- *
- */
-
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.List;
-
-/**
- * bridge to android logging
- *
- * @author zzz
- */
-class LogWriter implements Runnable {
-    private final static long CONFIG_READ_ITERVAL = 10 * 1000;
-    private long _lastReadConfig = 0;
-    private long _numBytesInCurrentFile = 0;
-    private OutputStream _currentOut; // = System.out
-    private int _rotationNum = -1;
-    private String _logFilenamePattern;
-    private File _currentFile;
-    private LogManager _manager;
-
-    private boolean _write;
-    
-    private LogWriter() { // nop
-    }
-
-    public LogWriter(LogManager manager) {
-        _manager = manager;
-    }
-
-    public void stopWriting() {
-        _write = false;
-    }
-    
-    public void run() {
-        _write = true;
-        try {
-            while (_write) {
-                flushRecords();
-                rereadConfig();
-            }
-            System.err.println("Done writing");
-        } catch (Exception e) {
-            System.err.println("Error writing the logs: " + e.getMessage());
-            e.printStackTrace();
-        }
-    }
-
-    public void flushRecords() { flushRecords(true); }
-    public void flushRecords(boolean shouldWait) {
-        try {
-            List records = _manager._removeAll();
-            if (records == null) return;
-            for (int i = 0; i < records.size(); i++) {
-                LogRecord rec = (LogRecord) records.get(i);
-                writeRecord(rec);
-            }
-        } catch (Throwable t) {
-            t.printStackTrace();
-        } finally {
-            if (shouldWait) {
-                try { 
-                    synchronized (this) {
-                        this.wait(10*1000); 
-                    }
-                } catch (InterruptedException ie) { // nop
-                }
-            }
-        }
-    }
-
-    public String currentFile() {
-        return _currentFile != null ? _currentFile.getAbsolutePath() : "uninitialized";
-    }
-    
-    private void rereadConfig() {
-        long now = Clock.getInstance().now();
-        if (now - _lastReadConfig > CONFIG_READ_ITERVAL) {
-            _manager.rereadConfig();
-            _lastReadConfig = now;
-        }
-    }
-
-    private void writeRecord(LogRecord rec) {
-        if (rec.getThrowable() == null)
-            log(rec.getPriority(), rec.getSource(), rec.getSourceName(), rec.getThreadName(), rec.getMessage());
-        else
-            log(rec.getPriority(), rec.getSource(), rec.getSourceName(), rec.getThreadName(), rec.getMessage(), rec.getThrowable());
-    }
-
-    public void log(int priority, Class src, String name, String threadName, String msg) {
-            if (src != null) {
-                String tag = src.getName();
-                int dot = tag.lastIndexOf(".");
-                if (dot >= 0)
-                    tag = tag.substring(dot + 1);
-                android.util.Log.println(toAndroidLevel(priority),
-                                         tag,
-                                         '[' + threadName + "] " + msg);
-            } else if (name != null)
-                android.util.Log.println(toAndroidLevel(priority),
-                                         name,
-                                         '[' + threadName + "] " + msg);
-            else
-                android.util.Log.println(toAndroidLevel(priority),
-                                         threadName, msg);
-    }
-
-    public void log(int priority, Class src, String name, String threadName, String msg, Throwable t) {
-            if (src != null) {
-                String tag = src.getName();
-                int dot = tag.lastIndexOf(".");
-                if (dot >= 0)
-                    tag = tag.substring(dot + 1);
-                android.util.Log.println(toAndroidLevel(priority),
-                                         tag,
-                                         '[' + threadName + "] " + msg +
-                                         ' ' + t.toString() + ' ' + android.util.Log.getStackTraceString(t));
-            } else if (name != null)
-                android.util.Log.println(toAndroidLevel(priority),
-                                         name,
-                                         '[' + threadName + "] " + msg +
-                                         ' ' + t.toString() + ' ' + android.util.Log.getStackTraceString(t));
-            else
-                android.util.Log.println(toAndroidLevel(priority),
-                                         threadName,
-                                         msg + ' ' + t.toString() + ' ' + android.util.Log.getStackTraceString(t));
-    }
-
-    private static int toAndroidLevel(int level) {
-        switch (level) {
-        case Log.DEBUG:
-            return android.util.Log.DEBUG;
-        case Log.INFO:
-            return android.util.Log.INFO;
-        case Log.WARN:
-            return android.util.Log.WARN;
-        case Log.ERROR:
-        case Log.CRIT:
-        default:
-            return android.util.Log.ERROR;
-        }
-    }
-
-    private static final String replace(String pattern, int num) {
-        char c[] = pattern.toCharArray();
-        StringBuffer buf = new StringBuffer();
-        for (int i = 0; i < c.length; i++) {
-            if ( (c[i] != '#') && (c[i] != '@') )
-                buf.append(c[i]);
-            else
-                buf.append(num);
-        }
-        return buf.toString();
-    }
-}

app/build.gradle

@@ -0,0 +1,230 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION as String)
+    defaultConfig {
+        versionCode 4745242
+        versionName "$I2P_VERSION"
+        minSdkVersion 9
+        targetSdkVersion Integer.parseInt(project.ANDROID_BUILD_TARGET_SDK_VERSION as String)
+
+        // For Espresso
+        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
+    }
+    signingConfigs {
+        release
+    }
+    buildTypes {
+        release {
+            signingConfig signingConfigs.release
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+        debug {
+            debuggable true
+            applicationIdSuffix '.debug'
+            versionNameSuffix '-DEBUG'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+    lintOptions {
+        abortOnError false
+    }
+    packagingOptions {
+        exclude 'LICENSE.txt'
+    }
+    flavorDimensions 'tier'
+    productFlavors {
+        free {
+            dimension 'tier'
+            applicationId 'net.i2p.android'
+        }
+        donate {
+            dimension 'tier'
+            applicationId 'net.i2p.android.donate'
+        }
+        legacy {
+            dimension 'tier'
+            applicationId 'net.i2p.android.router'
+        }
+    }
+}
+
+dependencies {
+    // Local dependencies
+    implementation project(':lib:client')
+    implementation project(':lib:helper')
+    implementation project(path: ':routerjars', configuration: 'routerjars')
+
+    // Android Support Repository dependencies
+    def supportVersion = '25.3.1'
+    implementation "com.android.support:support-v4:$supportVersion"
+    implementation "com.android.support:appcompat-v7:$supportVersion"
+    implementation "com.android.support:preference-v7:$supportVersion"
+    implementation "com.android.support:preference-v14:$supportVersion"
+    implementation "com.android.support:recyclerview-v7:$supportVersion"
+
+    // Remote dependencies
+    implementation 'com.androidplot:androidplot-core:1.4.1'
+    implementation 'com.eowise:recyclerview-stickyheaders:0.5.2@aar'
+    implementation 'com.inkapplications.viewpageindicator:library:2.4.4'
+    implementation 'com.pnikosis:materialish-progress:1.7'
+    implementation "net.i2p:router:$I2P_VERSION"
+    implementation 'net.i2p.android.ext:floatingactionbutton:1.10.1'
+    implementation 'org.sufficientlysecure:html-textview:3.1'
+
+    // Testing-only dependencies
+    androidTestImplementation('com.android.support.test.espresso:espresso-core:2.2.2') {
+        exclude group: 'com.android.support', module: 'support-annotations'
+    }
+}
+
+project.ext.i2pbase = "../i2p.i2p"
+def Properties props = new Properties()
+def propFile = new File(project(':routerjars').projectDir, 'local.properties')
+
+if (propFile.canRead()) {
+    props.load(new FileInputStream(propFile))
+
+    if (props != null &&
+            props.containsKey('i2psrc')) {
+        i2pbase = props['i2psrc']
+    } else {
+        println 'local.properties found but some entries are missing'
+    }
+} else {
+    println 'local.properties not found'
+}
+
+task certificatesZip(type: Zip) {
+    archiveName = 'certificates_zip'
+    from files('' + i2pbase + '/installer/resources/certificates')
+}
+task copyI2PResources(type: Copy) {
+    // Force this to always run: Copy only detects source changes, not if missing in destination
+    outputs.upToDateWhen { false }
+    into 'src/main/res'
+    into('drawable') {
+        from file(i2pbase + '/installer/resources/themes/console/images/i2plogo.png')
+    }
+    into('raw') {
+        from(i2pbase + '/installer/resources/blocklist.txt') { rename { 'blocklist_txt' } }
+        from(i2pbase + '/installer/resources/hosts.txt') { rename { 'hosts_txt' } }
+        from(i2pbase + '/installer/resources/proxy') {
+            include { elem ->
+                elem.name.endsWith('.ht')
+            }
+            rename { String name ->
+                name.toLowerCase(Locale.US).replace('-', '_').replace('.', '_')
+            }
+            filter { String line ->
+                // Remove links to routerconsole
+                def m = line =~ /127.0.0.1:7657/
+                if (m.getCount()) {
+                    // Links around content
+                    line = line.replaceAll(/<a href="http:\/\/127.0.0.1:7657[^>]*>(.+?)<\/a>/) { fullmatch, content ->
+                        content
+                    }
+                    // Links in translation substitutions
+                    line = line.replaceAll(/"<a href=\\"http:\/\/127.0.0.1:7657[^>]*>", "<\/a>"/, '"", ""')
+                }
+                // Remove "Configuration - Help - Addressbook" heading
+                def n = line =~ /Configuration.+Help.+Addressbook/
+                if (n.getCount())
+                    ""
+                else
+                    line
+            }
+        }
+        from('../LICENSE.txt') { rename { 'license_app_txt' } }
+        from('../licenses/LICENSE-Apache2.0.txt') { rename { 'license_apache20_txt' } }
+        from(i2pbase + '/licenses') {
+            include { elem ->
+                elem.name in [
+                        'LICENSE-ElGamalDSA.txt',
+                        'LICENSE-SHA256.txt',
+                        'LICENSE-BSD.txt',
+                        'LICENSE-SNTP.txt',
+                        'LICENSE-LGPLv2.1.txt',
+                        'LICENSE-InstallCert.txt',
+                        'LICENSE-BlockFile.txt',
+                        'LICENSE-GPLv2.txt',
+                        'LICENSE-GPLv3.txt',
+                        'LICENSE-LGPLv3.txt',
+                        'LICENSE-FatCowIcons.txt',
+                        'LICENSE-Addressbook.txt',
+                ]
+            }
+            rename { String name ->
+                name.toLowerCase(Locale.US).replace('-', '_').replace('.', '_')
+            }
+        }
+        from certificatesZip
+    }
+}
+// For peers WebView
+task copyI2PAssets(type: Copy) {
+    // Force this to always run: Copy only detects source changes, not if missing in destination
+    outputs.upToDateWhen { false }
+    into 'src/main/assets/themes/console'
+    into('images') {
+        from file(i2pbase + '/installer/resources/themes/console/images/i2plogo.png')
+        from file(i2pbase + '/installer/resources/themes/console/images/inbound.png')
+        from file(i2pbase + '/installer/resources/themes/console/images/outbound.png')
+    }
+    into('light') {
+        from file(i2pbase + '/installer/resources/themes/console/light/console.css')
+    }
+    into('light/images') {
+        from file(i2pbase + '/installer/resources/themes/console/light/images/header.png')
+    }
+}
+
+preBuild.dependsOn copyI2PResources
+preBuild.dependsOn copyI2PAssets
+
+task cleanI2PResources(type: Delete) {
+    delete file('src/main/res/drawable/i2plogo.png')
+    delete fileTree('src/main/res/raw') {
+        include 'blocklist_txt'
+        include 'hosts_txt'
+        include '*_ht'
+        include 'license_*'
+        include 'certificates_zip'
+    }
+}
+task cleanI2PAssets(type: Delete) {
+    delete fileTree('src/main/assets/themes/console/images')
+    delete file('src/main/assets/themes/console/light/console.css')
+    delete file('src/main/assets/themes/console/light/images/header.png')
+}
+
+clean.dependsOn cleanI2PResources
+clean.dependsOn cleanI2PAssets
+
+props = new Properties()
+propFile = new File(project.rootDir, 'signing.properties')
+
+if (propFile.canRead()) {
+    props.load(new FileInputStream(propFile))
+
+    if (props != null &&
+            props.containsKey('STORE_FILE') &&
+            props.containsKey('STORE_PASSWORD') &&
+            props.containsKey('KEY_ALIAS') &&
+            props.containsKey('KEY_PASSWORD')) {
+        android.signingConfigs.release.storeFile = file(props['STORE_FILE'])
+        android.signingConfigs.release.storePassword = props['STORE_PASSWORD']
+        android.signingConfigs.release.keyAlias = props['KEY_ALIAS']
+        android.signingConfigs.release.keyPassword = props['KEY_PASSWORD']
+    } else {
+        println 'signing.properties found but some entries are missing'
+        android.buildTypes.release.signingConfig = null
+    }
+} else {
+    println 'signing.properties not found'
+    android.buildTypes.release.signingConfig = null
+}

app/proguard-rules.pro

@@ -0,0 +1,29 @@
+# Add project specific ProGuard rules here.
+# You can edit the include path and order by changing the proguardFiles
+# directive in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+-dontobfuscate
+-dontoptimize
+-dontpreverify
+-dontshrink
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+
+# Workaround for Samsung Android 4.2 bug
+# https://code.google.com/p/android/issues/detail?id=78377
+# https://code.google.com/p/android/issues/detail?id=78377#c188
+# https://code.google.com/p/android/issues/detail?id=78377#c302
+-keepattributes **
+-keep class !android.support.v7.view.menu.**,** {*;}
+-dontwarn **
+-dontnote **

app/src/androidTest/java/net/i2p/android/I2PActivityTest.java

@@ -0,0 +1,109 @@
+package net.i2p.android;
+
+import android.test.ActivityInstrumentationTestCase2;
+
+import net.i2p.android.router.R;
+
+import static android.support.test.espresso.Espresso.closeSoftKeyboard;
+import static android.support.test.espresso.Espresso.onView;
+import static android.support.test.espresso.Espresso.openActionBarOverflowOrOptionsMenu;
+import static android.support.test.espresso.Espresso.pressBack;
+import static android.support.test.espresso.action.ViewActions.click;
+import static android.support.test.espresso.action.ViewActions.swipeLeft;
+import static android.support.test.espresso.assertion.ViewAssertions.doesNotExist;
+import static android.support.test.espresso.assertion.ViewAssertions.matches;
+import static android.support.test.espresso.matcher.ViewMatchers.hasSibling;
+import static android.support.test.espresso.matcher.ViewMatchers.isDescendantOfA;
+import static android.support.test.espresso.matcher.ViewMatchers.isDisplayed;
+import static android.support.test.espresso.matcher.ViewMatchers.withId;
+import static android.support.test.espresso.matcher.ViewMatchers.withParent;
+import static android.support.test.espresso.matcher.ViewMatchers.withText;
+import static org.hamcrest.Matchers.allOf;
+import static org.hamcrest.Matchers.not;
+
+public class I2PActivityTest extends ActivityInstrumentationTestCase2<I2PActivity> {
+    public I2PActivityTest() {
+        super(I2PActivity.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        // For each test method invocation, the Activity will not actually be created
+        // until the first time this method is called.
+        getActivity();
+    }
+
+    public void testMainTabs() {
+        onView(withId(R.id.router_onoff_button)).check(matches(isDisplayed()));
+
+        // Press "Tunnels" tab
+        onView(allOf(withText(R.string.label_tunnels),
+                not(isDescendantOfA(withId(R.id.main_scrollview))))).perform(click());
+        onView(withId(R.id.router_onoff_button)).check(matches(not(isDisplayed())));
+        onView(withText(R.string.label_i2ptunnel_client)).check(matches(isDisplayed()));
+
+        // Press "Addresses" tab
+        onView(withText(R.string.label_addresses)).perform(click());
+        onView(withText(R.string.label_i2ptunnel_client)).check(matches(not(isDisplayed())));
+        onView(withText(R.string.label_router)).check(matches(isDisplayed()));
+
+        // Press "Console" tab
+        onView(withText(R.string.label_console)).perform(click());
+        // Addressbook fragment should have been destroyed
+        onView(withText(R.string.label_router)).check(doesNotExist());
+        onView(withId(R.id.router_onoff_button)).check(matches(isDisplayed()));
+    }
+
+    public void testMainSwipe() {
+        onView(withId(R.id.router_onoff_button)).check(matches(isDisplayed()));
+
+        onView(allOf(withId(R.id.pager), withParent(hasSibling(withId(R.id.main_toolbar))))).perform(swipeLeft());
+        onView(withId(R.id.router_onoff_button)).check(matches(not(isDisplayed())));
+        onView(withText(R.string.label_i2ptunnel_client)).check(matches(isDisplayed()));
+
+        onView(allOf(withId(R.id.pager), withParent(hasSibling(withId(R.id.main_toolbar))))).perform(swipeLeft());
+        // TODO: test tunnels ViewPager
+        onView(allOf(withId(R.id.pager), withParent(hasSibling(withId(R.id.main_toolbar))))).perform(swipeLeft());
+        onView(withText(R.string.label_i2ptunnel_client)).check(matches(not(isDisplayed())));
+        onView(withText(R.string.label_router)).check(matches(isDisplayed()));
+        // TODO: test addressbook ViewPager
+    }
+
+    public void testSettingsNavigation() {
+        // Open settings menu
+        openActionBarOverflowOrOptionsMenu(getActivity());
+        onView(withText(R.string.menu_settings)).perform(click());
+
+        // Open bandwidth page
+        onView(withText(R.string.settings_label_bandwidth_net)).perform(click());
+        onView(withText(R.string.settings_label_startOnBoot)).check(matches(isDisplayed()));
+        pressBack();
+
+        // Open graphs page
+        onView(withText(R.string.label_graphs)).perform(click());
+        onView(withText(R.string.router_not_running)).check(matches(isDisplayed()));
+        pressBack();
+
+        // Open logging page
+        onView(withText(R.string.settings_label_logging)).perform(click());
+        onView(withText(R.string.settings_label_default_log_level)).check(matches(isDisplayed()));
+        pressBack();
+
+        // Open addressbook page
+        onView(withText(R.string.label_addressbook)).perform(click());
+        onView(withText("Subscriptions")).check(matches(isDisplayed()));
+        closeSoftKeyboard();
+        pressBack();
+
+        // Open graphs page
+        onView(withText(R.string.settings_label_advanced)).perform(click());
+        onView(withText(R.string.settings_label_transports)).check(matches(isDisplayed()));
+        pressBack();
+
+        // Check back exits settings
+        onView(withText(R.string.settings_label_advanced)).check(matches(isDisplayed()));
+        pressBack();
+        onView(withText(R.string.settings_label_advanced)).check(doesNotExist());
+    }
+}

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

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+    <string name="app_name" translatable="false">I2P DEBUG</string>
+</resources>

app/src/donate/res/xml/settings_headers.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<preference-headers xmlns:android="http://schemas.android.com/apk/res/android">
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/settings_label_bandwidth_net">
+        <extra
+            android:name="settings"
+            android:value="net" />
+    </header>
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/label_graphs">
+        <extra
+            android:name="settings"
+            android:value="graphs" />
+    </header>
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/settings_label_logging">
+        <extra
+            android:name="settings"
+            android:value="logging" />
+    </header>
+    <header
+        android:title="@string/label_addressbook">
+        <intent
+            android:targetPackage="net.i2p.android.donate"
+            android:targetClass="net.i2p.android.router.addressbook.AddressbookSettingsActivity" />
+    </header>
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/settings_label_advanced">
+        <extra
+            android:name="settings"
+            android:value="advanced" />
+    </header>
+</preference-headers>

app/src/donate/res/xml/settings_headers_legacy.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android" >
+    <Preference android:title="@string/settings_label_bandwidth_net">
+        <intent
+            android:targetPackage="net.i2p.android.donate"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_NET" />
+    </Preference>
+    <Preference android:title="@string/label_graphs">
+        <intent
+            android:targetPackage="net.i2p.android.donate"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_GRAPHS" />
+    </Preference>
+    <Preference android:title="@string/settings_label_logging">
+        <intent
+            android:targetPackage="net.i2p.android.donate"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_LOGGING" />
+    </Preference>
+    <Preference android:title="@string/label_addressbook">
+        <intent
+            android:targetPackage="net.i2p.android.donate"
+            android:targetClass="net.i2p.android.router.addressbook.AddressbookSettingsActivity" />
+    </Preference>
+    <Preference android:title="@string/settings_label_advanced">
+        <intent
+            android:targetPackage="net.i2p.android.donate"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_ADVANCED" />
+    </Preference>
+</PreferenceScreen>

app/src/legacy/res/xml/settings_headers.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="utf-8"?>
+<preference-headers xmlns:android="http://schemas.android.com/apk/res/android">
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/settings_label_bandwidth_net">
+        <extra
+            android:name="settings"
+            android:value="net" />
+    </header>
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/label_graphs">
+        <extra
+            android:name="settings"
+            android:value="graphs" />
+    </header>
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/settings_label_logging">
+        <extra
+            android:name="settings"
+            android:value="logging" />
+    </header>
+    <header
+        android:title="@string/label_addressbook">
+        <intent
+            android:targetPackage="net.i2p.android.router"
+            android:targetClass="net.i2p.android.router.addressbook.AddressbookSettingsActivity" />
+    </header>
+    <header
+        android:fragment="net.i2p.android.router.SettingsActivity$SettingsFragment"
+        android:title="@string/settings_label_advanced">
+        <extra
+            android:name="settings"
+            android:value="advanced" />
+    </header>
+</preference-headers>

app/src/legacy/res/xml/settings_headers_legacy.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="utf-8"?>
+<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android" >
+    <Preference android:title="@string/settings_label_bandwidth_net">
+        <intent
+            android:targetPackage="net.i2p.android.router"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_NET" />
+    </Preference>
+    <Preference android:title="@string/label_graphs">
+        <intent
+            android:targetPackage="net.i2p.android.router"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_GRAPHS" />
+    </Preference>
+    <Preference android:title="@string/settings_label_logging">
+        <intent
+            android:targetPackage="net.i2p.android.router"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_LOGGING" />
+    </Preference>
+    <Preference android:title="@string/label_addressbook">
+        <intent
+            android:targetPackage="net.i2p.android.router"
+            android:targetClass="net.i2p.android.router.addressbook.AddressbookSettingsActivity" />
+    </Preference>
+    <Preference android:title="@string/settings_label_advanced">
+        <intent
+            android:targetPackage="net.i2p.android.router"
+            android:targetClass="net.i2p.android.router.SettingsActivity"
+            android:action="net.i2p.android.router.PREFS_ADVANCED" />
+    </Preference>
+</PreferenceScreen>

app/src/main/AndroidManifest.xml

@@ -0,0 +1,209 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="net.i2p.android.router"
+    android:installLocation="auto">
+
+    <uses-sdk xmlns:tools="http://schemas.android.com/tools"
+        tools:overrideLibrary="android.support.v14.preference" />
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+
+    <application
+        android:icon="@drawable/ic_launcher_itoopie"
+        android:label="@string/app_name"
+        android:theme="@style/Theme.I2P">
+        <service
+            android:name=".service.RouterService"
+            android:icon="@drawable/ic_launcher_itoopie"
+            android:label="@string/app_name">
+            <intent-filter>
+                <action android:name="net.i2p.android.router.service.IRouterState" />
+            </intent-filter>
+        </service>
+        <provider
+            android:name=".provider.CacheProvider"
+            android:authorities="${applicationId}.provider" />
+        <receiver android:name=".receiver.OnBootReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+
+        <activity
+            android:name="net.i2p.android.I2PActivity"
+            android:icon="@drawable/ic_launcher_itoopie"
+            android:label="@string/app_name"
+            android:launchMode="singleTop">
+            <!-- Console filters -->
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="net.i2p.android.router.START_I2P" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+
+            <!-- Addressbook filters -->
+            <intent-filter>
+                <action android:name="android.intent.action.SEARCH" />
+            </intent-filter>
+            <intent-filter>
+                <action android:name="android.intent.action.PICK" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+
+            <meta-data
+                android:name="android.app.searchable"
+                android:resource="@xml/searchable_addressbook" />
+        </activity>
+        <activity
+            android:name=".NewsActivity"
+            android:configChanges="orientation|keyboardHidden"
+            android:label="@string/label_news"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name="net.i2p.android.help.HelpActivity"
+            android:label="@string/menu_help"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name="net.i2p.android.help.BrowserConfigActivity"
+            android:label="@string/label_browser_configuration"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".LicenseActivity"
+            android:label="@string/label_licenses"
+            android:parentActivityName="net.i2p.android.help.HelpActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.help.HelpActivity" />
+        </activity>
+        <activity
+            android:name=".web.WebActivity"
+            android:configChanges="orientation|keyboardHidden"
+            android:label="I2P Web Browser">
+            <!-- Disabled, this browser is not very secure
+            Temporarily enabled until an alternative browser is ready -->
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.BROWSABLE" />
+
+                <data
+                    android:host="*.i2p"
+                    android:scheme="http" />
+            </intent-filter>
+        </activity>
+        <activity
+            android:name=".SettingsActivity"
+            android:label="@string/menu_settings"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".addressbook.AddressbookSettingsActivity"
+            android:label="@string/label_addressbook"
+            android:launchMode="singleTop"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".addressbook.AddressbookAddWizardActivity"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name="net.i2p.android.i2ptunnel.TunnelDetailActivity"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name="net.i2p.android.i2ptunnel.preferences.EditTunnelActivity"
+            android:label="@string/edit_tunnel"
+            android:parentActivityName="net.i2p.android.i2ptunnel.TunnelDetailActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.i2ptunnel.TunnelDetailActivity" />
+        </activity>
+        <activity
+            android:name="net.i2p.android.i2ptunnel.TunnelWizardActivity"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".log.LogActivity"
+            android:label="@string/label_logs"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".log.LogDetailActivity"
+            android:label="@string/log_entry"
+            android:parentActivityName=".log.LogActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.router.log.LogActivity" />
+        </activity>
+        <activity
+            android:name=".stats.RateGraphActivity"
+            android:label="@string/label_graphs"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".stats.PeersActivity"
+            android:configChanges="orientation|keyboardHidden"
+            android:label="@string/label_peers_status"
+            android:launchMode="singleTop"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".netdb.NetDbActivity"
+            android:label="NetDB"
+            android:parentActivityName="net.i2p.android.I2PActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.I2PActivity" />
+        </activity>
+        <activity
+            android:name=".netdb.NetDbDetailActivity"
+            android:label="NetDB Detail"
+            android:parentActivityName=".netdb.NetDbActivity">
+            <meta-data
+                android:name="android.support.PARENT_ACTIVITY"
+                android:value="net.i2p.android.router.netdb.NetDbActivity" />
+        </activity>
+    </application>
+</manifest>

app/src/main/java/android/support/v4/view/CustomViewPager.java

@@ -0,0 +1,140 @@
+package android.support.v4.view;
+
+import android.content.Context;
+import android.os.Parcel;
+import android.os.Parcelable;
+import android.support.v4.os.ParcelableCompat;
+import android.support.v4.os.ParcelableCompatCreatorCallbacks;
+import android.util.AttributeSet;
+import android.view.MotionEvent;
+import android.widget.Toast;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+
+public class CustomViewPager extends ViewPager {
+    private boolean mEnabled;
+    private int mFixedPage;
+    private int mFixedPageString;
+
+    public CustomViewPager(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        mEnabled = false;
+        mFixedPage = -1;
+        mFixedPageString = 0;
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        return mEnabled && mFixedPage < 0 && super.onTouchEvent(event);
+    }
+
+    @Override
+    public boolean onInterceptTouchEvent(MotionEvent event) {
+        return mEnabled && mFixedPage < 0 && super.onInterceptTouchEvent(event);
+    }
+
+    @Override
+    public void setCurrentItem(int item) {
+        if ((mEnabled && (mFixedPage < 0 || item == mFixedPage))
+                || (!mEnabled && item == 0))
+            super.setCurrentItem(item);
+        else if (!mEnabled)
+            Toast.makeText(getContext(), Util.getRouterContext() == null ?
+                    R.string.router_not_running : R.string.router_shutting_down,
+                    Toast.LENGTH_SHORT).show();
+        else if (mFixedPageString > 0)
+            Toast.makeText(getContext(), getContext().getString(mFixedPageString),
+                    Toast.LENGTH_SHORT).show();
+    }
+
+    public void setPagingEnabled(boolean enabled) {
+        mEnabled = enabled;
+        updatePagingState();
+    }
+
+    public void setFixedPage(int page, int res) {
+        mFixedPage = page;
+        mFixedPageString = res;
+        updatePagingState();
+    }
+
+    public void updatePagingState() {
+        if (mEnabled) {
+            if (mFixedPage >= 0 && getCurrentItem() != mFixedPage)
+                setCurrentItem(mFixedPage);
+
+        } else if (getCurrentItem() != 0)
+            setCurrentItem(0);
+    }
+
+    public static class SavedState extends ViewPager.SavedState {
+        boolean enabled;
+        int fixedPage;
+        int fixedPageString;
+
+        public SavedState(Parcelable superState) {
+            super(superState);
+        }
+
+        @Override
+        public void writeToParcel(Parcel out, int flags) {
+            super.writeToParcel(out, flags);
+            out.writeInt(enabled ? 1 : 0);
+            out.writeInt(fixedPage);
+            out.writeInt(fixedPageString);
+        }
+
+        @Override
+        public String toString() {
+            return "CustomViewPager.SavedState{"
+                    + Integer.toHexString(System.identityHashCode(this))
+                    + " enabled=" + enabled + " fixedPage=" + fixedPage + "}";
+        }
+
+        public static final Parcelable.Creator<SavedState> CREATOR
+                = ParcelableCompat.newCreator(new ParcelableCompatCreatorCallbacks<SavedState>() {
+            @Override
+            public SavedState createFromParcel(Parcel in, ClassLoader loader) {
+                return new SavedState(in, loader);
+            }
+
+            @Override
+            public SavedState[] newArray(int size) {
+                return new SavedState[size];
+            }
+        });
+
+        SavedState(Parcel in, ClassLoader loader) {
+            super(in, loader);
+            enabled = in.readInt() != 0;
+            fixedPage = in.readInt();
+            fixedPageString = in.readInt();
+        }
+    }
+
+    @Override
+    public Parcelable onSaveInstanceState() {
+        Parcelable superState = super.onSaveInstanceState();
+        SavedState ss = new SavedState(superState);
+        ss.enabled = mEnabled;
+        ss.fixedPage = mFixedPage;
+        ss.fixedPageString = mFixedPageString;
+        return ss;
+    }
+
+    @Override
+    public void onRestoreInstanceState(Parcelable state) {
+        if (!(state instanceof SavedState)) {
+            super.onRestoreInstanceState(state);
+            return;
+        }
+
+        SavedState ss = (SavedState)state;
+        super.onRestoreInstanceState(ss.getSuperState());
+
+        mEnabled = ss.enabled;
+        mFixedPage = ss.fixedPage;
+        mFixedPageString = ss.fixedPageString;
+    }
+}

app/src/main/java/com/pavelsikun/seekbarpreference/MaterialSeekBarController.java

@@ -0,0 +1,161 @@
+package com.pavelsikun.seekbarpreference;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v7.preference.Preference;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.View;
+import android.widget.SeekBar;
+import android.widget.TextView;
+
+import net.i2p.android.router.R;
+
+/**
+ * Based on MaterialSeekBarController created by mrbimc on 30.09.15.
+ */
+public class MaterialSeekBarController implements SeekBar.OnSeekBarChangeListener {
+
+    private final String TAG = getClass().getName();
+
+    public static final int DEFAULT_CURRENT_VALUE = 50;
+    private static final int DEFAULT_MAX_VALUE = 100;
+    private static final String DEFAULT_MEASUREMENT_UNIT = "";
+
+    private int mMaxValue;
+    private int mMaxDigits;
+    private int mCurrentValue;
+    private String mMeasurementUnit;
+
+    private SeekBar mSeekBar;
+    private TextView mSeekBarValue;
+    private TextView mMeasurementUnitView;
+
+    private Context mContext;
+
+    private Persistable mPersistable;
+
+    public MaterialSeekBarController(Context context, AttributeSet attrs, Persistable persistable) {
+        mContext = context;
+        mPersistable = persistable;
+        init(attrs, null);
+    }
+
+    private void init(AttributeSet attrs, View view) {
+        setValuesFromXml(attrs);
+        if(view != null) onBindView(view);
+    }
+    private void setValuesFromXml(@Nullable AttributeSet attrs) {
+        if (attrs == null) {
+            mCurrentValue = DEFAULT_CURRENT_VALUE;
+            mMaxValue = DEFAULT_MAX_VALUE;
+            mMeasurementUnit = DEFAULT_MEASUREMENT_UNIT;
+        } else {
+            TypedArray a = mContext.obtainStyledAttributes(attrs, R.styleable.SeekBarPreference);
+            try {
+                mMaxValue = a.getInt(R.styleable.SeekBarPreference_msbp_maxValue, DEFAULT_MAX_VALUE);
+                mCurrentValue = a.getInt(R.styleable.SeekBarPreference_msbp_defaultValue, DEFAULT_CURRENT_VALUE);
+
+                if(mCurrentValue > mMaxValue) mCurrentValue = mMaxValue / 2;
+                mMeasurementUnit = a.getString(R.styleable.SeekBarPreference_msbp_measurementUnit);
+                if (mMeasurementUnit == null)
+                    mMeasurementUnit = DEFAULT_MEASUREMENT_UNIT;
+            } finally {
+                a.recycle();
+            }
+        }
+        mMaxDigits = (int) Math.log10(mMaxValue) + 1;
+    }
+
+    public void onBindView(@NonNull View view) {
+
+        mSeekBar = (SeekBar) view.findViewById(R.id.seekbar);
+        mSeekBar.setMax(mMaxValue);
+        mSeekBar.setOnSeekBarChangeListener(this);
+
+        mSeekBarValue = (TextView) view.findViewById(R.id.seekbar_value);
+        setPaddedValue(mCurrentValue);
+
+        mMeasurementUnitView = (TextView) view.findViewById(R.id.measurement_unit);
+        mMeasurementUnitView.setText(mMeasurementUnit);
+
+        mSeekBar.setProgress(mCurrentValue);
+
+        if (!view.isEnabled()) {
+            mSeekBar.setEnabled(false);
+            mSeekBarValue.setEnabled(false);
+        }
+    }
+
+    protected void onSetInitialValue(boolean restoreValue, @NonNull Object defaultValue) {
+        mCurrentValue = mMaxValue / 2;
+        try {
+            mCurrentValue = (Integer) defaultValue;
+        } catch (Exception ex) {
+            Log.e(TAG, "Invalid default value: " + defaultValue.toString());
+        }
+    }
+
+    public void setEnabled(boolean enabled) {
+        if (mSeekBar != null) mSeekBar.setEnabled(enabled);
+        if (mSeekBarValue != null) mSeekBarValue.setEnabled(enabled);
+    }
+
+    public void onDependencyChanged(Preference dependency, boolean disableDependent) {
+        if (mSeekBar != null) mSeekBar.setEnabled(!disableDependent);
+        if (mSeekBarValue != null) mSeekBarValue.setEnabled(!disableDependent);
+    }
+
+    //SeekBarListener:
+    @Override
+    public void onProgressChanged(@NonNull SeekBar seekBar, int progress, boolean fromUser) {
+        mCurrentValue = progress;
+        setPaddedValue(progress);
+    }
+
+    @Override
+    public void onStartTrackingTouch(SeekBar seekBar) {
+    }
+
+    @Override
+    public void onStopTrackingTouch(@NonNull SeekBar seekBar) {
+        setCurrentValue(mCurrentValue);
+    }
+
+    private void setPaddedValue(int value) {
+        mSeekBarValue.setText(String.format("%0" + mMaxDigits +"d", value));
+    }
+
+
+    //public methods for manipulating this widget from java:
+    public void setCurrentValue(int value) {
+        mCurrentValue = value;
+        if (mPersistable != null) mPersistable.onPersist(value);
+    }
+
+    public int getCurrentValue() {
+        return mCurrentValue;
+    }
+
+
+    public void setMaxValue(int maxValue) {
+        mMaxValue = maxValue;
+        if (mSeekBar != null) mSeekBar.setMax(mMaxValue);
+    }
+
+    public int getMaxValue() {
+        return mMaxValue;
+    }
+
+
+    public void setMeasurementUnit(String measurementUnit) {
+        mMeasurementUnit = measurementUnit;
+        if (mMeasurementUnitView != null) mMeasurementUnitView.setText(mMeasurementUnit);
+    }
+
+    public String getMeasurementUnit() {
+        return mMeasurementUnit;
+    }
+}

app/src/main/java/com/pavelsikun/seekbarpreference/Persistable.java

@@ -0,0 +1,8 @@
+package com.pavelsikun.seekbarpreference;
+
+/**
+ * Created by mrbimc on 04.10.15.
+ */
+public interface Persistable {
+    void onPersist(int value);
+}

app/src/main/java/com/pavelsikun/seekbarpreference/SeekBarPreference.java

@@ -0,0 +1,104 @@
+package com.pavelsikun.seekbarpreference;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.os.Build;
+import android.support.annotation.NonNull;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceViewHolder;
+import android.util.AttributeSet;
+
+import net.i2p.android.router.R;
+
+public class SeekBarPreference extends Preference implements Persistable {
+
+    private MaterialSeekBarController mController;
+
+    public SeekBarPreference(Context context) {
+        super(context);
+        init(null);
+    }
+
+    public SeekBarPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(attrs);
+    }
+
+    public SeekBarPreference(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(attrs);
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public SeekBarPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+        init(attrs);
+    }
+
+    private void init(AttributeSet attrs) {
+        setLayoutResource(R.layout.seekbar_preference);
+        mController = new MaterialSeekBarController(getContext(), attrs, this);
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull PreferenceViewHolder viewHolder) {
+        super.onBindViewHolder(viewHolder);
+        mController.onBindView(viewHolder.itemView);
+    }
+
+    @Override
+    protected Object onGetDefaultValue(@NonNull TypedArray ta, int index) {
+        if(mController != null) return ta.getInt(index, mController.getCurrentValue());
+        else return null;
+    }
+
+    @Override
+    protected void onSetInitialValue(boolean restoreValue, @NonNull Object defaultValue) {
+        int average = mController.getMaxValue() / 2;
+        if(restoreValue) mController.setCurrentValue(getPersistedInt(average));
+        else mController.onSetInitialValue(restoreValue, defaultValue);
+    }
+
+    @Override
+    public void setEnabled(boolean enabled) {
+        super.setEnabled(enabled);
+        mController.setEnabled(enabled);
+    }
+
+    @Override
+    public void onDependencyChanged(Preference dependency, boolean disableDependent) {
+        super.onDependencyChanged(dependency, disableDependent);
+        mController.onDependencyChanged(dependency, disableDependent);
+    }
+
+    @Override
+    public void onPersist(int value) {
+        persistInt(value);
+        notifyChanged();
+    }
+
+    public String getMeasurementUnit() {
+        return mController.getMeasurementUnit();
+    }
+
+    public void setMeasurementUnit(String measurementUnit) {
+        mController.setMeasurementUnit(measurementUnit);
+    }
+
+    public int getMaxValue() {
+        return mController.getMaxValue();
+    }
+
+    public void setMaxValue(int maxValue) {
+        mController.setMaxValue(maxValue);
+    }
+
+    public int getCurrentValue() {
+        return mController.getCurrentValue();
+    }
+
+    public void setCurrentValue(int value) {
+        mController.setCurrentValue(value);
+    }
+}

app/src/main/java/net/i2p/android/I2PActivity.java

@@ -0,0 +1,364 @@
+package net.i2p.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v7.widget.Toolbar;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import net.i2p.android.help.HelpActivity;
+import net.i2p.android.i2ptunnel.TunnelsContainer;
+import net.i2p.android.router.ConsoleContainer;
+import net.i2p.android.router.MainFragment;
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+import net.i2p.android.router.addressbook.AddressbookContainer;
+import net.i2p.android.router.service.RouterService;
+import net.i2p.android.router.service.State;
+import net.i2p.android.router.util.Connectivity;
+import net.i2p.android.router.util.Util;
+import net.i2p.android.util.MemoryFragmentPagerAdapter;
+import android.support.v4.view.CustomViewPager;
+import net.i2p.android.widget.SlidingTabLayout;
+import net.i2p.router.RouterContext;
+
+import java.io.File;
+
+/**
+ * The main activity of the app. Contains a ViewPager that holds the three main
+ * views:
+ * <ul>
+ * <li>The console</li>
+ * <li>The addressbook</li>
+ * <li>The tunnel manager</li>
+ * </ul>
+ */
+public class I2PActivity extends I2PActivityBase implements
+        MainFragment.RouterControlListener {
+    CustomViewPager mViewPager;
+    ViewPagerAdapter mViewPagerAdapter;
+    SlidingTabLayout mSlidingTabLayout;
+
+    private boolean mAutoStartFromIntent = false;
+    private boolean _keep = true;
+    private boolean _startPressed = false;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_viewpager);
+
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+
+        mViewPager = (CustomViewPager) findViewById(R.id.pager);
+        mViewPagerAdapter = new ViewPagerAdapter(this, getSupportFragmentManager());
+        mViewPager.setAdapter(mViewPagerAdapter);
+
+        mSlidingTabLayout = (SlidingTabLayout) findViewById(R.id.sliding_tabs);
+        // Center the tabs in the layout
+        mSlidingTabLayout.setDistributeEvenly(true);
+        // Customize tab color
+        mSlidingTabLayout.setCustomTabColorizer(new SlidingTabLayout.TabColorizer() {
+            @Override
+            public int getIndicatorColor(int position) {
+                return getResources().getColor(R.color.accent);
+            }
+        });
+        // Give the SlidingTabLayout the ViewPager
+        mSlidingTabLayout.setViewPager(mViewPager);
+
+        _keep = true;
+    }
+
+    public static class ViewPagerAdapter extends MemoryFragmentPagerAdapter {
+        private static final int NUM_ITEMS = 3;
+
+        private Context mContext;
+
+        public ViewPagerAdapter(Context context, FragmentManager fm) {
+            super(fm);
+            mContext = context;
+        }
+
+        @Override
+        public int getCount() {
+            return NUM_ITEMS;
+        }
+
+        @Override
+        public Fragment getItem(int position) {
+            switch (position) {
+                case 0:
+                    return new ConsoleContainer();
+                case 1:
+                    return new TunnelsContainer();
+                case 2:
+                    return new AddressbookContainer();
+                default:
+                    return null;
+            }
+        }
+
+        @Override
+        public CharSequence getPageTitle(int position) {
+            switch (position) {
+                case 0:
+                    return mContext.getString(R.string.label_console);
+                case 1:
+                    return mContext.getString(R.string.label_tunnels);
+                case 2:
+                    return mContext.getString(R.string.label_addresses);
+                default:
+                    return null;
+            }
+        }
+    }
+
+    @Override
+    protected void onPostCreate(Bundle savedInstanceState) {
+        Util.d("Initializing...");
+        InitActivities init = new InitActivities(this);
+        init.debugStuff();
+        init.initialize();
+        super.onPostCreate(savedInstanceState);
+        handleIntents();
+    }
+
+    @Override
+    protected void onNewIntent(Intent intent) {
+        super.onNewIntent(intent);
+        handleIntents();
+    }
+
+    private void handleIntents() {
+        if (getIntent() == null)
+            return;
+
+        Intent intent = getIntent();
+        String action = intent.getAction();
+
+        if (action == null)
+            return;
+
+        switch (action) {
+            case "net.i2p.android.router.START_I2P":
+                if (mViewPager.getCurrentItem() != 0)
+                    mViewPager.setCurrentItem(0, false);
+                autoStart();
+                break;
+
+            case Intent.ACTION_PICK:
+                mViewPager.setFixedPage(2, R.string.select_an_address);
+                break;
+        }
+    }
+
+    private void autoStart() {
+        if (canStart()) {
+            if (Connectivity.isConnected(this)) {
+                mAutoStartFromIntent = true;
+                onStartRouterClicked();
+            } else {
+                // Not connected to a network
+                // TODO: Notify user
+            }
+        } else {
+            // TODO: Notify user
+        }
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(this);
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(RouterService.LOCAL_BROADCAST_STATE_NOTIFICATION);
+        filter.addAction(RouterService.LOCAL_BROADCAST_STATE_CHANGED);
+        lbm.registerReceiver(onStateChange, filter);
+    }
+
+    private BroadcastReceiver onStateChange = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            State state = intent.getParcelableExtra(RouterService.LOCAL_BROADCAST_EXTRA_STATE);
+
+            if (_startPressed && Util.getRouterContext() != null)
+                _startPressed = false;
+
+            // Update menus, FAMs etc.
+            supportInvalidateOptionsMenu();
+
+            // Update main paging state
+            mViewPager.setPagingEnabled(!(Util.isStopping(state) || Util.isStopped(state)));
+
+            // If I2P was started by another app and is running, return to that app
+            if (state == State.RUNNING && mAutoStartFromIntent) {
+                I2PActivity.this.setResult(RESULT_OK);
+                finish();
+            }
+        }
+    };
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        // Handle edge cases after shutting down router
+        mViewPager.updatePagingState();
+
+        LocalBroadcastManager.getInstance(this).sendBroadcast(new Intent(RouterService.LOCAL_BROADCAST_REQUEST_STATE));
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.activity_base_actions, menu);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.menu_settings:
+                Intent intent = new Intent(this, SettingsActivity.class);
+                startActivity(intent);
+                return true;
+
+            case R.id.menu_help:
+                Intent hi = new Intent(this, HelpActivity.class);
+                switch (mViewPager.getCurrentItem()) {
+                    case 1:
+                        hi.putExtra(HelpActivity.CATEGORY, HelpActivity.CAT_I2PTUNNEL);
+                        break;
+                    case 2:
+                        hi.putExtra(HelpActivity.CATEGORY, HelpActivity.CAT_ADDRESSBOOK);
+                        break;
+                }
+                startActivity(hi);
+                return true;
+
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    public void onBackPressed() {
+        super.onBackPressed();
+
+        RouterContext ctx = Util.getRouterContext();
+        // RouterService svc = _routerService; Which is better to use?!
+        _keep = Connectivity.isConnected(this) && (ctx != null || _startPressed);
+        Util.d("*********************************************************");
+        Util.d("Back pressed, Keep? " + _keep);
+        Util.d("*********************************************************");
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+
+        LocalBroadcastManager.getInstance(this).unregisterReceiver(onStateChange);
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        if (!_keep) {
+            Thread t = new Thread(new KillMe());
+            t.start();
+        }
+    }
+
+    private class KillMe implements Runnable {
+
+        public void run() {
+            Util.d("*********************************************************");
+            Util.d("KillMe started!");
+            Util.d("*********************************************************");
+            try {
+                Thread.sleep(500); // is 500ms long enough?
+            } catch (InterruptedException ex) {
+            }
+            System.exit(0);
+        }
+    }
+
+    private boolean canStart() {
+        RouterService svc = _routerService;
+        return (svc == null) || (!_isBound) || svc.canManualStart();
+    }
+
+    private boolean canStop() {
+        RouterService svc = _routerService;
+        return svc != null && _isBound && svc.canManualStop();
+    }
+
+    // MainFragment.RouterControlListener
+
+    public boolean shouldShowOnOff() {
+        return (canStart() && Connectivity.isConnected(this)) || (canStop() && !isGracefulShutdownInProgress());
+    }
+
+    public boolean shouldBeOn() {
+        String action = getIntent().getAction();
+        return (canStop()) ||
+                (action != null && action.equals("net.i2p.android.router.START_I2P"));
+    }
+
+    public void onStartRouterClicked() {
+        _startPressed = true;
+        RouterService svc = _routerService;
+        if (svc != null && _isBound) {
+            setPref(PREF_AUTO_START, true);
+            svc.manualStart();
+        } else {
+            (new File(Util.getFileDir(this), "wrapper.log")).delete();
+            startRouter();
+        }
+    }
+
+    public boolean onStopRouterClicked() {
+        RouterService svc = _routerService;
+        if (svc != null && _isBound) {
+            setPref(PREF_AUTO_START, false);
+            svc.manualQuit();
+            return true;
+        }
+        return false;
+    }
+
+    /** @since 0.9.19 */
+    public boolean isGracefulShutdownInProgress() {
+        RouterService svc = _routerService;
+        return svc != null && svc.isGracefulShutdownInProgress();
+    }
+
+    /** @since 0.9.19 */
+    public boolean onGracefulShutdownClicked() {
+        RouterService svc = _routerService;
+        if(svc != null && _isBound) {
+            setPref(PREF_AUTO_START, false);
+            svc.gracefulShutdown();
+            return true;
+        }
+        return false;
+    }
+
+    /** @since 0.9.19 */
+    public boolean onCancelGracefulShutdownClicked() {
+        RouterService svc = _routerService;
+        if(svc != null && _isBound) {
+            setPref(PREF_AUTO_START, false);
+            svc.cancelGracefulShutdown();
+            return true;
+        }
+        return false;
+    }
+}

app/src/main/java/net/i2p/android/I2PActivityBase.java

@@ -0,0 +1,207 @@
+package net.i2p.android;
+
+import android.content.ComponentName;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.support.v7.app.AppCompatActivity;
+
+import net.i2p.android.router.service.RouterBinder;
+import net.i2p.android.router.service.RouterService;
+import net.i2p.android.router.util.Util;
+import net.i2p.android.util.LocaleManager;
+
+public abstract class I2PActivityBase extends AppCompatActivity {
+    /**
+     * Router variables
+     */
+    protected boolean _isBound;
+    protected boolean _triedBind;
+    protected ServiceConnection _connection;
+    protected RouterService _routerService;
+    private SharedPreferences _sharedPrefs;
+
+    private static final String SHARED_PREFS = "net.i2p.android.router";
+    protected static final String PREF_AUTO_START = "autoStart";
+    /**
+     * true leads to a poor install experience, very slow to paint the screen
+     */
+    protected static final boolean DEFAULT_AUTO_START = false;
+
+    private final LocaleManager localeManager = new LocaleManager();
+
+    /**
+     * Called when the activity is first created.
+     */
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        Util.d(this + " onCreate called");
+        localeManager.onCreate(this);
+        super.onCreate(savedInstanceState);
+        _sharedPrefs = getSharedPreferences(SHARED_PREFS, 0);
+    }
+
+    @Override
+    public void onRestart() {
+        Util.d(this + " onRestart called");
+        super.onRestart();
+    }
+
+    @Override
+    public void onStart() {
+        Util.d(this + " onStart called");
+        super.onStart();
+        if (_sharedPrefs.getBoolean(PREF_AUTO_START, DEFAULT_AUTO_START))
+            startRouter();
+        else
+            bindRouter(false);
+    }
+
+    /**
+     * @param def default
+     */
+    public boolean getPref(String pref, boolean def) {
+        return _sharedPrefs.getBoolean(pref, def);
+    }
+
+    /**
+     * @param def default
+     */
+    public String getPref(String pref, String def) {
+        return _sharedPrefs.getString(pref, def);
+    }
+
+    /**
+     * @return success
+     */
+    public boolean setPref(String pref, boolean val) {
+        SharedPreferences.Editor edit = _sharedPrefs.edit();
+        edit.putBoolean(pref, val);
+        return edit.commit();
+    }
+
+    /**
+     * @return success
+     */
+    public boolean setPref(String pref, String val) {
+        SharedPreferences.Editor edit = _sharedPrefs.edit();
+        edit.putString(pref, val);
+        return edit.commit();
+    }
+
+    @Override
+    public void onResume() {
+        Util.d(this + " onResume called");
+        super.onResume();
+        localeManager.onResume(this);
+    }
+
+    public void notifyLocaleChanged() {
+        localeManager.onResume(this);
+    }
+
+    @Override
+    public void onPause() {
+        Util.d(this + " onPause called");
+        super.onPause();
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        Util.d(this + " onSaveInstanceState called");
+        super.onSaveInstanceState(outState);
+    }
+
+    @Override
+    public void onStop() {
+        Util.d(this + " onStop called");
+        unbindRouter();
+        super.onStop();
+    }
+
+    @Override
+    public void onDestroy() {
+        Util.d(this + " onDestroy called");
+        super.onDestroy();
+    }
+
+    ////// Service stuff
+
+    /**
+     * Start the service and bind to it
+     */
+    protected boolean startRouter() {
+        Intent intent = new Intent();
+        intent.setClassName(this, "net.i2p.android.router.service.RouterService");
+        Util.d(this + " calling startService");
+        ComponentName name = startService(intent);
+        if (name == null)
+            Util.d(this + " XXXXXXXXXXXXXXXXXXXX got null from startService!");
+        Util.d(this + " got from startService: " + name);
+        boolean success = bindRouter(true);
+        if (!success)
+            Util.d(this + " Bind router failed");
+        return success;
+    }
+
+    /**
+     * Bind only
+     */
+    protected boolean bindRouter(boolean autoCreate) {
+        Intent intent = new Intent(RouterBinder.class.getName());
+        intent.setClassName(this, "net.i2p.android.router.service.RouterService");
+        Util.d(this + " calling bindService");
+        _connection = new RouterConnection();
+        _triedBind = bindService(intent, _connection, autoCreate ? BIND_AUTO_CREATE : 0);
+        Util.d(this + " bindService: auto create? " + autoCreate + " success? " + _triedBind);
+        return _triedBind;
+    }
+
+    protected void unbindRouter() {
+        Util.d(this + " unbindRouter called with _isBound:" + _isBound + " _connection:" + _connection + " _triedBind:" + _triedBind);
+        if (_triedBind && _connection != null)
+            unbindService(_connection);
+
+        _triedBind = false;
+        _connection = null;
+        _routerService = null;
+        _isBound = false;
+    }
+
+    /**
+     * Class for interacting with the main interface of the RouterService.
+     */
+    protected class RouterConnection implements ServiceConnection {
+
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            Util.d(this + " connected to router service");
+            RouterBinder binder = (RouterBinder) service;
+            RouterService svc = binder.getService();
+            _routerService = svc;
+            _isBound = true;
+            onRouterBind(svc);
+        }
+
+        public void onServiceDisconnected(ComponentName name) {
+            Util.d(this + " disconnected from router service!!!!!!!");
+            // save memory
+            _routerService = null;
+            _isBound = false;
+            onRouterUnbind();
+        }
+    }
+
+    /**
+     * callback from ServiceConnection, override as necessary
+     */
+    protected void onRouterBind(RouterService svc) {
+    }
+
+    /**
+     * callback from ServiceConnection, override as necessary
+     */
+    protected void onRouterUnbind() {
+    }
+}

app/src/main/java/net/i2p/android/InitActivities.java

@@ -0,0 +1,280 @@
+package net.i2p.android;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.Build;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.data.DataHelper;
+import net.i2p.util.FileUtil;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Properties;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+//  Wouldn't this be better as a private class in MainActivity?
+
+class InitActivities {
+
+    private final Context ctx;
+    private final String myDir;
+    private final String _ourVersion;
+
+    private static final String CONFIG_FILE = "android.config";
+    private static final String PROP_NEW_INSTALL = "i2p.newInstall";
+    private static final String PROP_NEW_VERSION = "i2p.newVersion";
+    private static final String PROP_INSTALLED_VERSION = "i2p.version";
+
+    public InitActivities(Context c) {
+        ctx = c;
+        myDir = Util.getFileDir(c);
+        _ourVersion = Util.getOurVersion(c);
+    }
+
+    void debugStuff() {
+        Util.d("java.io.tmpdir" + ": " + System.getProperty("java.io.tmpdir"));
+        Util.d("java.vendor" + ": " + System.getProperty("java.vendor"));
+        Util.d("java.version" + ": " + System.getProperty("java.version"));
+        Util.d("os.arch" + ": " + System.getProperty("os.arch"));
+        Util.d("os.name" + ": " + System.getProperty("os.name"));
+        Util.d("os.version" + ": " + System.getProperty("os.version"));
+        Util.d("user.dir" + ": " + System.getProperty("user.dir"));
+        Util.d("user.home" + ": " + System.getProperty("user.home"));
+        Util.d("user.name" + ": " + System.getProperty("user.name"));
+        Util.d("getFilesDir()" + ": " + myDir);
+        Util.d("max mem" + ": " + DataHelper.formatSize(Runtime.getRuntime().maxMemory()));
+        Util.d("Package" + ": " + ctx.getPackageName());
+        Util.d("Version" + ": " + _ourVersion);
+        Util.d("MODEL" + ": " + Build.MODEL);
+        Util.d("DISPLAY" + ": " + Build.DISPLAY);
+        Util.d("VERSION" + ": " + Build.VERSION.RELEASE);
+        Util.d("SDK" + ": " + Build.VERSION.SDK_INT);
+    }
+
+    void initialize() {
+
+        if (checkNewVersion()) {
+            List<Properties> lProps = Util.getPropertiesFromPreferences(ctx);
+            Properties props = lProps.get(0);
+
+            props.setProperty("i2p.dir.temp", myDir + "/tmp");
+            props.setProperty("i2p.dir.pid", myDir + "/tmp");
+            // Time disabled in default router.config
+            // But lots of time problems on Android, not all carriers support NITZ
+            // and there was no NTP before 3.0. Tablets should be fine?
+            // Phones in airplane mode with wifi enabled still a problem.
+            // Deactivated phones in airplane mode definitely won't have correct time.
+            if (Build.VERSION.SDK_INT < 11)  // Honeycomb 3.0
+                props.setProperty("time.disabled", "false");
+            mergeResourceToFile(R.raw.router_config, "router.config", props);
+            mergeResourceToFile(R.raw.logger_config, "logger.config", lProps.get(1));
+            // This is not needed for now, i2ptunnel.config only contains tunnel
+            // settings, which can now be configured manually. We don't want to
+            // overwrite the user's tunnels.
+            //mergeResourceToFile(R.raw.i2ptunnel_config, "i2ptunnel.config", null);
+            copyResourceToFileIfAbsent(R.raw.i2ptunnel_config, "i2ptunnel.config");
+            // FIXME this is a memory hog to merge this way
+            mergeResourceToFile(R.raw.hosts_txt, "hosts.txt", null);
+            mergeResourceToFile(R.raw.more_hosts_txt, "hosts.txt", null);
+            copyResourceToFile(R.raw.blocklist_txt, "blocklist.txt");
+
+            File abDir = new File(myDir, "addressbook");
+            abDir.mkdir();
+            copyResourceToFile(R.raw.subscriptions_txt, "addressbook/subscriptions.txt");
+            mergeResourceToFile(R.raw.addressbook_config_txt, "addressbook/config.txt", null);
+
+            File docsDir = new File(myDir, "docs");
+            docsDir.mkdir();
+            copyResourceToFile(R.raw.ahelper_conflict_header_ht, "docs/ahelper-conflict-header.ht");
+            copyResourceToFile(R.raw.ahelper_new_header_ht, "docs/ahelper-new-header.ht");
+            copyResourceToFile(R.raw.ahelper_notfound_header_ht, "docs/ahelper-notfound-header.ht");
+            copyResourceToFile(R.raw.auth_header_ht, "docs/auth-header.ht");
+            copyResourceToFile(R.raw.baduri_header_ht, "docs/baduri-header.ht");
+            copyResourceToFile(R.raw.denied_header_ht, "docs/denied-header.ht");
+            copyResourceToFile(R.raw.dnf_header_ht, "docs/dnf-header.ht");
+            copyResourceToFile(R.raw.dnfb_header_ht, "docs/dnfb-header.ht");
+            copyResourceToFile(R.raw.dnfh_header_ht, "docs/dnfh-header.ht");
+            copyResourceToFile(R.raw.dnfp_header_ht, "docs/dnfp-header.ht");
+            copyResourceToFile(R.raw.enc_header_ht, "docs/enc-header.ht");
+            copyResourceToFile(R.raw.encp_header_ht, "docs/encp-header.ht");
+            copyResourceToFile(R.raw.localhost_header_ht, "docs/localhost-header.ht");
+            copyResourceToFile(R.raw.nols_header_ht, "docs/nols-header.ht");
+            copyResourceToFile(R.raw.nolsp_header_ht, "docs/nolsp-header.ht");
+            copyResourceToFile(R.raw.noproxy_header_ht, "docs/noproxy-header.ht");
+            copyResourceToFile(R.raw.protocol_header_ht, "docs/protocol-header.ht");
+            copyResourceToFile(R.raw.reset_header_ht, "docs/reset-header.ht");
+            copyResourceToFile(R.raw.resetp_header_ht, "docs/resetp-header.ht");
+
+            File cssDir = new File(docsDir, "themes/console/light");
+            cssDir.mkdirs();
+            //copyResourceToFile(R.raw.console_css, "docs/themes/console/light/console.css");
+            //copyResourceToFile(R.raw.android_css, "docs/themes/console/light/android.css");
+
+            File imgDir = new File(docsDir, "themes/console/images");
+            imgDir.mkdir();
+            copyResourceToFile(R.drawable.i2plogo, "docs/themes/console/images/i2plogo.png");
+            copyResourceToFile(R.drawable.itoopie_sm, "docs/themes/console/images/itoopie_sm.png");
+            //copyResourceToFile(R.drawable.outbound, "docs/themes/console/images/outbound.png");
+            //copyResourceToFile(R.drawable.inbound, "docs/themes/console/images/inbound.png");
+
+            File img2Dir = new File(cssDir, "images");
+            img2Dir.mkdir();
+            //copyResourceToFile(R.drawable.header, "docs/themes/console/light/images/header.png");
+
+            File certDir = new File(myDir, "certificates");
+            certDir.mkdir();
+            File certificates = new File(myDir, "certificates");
+            File[] allcertificates = certificates.listFiles();
+            if ( allcertificates != null) {
+                for (File f : allcertificates) {
+                    Util.d("Deleting old certificate file/dir " + f);
+                    FileUtil.rmdir(f, false);
+                }
+            }
+            unzipResourceToDir(R.raw.certificates_zip, "certificates");
+            //File netDBDir = new File(myDir, "netDB");
+            //netDBDir.mkdir();
+            //unzipResourceToDir(R.raw.netdb_zip, "netDB");
+        }
+
+        // Set up the locations so settings can find them
+        System.setProperty("i2p.dir.base", myDir);
+        System.setProperty("i2p.dir.config", myDir);
+        System.setProperty("wrapper.logfile", myDir + "/wrapper.log");
+    }
+
+    /**
+     *  @param f relative to base dir
+     */
+    private void copyResourceToFileIfAbsent(int resID, String f) {
+        File file = new File(myDir, f);
+        if (!file.exists())
+            copyResourceToFile(resID, f);
+    }
+
+    /**
+     *  @param f relative to base dir
+     */
+    private void copyResourceToFile(int resID, String f) {
+        InputStream in = null;
+        FileOutputStream out = null;
+
+        Util.d("Creating file " + f + " from resource");
+        byte buf[] = new byte[4096];
+        try {
+            // Context methods
+            in = ctx.getResources().openRawResource(resID);
+            out = new FileOutputStream(new File(myDir, f));
+
+            int read;
+            while ( (read = in.read(buf)) != -1)
+                out.write(buf, 0, read);
+
+        } catch (IOException ioe) {
+        } catch (Resources.NotFoundException nfe) {
+        } finally {
+            if (in != null) try { in.close(); } catch (IOException ioe) {}
+            if (out != null) try { out.close(); } catch (IOException ioe) {}
+        }
+    }
+    /**
+     *  @param folder relative to base dir
+     */
+    private void unzipResourceToDir(int resID, String folder) {
+        InputStream in = null;
+        FileOutputStream out = null;
+        ZipInputStream zis = null;
+
+        Util.d("Creating files in '" + myDir + "/" + folder + "/' from resource");
+        try {
+            // Context methods
+            in = ctx.getResources().openRawResource(resID);
+            zis = new ZipInputStream((in));
+            ZipEntry ze;
+            while ((ze = zis.getNextEntry()) != null) {
+                out = null;
+                try {
+                    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+                    byte[] buffer = new byte[1024];
+                    int count;
+                    while ((count = zis.read(buffer)) != -1) {
+                        baos.write(buffer, 0, count);
+                    }
+                    String name = ze.getName();
+                    File f = new File(myDir + "/" + folder +"/" + name);
+                    if (ze.isDirectory()) {
+                        Util.d("Creating directory " + myDir + "/" + folder +"/" + name + " from resource");
+                        f.mkdir();
+                    } else {
+                        Util.d("Creating file " + myDir + "/" + folder +"/" + name + " from resource");
+                        byte[] bytes = baos.toByteArray();
+                        out = new FileOutputStream(f);
+                        out.write(bytes);
+                    }
+                } catch (IOException ioe) {
+                } finally {
+                    if (out != null) { try { out.close(); } catch (IOException ioe) {} out = null; }
+                }
+            }
+        } catch (IOException ioe) {
+        } catch (Resources.NotFoundException nfe) {
+        } finally {
+            if (in != null) try { in.close(); } catch (IOException ioe) {}
+            if (out != null) try { out.close(); } catch (IOException ioe) {}
+            if (zis != null) try { zis.close(); } catch (IOException ioe) {}
+        }
+    }
+
+    /**
+     *  Load defaults from resource,
+     *  then add props from settings,
+     *  and write back.
+     *
+     *  @param f relative to base dir
+     *  @param overrides local overrides or null
+     */
+    private void mergeResourceToFile(int resID, String f, Properties overrides) {
+        Util.mergeResourceToFile(ctx, myDir, f, resID, overrides, null);
+    }
+
+    /**
+     *  Check for new version.
+     *  FIXME we could just use shared prefs for this instead of storing in a file
+     *  @return true if new version
+     */
+    private boolean checkNewVersion() {
+        Properties props = new Properties();
+
+        InputStream fin = null;
+        try {
+            fin = ctx.openFileInput(CONFIG_FILE);
+            DataHelper.loadProps(props,  fin);
+        } catch (IOException ioe) {
+            Util.d("Looks like a new install");
+        } finally {
+            if (fin != null) try { fin.close(); } catch (IOException ioe) {}
+        }
+
+        String oldVersion = props.getProperty(PROP_INSTALLED_VERSION);
+        boolean newInstall = oldVersion == null;
+        boolean newVersion = !_ourVersion.equals(oldVersion);
+
+        if (newVersion) {
+            Util.d("New version " + _ourVersion);
+            props.setProperty(PROP_INSTALLED_VERSION, _ourVersion);
+            try {
+                DataHelper.storeProps(props, ctx.getFileStreamPath(CONFIG_FILE));
+            } catch (IOException ioe) {
+                Util.d("Failed to write " + CONFIG_FILE);
+            }
+        }
+        return newVersion;
+    }
+}

app/src/main/java/net/i2p/android/apps/EepGetFetcher.java

@@ -0,0 +1,157 @@
+package net.i2p.android.apps;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import net.i2p.I2PAppContext;
+import net.i2p.data.DataHelper;
+import net.i2p.util.EepGet;
+import net.i2p.util.Log;
+
+/**
+ *  EepGet and return as a string. 256KB max.
+ */
+public class EepGetFetcher implements EepGet.StatusListener {
+
+    private final I2PAppContext _context;
+    private final Log _log;
+    private final String _url;
+    private final EepGet _eepget;
+    private final File _file;
+    private boolean _success;
+
+    private static final long MAX_LEN = 256*1024;
+
+    private static final String ERROR_HEADER = "<html><head><title>Not Found</title></head><body>";
+    private static final String ERROR_URL = "<p>Unable to load URL: ";
+    private static final String ERROR_ROUTER = "<p>Your router (or the HTTP proxy) does not appear to be running.</p>";
+    private static final String ERROR_FOOTER = "</body></html>";
+
+    /**
+     *  Writes to temp file, call getData()
+     *  to get the data as a String.
+     *  Temp file sticks around forever.
+     */
+    public EepGetFetcher(String url) {
+        _context = I2PAppContext.getGlobalContext();
+        _log = _context.logManager().getLog(EepGetFetcher.class);
+        _url = url;
+        _file = new File(_context.getTempDir(), "eepget-" + _context.random().nextLong());
+        _eepget = new EepGet(_context, true, "localhost", 4444, 0, -1, MAX_LEN,
+                             _file.getAbsolutePath(), null, url,
+                             true, null, null, null);
+        // use new 0.8.8 feature
+        _eepget.setWriteErrorToOutput();
+        //_eepget.addStatusListener(this);
+    }
+
+    /**
+     *  Writes to output stream
+     */
+    public EepGetFetcher(String url, OutputStream out, boolean writeErrorToStream) {
+        _context = I2PAppContext.getGlobalContext();
+        _log = _context.logManager().getLog(EepGetFetcher.class);
+        _url = url;
+        _file = null;
+        _eepget = new EepGet(_context, true, "localhost", 4444, 0, -1, MAX_LEN,
+                             null, out, url,
+                             true, null, null, null);
+        if (writeErrorToStream)
+            _eepget.setWriteErrorToOutput();
+    }
+
+    public void addStatusListener(EepGet.StatusListener l) {
+        _eepget.addStatusListener(l);
+    }
+
+    public boolean fetch() {
+        _success = _eepget.fetch();
+        return _success;
+    }
+
+    /**
+     *  @return non-null
+     */
+    public String getContentType() {
+        if (_eepget.getStatusCode() < 0)
+            return "text/html";
+        String rv = _eepget.getContentType();
+        if (rv == null)
+            return "text/html";
+        int semi = rv.indexOf(";");
+        if (semi > 0)
+            rv = rv.substring(0, semi);
+        return rv.toLowerCase();
+    }
+
+    /**
+     *  @return non-null
+     */
+    public String getEncoding() {
+        if (_eepget.getStatusCode() < 0)
+            return "UTF-8";
+        String type = _eepget.getContentType();
+        String rv;
+        if (type == null || !type.startsWith("text"))
+            rv = "ISO-8859-1";
+        else
+            rv = "UTF-8";
+        return rv;
+    }
+
+    /**
+     *  @return -1 if nothing back from server
+     */
+    public int getStatusCode() {
+        return _eepget.getStatusCode();
+    }
+
+    /**
+     *  Only for the constructor without the output stream
+     *  Only call ONCE!
+     *  FIXME we don't get the proxy error pages this way
+     */
+    public String getData() {
+        String rv;
+        int statusCode = _eepget.getStatusCode();
+        if (statusCode < 0) {
+            rv = ERROR_HEADER + ERROR_URL + "<a href=\"" + _url + "\">" + _url +
+                 "</a></p>" + ERROR_ROUTER + ERROR_FOOTER;
+            _file.delete();
+        } else if (_file.length() <= 0) {
+            rv = ERROR_HEADER + ERROR_URL + "<a href=\"" + _url + "\">" + _url +
+                 "</a> No data returned, error code: " + statusCode +
+                 "</p>" + ERROR_FOOTER;
+            _file.delete();
+        } else {
+            InputStream fis = null;
+            try {
+                fis = new FileInputStream(_file);
+                byte[] data = new byte[(int) _file.length()];
+                DataHelper.read(fis, data);
+                rv = new String(data, getEncoding());
+            } catch (IOException ioe) {
+                _log.error("fetcher", ioe);
+                rv = "I/O error";
+            } finally {
+                if (fis != null) try { fis.close(); } catch (IOException ioe) {}
+                _file.delete();
+            }
+        }
+        return rv;
+    }
+
+    public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) {}
+
+    public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) {}
+
+    public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) {}
+
+    public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) {}
+
+    public void headerReceived(String url, int attemptNum, String key, String val) {}
+
+    public void attempting(String url) {}
+}

app/src/main/java/net/i2p/android/apps/NewsFetcher.java

@@ -0,0 +1,420 @@
+package net.i2p.android.apps;
+
+import android.content.Context;
+
+import net.i2p.android.router.NewsActivity;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Notifications;
+import net.i2p.crypto.SU3File;
+import net.i2p.data.DataHelper;
+import net.i2p.router.RouterContext;
+import net.i2p.router.news.NewsEntry;
+import net.i2p.router.news.NewsMetadata;
+import net.i2p.router.news.NewsXMLParser;
+import net.i2p.util.EepGet;
+import net.i2p.util.FileUtil;
+import net.i2p.util.Log;
+import net.i2p.util.ReusableGZIPInputStream;
+import net.i2p.util.SecureFileOutputStream;
+import net.i2p.util.RFC822Date;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.Date;
+import java.util.List;
+
+/**
+ * From router console, simplified since we don't deal with router versions
+ * or updates.
+ */
+public class NewsFetcher implements Runnable, EepGet.StatusListener {
+    private final Context mCtx;
+    private final RouterContext _context;
+    private final Notifications _notif;
+    private final Log _log;
+    private long _lastFetch;
+    private long _lastUpdated;
+    private String _lastModified;
+    private boolean _invalidated;
+    private File _newsFile;
+    private File _tempFile;
+    private static NewsFetcher _instance;
+    private volatile boolean _isRunning = true;
+    private Thread _thread;
+
+    public static /*final */ NewsFetcher getInstance() {
+        return _instance;
+    }
+
+    public static /* final */ synchronized NewsFetcher getInstance(
+            Context context, RouterContext ctx, Notifications notif) {
+        if (_instance != null)
+            return _instance;
+        _instance = new NewsFetcher(context, ctx, notif);
+        return _instance;
+    }
+
+    private static final String NEWS_DIR = "docs";
+    private static final String NEWS_FILE = "news.xml";
+    private static final String TEMP_NEWS_FILE = "news.xml.temp";
+
+    /**
+     * Changed in 0.9.11 to the b32 for psi.i2p, run by psi.
+     * We may be able to change it to psi.i2p in a future release after
+     * the hostname propagates.
+     *
+     * @since 0.7.14 not configurable
+     */
+    private static final String BACKUP_NEWS_URL_SU3 = "http://avviiexdngd32ccoy4kuckvc3mkf53ycvzbz6vz75vzhv4tbpk5a.b32.i2p/news.su3";
+    private static final String PROP_LAST_CHECKED = "router.newsLastChecked";
+    private static final String PROP_REFRESH_FREQUENCY = "router.newsRefreshFrequency";
+    private static final String DEFAULT_REFRESH_FREQUENCY = 24 * 60 * 60 * 1000 + "";
+    private static final String PROP_NEWS_URL = "router.newsURL";
+    public static final String DEFAULT_NEWS_URL_SU3 = "http://echelon.i2p/news/news.su3";
+
+    private NewsFetcher(Context context, RouterContext ctx, Notifications notif) {
+        mCtx = context;
+        _context = ctx;
+        _notif = notif;
+        _context.addShutdownTask(new Shutdown());
+        _log = ctx.logManager().getLog(NewsFetcher.class);
+        try {
+            String last = ctx.getProperty(PROP_LAST_CHECKED);
+            if (last != null)
+                _lastFetch = Long.parseLong(last);
+        } catch (NumberFormatException nfe) {
+        }
+        File newsDir = new File(_context.getRouterDir(), NEWS_DIR);
+        // isn't already there on android
+        newsDir.mkdir();
+        _newsFile = new File(newsDir, NEWS_FILE);
+        _tempFile = new File(_context.getTempDir(), TEMP_NEWS_FILE);
+        updateLastFetched();
+    }
+
+    private void updateLastFetched() {
+        if (_newsFile.exists()) {
+            if (_lastUpdated == 0)
+                _lastUpdated = _newsFile.lastModified();
+            if (_lastFetch == 0)
+                _lastFetch = _lastUpdated;
+            if (_lastModified == null)
+                _lastModified = RFC822Date.to822Date(_lastFetch);
+        } else {
+            _lastUpdated = 0;
+            _lastFetch = 0;
+            _lastModified = null;
+        }
+    }
+
+    public String status() {
+        StringBuilder buf = new StringBuilder(128);
+        long now = _context.clock().now();
+        if (_lastUpdated > 0) {
+            buf.append(mCtx.getString(R.string.news_last_updated,
+                    DataHelper.formatDuration2(now - _lastUpdated)))
+                    .append('\n');
+        }
+        if (_lastFetch > _lastUpdated) {
+            buf.append(mCtx.getString(R.string.news_last_checked,
+                    DataHelper.formatDuration2(now - _lastFetch)));
+        }
+        return buf.toString();
+    }
+
+    // Runnable
+
+    private static final long INITIAL_DELAY = 5 * 60 * 1000;
+    private static final long RUN_DELAY = 30 * 60 * 1000;
+
+    public void run() {
+        _thread = Thread.currentThread();
+        try {
+            Thread.sleep(INITIAL_DELAY);
+        } catch (InterruptedException ie) {
+            return;
+        }
+        while (_isRunning && _context.router().isAlive()) {
+            if (shouldFetchNews()) {
+                fetchNews();
+            }
+            try {
+                Thread.sleep(RUN_DELAY);
+            } catch (InterruptedException ie) {
+                break;
+            }
+        }
+    }
+
+    private boolean shouldFetchNews() {
+        if (_invalidated)
+            return true;
+        updateLastFetched();
+        String freq = _context.getProperty(PROP_REFRESH_FREQUENCY,
+                DEFAULT_REFRESH_FREQUENCY);
+        try {
+            long ms = Long.parseLong(freq);
+            if (ms <= 0)
+                return false;
+
+            if (_lastFetch + ms < _context.clock().now()) {
+                return true;
+            } else {
+                if (_log.shouldLog(Log.DEBUG))
+                    _log.debug("Last fetched " + DataHelper.formatDuration(_context.clock().now() - _lastFetch) + " ago");
+                return false;
+            }
+        } catch (NumberFormatException nfe) {
+            if (_log.shouldLog(Log.ERROR))
+                _log.error("Invalid refresh frequency: " + freq);
+            return false;
+        }
+    }
+
+    /**
+     * Call this when changing news URLs to force an update next time the timer fires.
+     *
+     * @since 0.8.7
+     */
+    void invalidateNews() {
+        _lastModified = null;
+        _invalidated = true;
+    }
+
+    public void fetchNews() {
+        String newsURL = _context.getProperty(PROP_NEWS_URL, DEFAULT_NEWS_URL_SU3);
+        String proxyHost = "127.0.0.1";
+        int proxyPort = 4444;
+        if (_tempFile.exists())
+            _tempFile.delete();
+
+        try {
+            // EepGet get = null;
+            EepGet get = new EepGet(_context, true, proxyHost, proxyPort, 0, _tempFile.getAbsolutePath(), newsURL, true, null, _lastModified);
+            get.addStatusListener(this);
+            if (get.fetch()) {
+                _lastModified = get.getLastModified();
+                _invalidated = false;
+            } else {
+                // backup news location - always proxied
+                _tempFile.delete();
+                get = new EepGet(_context, true, proxyHost, proxyPort, 0, _tempFile.getAbsolutePath(), BACKUP_NEWS_URL_SU3, true, null, _lastModified);
+                get.addStatusListener(this);
+                if (get.fetch())
+                    _lastModified = get.getLastModified();
+            }
+        } catch (Throwable t) {
+            _log.error("Error fetching the news", t);
+        }
+    }
+
+    // EepGet.StatusListener
+
+    public void bytesTransferred(long alreadyTransferred, int currentWrite, long bytesTransferred, long bytesRemaining, String url) {
+        // ignore
+    }
+
+    public void transferComplete(long alreadyTransferred, long bytesTransferred, long bytesRemaining, String url, String outputFile, boolean notModified) {
+        if (_log.shouldLog(Log.INFO))
+            _log.info("News fetched from " + url + " with " + (alreadyTransferred + bytesTransferred));
+
+        long now = _context.clock().now();
+        if (_tempFile.exists() && _tempFile.length() > 0) {
+            File from;
+            if (url.endsWith(".su3")) {
+                try {
+                    from = processSU3();
+                } catch (IOException ioe) {
+                    _log.error("Failed to extract the news file", ioe);
+                    _tempFile.delete();
+                    return;
+                }
+            } else {
+                from = _tempFile;
+            }
+            boolean copied = FileUtil.rename(from, _newsFile);
+            _tempFile.delete();
+            if (copied) {
+                _lastUpdated = now;
+
+                // Notify user
+                _notif.notify(mCtx.getString(R.string.news_updated),
+                        mCtx.getString(R.string.view_news),
+                        NewsActivity.class);
+            } else {
+                if (_log.shouldLog(Log.ERROR))
+                    _log.error("Failed to copy the news file!");
+            }
+        } else {
+            if (_log.shouldLog(Log.WARN))
+                _log.warn("Transfer complete, but no file? - probably 304 Not Modified");
+        }
+        _lastFetch = now;
+        _context.router().setConfigSetting(PROP_LAST_CHECKED, "" + now);
+        _context.router().saveConfig();
+    }
+
+    public void attemptFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt, int numRetries, Exception cause) {
+        // ignore
+    }
+
+    public void transferFailed(String url, long bytesTransferred, long bytesRemaining, int currentAttempt) {
+        if (_log.shouldLog(Log.WARN))
+            _log.warn("Failed to fetch the news from " + url);
+        _tempFile.delete();
+    }
+
+    public void headerReceived(String url, int attemptNum, String key, String val) {
+    }
+
+    public void attempting(String url) {
+    }
+
+    private class Shutdown implements Runnable {
+        public void run() {
+            _isRunning = false;
+            if (_thread != null)
+                _thread.interrupt();
+        }
+    }
+
+    //
+    // SU3 handlers
+    //
+
+    /**
+     *  Process the fetched su3 news file _tempFile.
+     *  Handles 3 types of contained files: xml.gz (preferred), xml, and html (old format fake xml)
+     *
+     *  @return the temp file contining the HTML-format news.xml
+     *  @since 0.9.20
+     */
+    private File processSU3() throws IOException {
+        SU3File su3 = new SU3File(_context, _tempFile);
+        // real xml, maybe gz, maybe not
+        File to1 = new File(_context.getTempDir(), "tmp-" + _context.random().nextInt() + ".xml");
+        // real xml
+        File to2 = new File(_context.getTempDir(), "tmp2-" + _context.random().nextInt() + ".xml");
+        try {
+            su3.verifyAndMigrate(to1);
+            int type = su3.getFileType();
+            if (su3.getContentType() != SU3File.CONTENT_NEWS)
+                throw new IOException("bad content type: " + su3.getContentType());
+            if (type == SU3File.TYPE_HTML)
+                return to1;
+            if (type != SU3File.TYPE_XML && type != SU3File.TYPE_XML_GZ)
+                throw new IOException("bad file type: " + type);
+            File xml;
+            if (type == SU3File.TYPE_XML_GZ) {
+                gunzip(to1, to2);
+                xml = to2;
+                to1.delete();
+            } else {
+                xml = to1;
+            }
+            NewsXMLParser parser = new NewsXMLParser(_context);
+            parser.parse(xml);
+            xml.delete();
+            NewsMetadata data = parser.getMetadata();
+            List<NewsEntry> entries = parser.getEntries();
+            String sudVersion = su3.getVersionString();
+            String signingKeyName = su3.getSignerString();
+            File to3 = new File(_context.getTempDir(), "tmp3-" + _context.random().nextInt() + ".xml");
+            outputOldNewsXML(data, entries, sudVersion, signingKeyName, to3);
+            return to3;
+        } finally {
+            to2.delete();
+        }
+    }
+
+    /**
+     *  Gunzip the file
+     *
+     *  @since 0.9.20
+     */
+    private static void gunzip(File from, File to) throws IOException {
+        ReusableGZIPInputStream in = ReusableGZIPInputStream.acquire();
+        OutputStream out = null;
+        try {
+            in.initialize(new FileInputStream(from));
+            out = new SecureFileOutputStream(to);
+            byte buf[] = new byte[4096];
+            int read;
+            while ((read = in.read(buf)) != -1) {
+                out.write(buf, 0, read);
+            }
+        } finally {
+            if (out != null) try {
+                out.close();
+            } catch (IOException ioe) {}
+            ReusableGZIPInputStream.release(in);
+        }
+    }
+
+    /**
+     *  Output in the old format.
+     *
+     *  @since 0.9.20
+     */
+    private void outputOldNewsXML(NewsMetadata data, List<NewsEntry> entries,
+                                  String sudVersion, String signingKeyName, File to) throws IOException {
+        NewsMetadata.Release latestRelease = data.releases.get(0);
+        Writer out = null;
+        try {
+            out = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(to), "UTF-8"));
+            out.write("<!--\n");
+            // update metadata in old format
+            out.write("<i2p.release ");
+            if (latestRelease.i2pVersion != null)
+                out.write(" version=\"" + latestRelease.i2pVersion + '"');
+            if (latestRelease.minVersion != null)
+                out.write(" minVersion=\"" + latestRelease.minVersion + '"');
+            if (latestRelease.minJavaVersion != null)
+                out.write(" minJavaVersion=\"" + latestRelease.minJavaVersion + '"');
+            String su3Torrent = "";
+            String su2Torrent = "";
+            for (NewsMetadata.Update update : latestRelease.updates) {
+                if (update.torrent != null) {
+                    if ("su3".equals(update.type))
+                        su3Torrent = update.torrent;
+                    else if ("su2".equals(update.type))
+                        su2Torrent = update.torrent;
+                }
+            }
+            if (!su2Torrent.isEmpty())
+                out.write(" su2Torrent=\"" + su2Torrent + '"');
+            if (!su3Torrent.isEmpty())
+                out.write(" su3Torrent=\"" + su3Torrent + '"');
+            out.write("/>\n");
+            // su3 and feed metadata for debugging
+            out.write("** News version:\t" + DataHelper.stripHTML(sudVersion) + '\n');
+            out.write("** Signed by:\t" + signingKeyName + '\n');
+            out.write("** Feed:\t" + DataHelper.stripHTML(data.feedTitle) + '\n');
+            out.write("** Feed ID:\t" + DataHelper.stripHTML(data.feedID) + '\n');
+            out.write("** Feed Date:\t" + (new Date(data.feedUpdated)) + '\n');
+            out.write("-->\n");
+            if (entries == null)
+                return;
+            for (NewsEntry e : entries) {
+                if (e.title == null || e.content == null)
+                    continue;
+                out.write("<!-- Entry Date: " + (new Date(e.updated)) + " -->\n");
+                out.write("<h3>");
+                out.write(e.title);
+                out.write("</h3>\n");
+                out.write(e.content);
+                out.write("\n\n");
+            }
+        } finally {
+            if (out != null) try {
+                out.close();
+            } catch (IOException ioe) {}
+        }
+    }
+}

app/src/main/java/net/i2p/android/help/Browser.java

@@ -0,0 +1,83 @@
+package net.i2p.android.help;
+
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.graphics.drawable.Drawable;
+import android.support.annotation.NonNull;
+
+public class Browser implements Comparable<Browser> {
+    public final String packageName;
+    public final CharSequence label;
+    public final Drawable icon;
+    public final boolean isInstalled;
+    public final boolean isKnown;
+    public final boolean isSupported;
+    public final boolean isRecommended;
+
+    /**
+     * A browser that we don't know about.
+     *
+     * @param pm      the PackageManager used to find the browser
+     * @param browser the browser
+     */
+    public Browser(PackageManager pm, ResolveInfo browser) {
+        this(
+                browser.activityInfo.packageName,
+                browser.loadLabel(pm),
+                browser.loadIcon(pm),
+                true, false, false, false
+        );
+    }
+
+    /**
+     * A browser that we know about.
+     *
+     * @param pm        the PackageManager used to find the browser
+     * @param browser   the browser
+     * @param supported can this browser be used with I2P?
+     */
+    public Browser(PackageManager pm, ResolveInfo browser, boolean supported, boolean recommended) {
+        this(
+                browser.activityInfo.packageName,
+                browser.loadLabel(pm),
+                browser.loadIcon(pm),
+                true, true, supported, recommended
+        );
+    }
+
+    public Browser(String pn, CharSequence l, Drawable ic, boolean i, boolean k, boolean s, boolean r) {
+        packageName = pn;
+        label = l;
+        icon = ic;
+        isInstalled = i;
+        isKnown = k;
+        isSupported = s;
+        isRecommended = r;
+    }
+
+    @Override
+    public int compareTo(@NonNull Browser browser) {
+        // Sort order: supported -> unknown -> unsupported
+        int a = getOrder(this);
+        int b = getOrder(browser);
+
+        if (a < b)
+            return -1;
+        else if (a > b)
+            return 1;
+
+        return label.toString().compareTo(browser.label.toString());
+    }
+
+    private static int getOrder(Browser browser) {
+        if (browser.isKnown) {
+            if (browser.isRecommended)
+                return 0;
+            else if (browser.isSupported)
+                return 1;
+            else
+                return 3;
+        } else
+            return 2;
+    }
+}

app/src/main/java/net/i2p/android/help/BrowserAdapter.java

@@ -0,0 +1,123 @@
+package net.i2p.android.help;
+
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.ColorMatrix;
+import android.graphics.ColorMatrixColorFilter;
+import android.net.Uri;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.i2p.android.router.R;
+
+public class BrowserAdapter extends RecyclerView.Adapter<BrowserAdapter.ViewHolder> {
+    private Context mCtx;
+    private Browser[] mBrowsers;
+    private OnBrowserSelectedListener mListener;
+
+    // Provide a reference to the views for each data item
+    // Complex data items may need more than one view per item, and
+    // you provide access to all the views for a data item in a view holder
+    public static class ViewHolder extends RecyclerView.ViewHolder {
+        public ImageView mIcon;
+        public TextView mLabel;
+        public ImageView mStatus;
+
+        public ViewHolder(View v) {
+            super(v);
+            mIcon = (ImageView) v.findViewById(R.id.browser_icon);
+            mLabel = (TextView) v.findViewById(R.id.browser_label);
+            mStatus = (ImageView) v.findViewById(R.id.browser_status_icon);
+        }
+    }
+
+    public interface OnBrowserSelectedListener {
+        void onBrowserSelected(Browser browser);
+    }
+
+    public BrowserAdapter(Context ctx, OnBrowserSelectedListener listener) {
+        mCtx = ctx;
+        mListener = listener;
+    }
+
+    public void setBrowsers(Browser[] browsers) {
+        mBrowsers = browsers;
+        notifyDataSetChanged();
+    }
+
+    public void clear() {
+        mBrowsers = null;
+        notifyDataSetChanged();
+    }
+
+    // Create new views (invoked by the layout manager)
+    @Override
+    public BrowserAdapter.ViewHolder onCreateViewHolder(ViewGroup parent,
+                                                        int viewType) {
+        View v = LayoutInflater.from(parent.getContext())
+                .inflate(R.layout.listitem_browser, parent, false);
+        return new ViewHolder(v);
+    }
+
+    // Replace the contents of a view (invoked by the layout manager)
+    @Override
+    public void onBindViewHolder(ViewHolder holder, int position) {
+        final Browser browser = mBrowsers[position];
+        holder.mIcon.setImageDrawable(browser.icon);
+        holder.mLabel.setText(browser.label);
+
+        if (browser.isKnown) {
+            if (browser.isRecommended && browser.isInstalled) {
+                holder.mStatus.setImageDrawable(
+                        mCtx.getResources().getDrawable(R.drawable.ic_stars_white_24dp));
+                holder.mStatus.setVisibility(View.VISIBLE);
+            } else if (browser.isSupported && !browser.isInstalled) {
+                holder.mStatus.setImageDrawable(
+                        mCtx.getResources().getDrawable(R.drawable.ic_shop_white_24dp));
+                holder.mStatus.setOnClickListener(new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        String uriMarket = "market://search?q=pname:" + browser.packageName;
+                        Uri uri = Uri.parse(uriMarket);
+                        Intent intent = new Intent(Intent.ACTION_VIEW, uri);
+                        try {
+                            mCtx.startActivity(intent);
+                        } catch (ActivityNotFoundException e) {
+                            Toast.makeText(mCtx, R.string.no_market_app, Toast.LENGTH_LONG).show();
+                        }
+                    }
+                });
+                holder.mStatus.setVisibility(View.VISIBLE);
+            } else if (!browser.isSupported) {
+                // Make the icon gray-scale to show it is unsupported
+                ColorMatrix matrix = new ColorMatrix();
+                matrix.setSaturation(0);
+                ColorMatrixColorFilter filter = new ColorMatrixColorFilter(matrix);
+                holder.mIcon.setColorFilter(filter);
+                holder.mLabel.setTextColor(
+                        mCtx.getResources().getColor(R.color.primary_text_disabled_material_dark));
+            }
+        }
+
+        holder.itemView.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                mListener.onBrowserSelected(browser);
+            }
+        });
+    }
+
+    // Return the size of the dataset (invoked by the layout manager)
+    @Override
+    public int getItemCount() {
+        if (mBrowsers != null)
+            return mBrowsers.length;
+        return 0;
+    }
+}

app/src/main/java/net/i2p/android/help/BrowserConfigActivity.java

@@ -0,0 +1,104 @@
+package net.i2p.android.help;
+
+import android.os.Bundle;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+import android.view.MenuItem;
+
+import net.i2p.android.router.R;
+import net.i2p.android.util.LocaleManager;
+
+import java.lang.reflect.Field;
+
+public class BrowserConfigActivity extends AppCompatActivity implements
+        BrowserAdapter.OnBrowserSelectedListener {
+
+    /**
+     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
+     * device.
+     */
+    private boolean mTwoPane;
+
+    private final LocaleManager localeManager = new LocaleManager();
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        localeManager.onCreate(this);
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_help);
+
+        // Set the action bar
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        if (findViewById(R.id.detail_fragment) != null) {
+            // The detail container view will be present only in the
+            // large-screen layouts (res/values-large and
+            // res/values-sw600dp). If this view is present, then the
+            // activity should be in two-pane mode.
+            mTwoPane = true;
+        }
+
+        if (savedInstanceState == null) {
+            getSupportFragmentManager().beginTransaction()
+                    .add(R.id.main_fragment, new BrowserListFragment())
+                    .commit();
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        localeManager.onResume(this);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                onBackPressed();
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    // BrowserAdapter.OnBrowserSelected
+
+    @Override
+    public void onBrowserSelected(Browser browser) {
+        int file;
+        if (browser.isKnown) {
+            if (browser.isSupported) {
+                // Check for embedded browser
+                if (browser.packageName.startsWith("net.i2p.android"))
+                    file = R.raw.help_embedded_browser;
+                else {
+                    // Load the configuration guide for this browser
+                    try {
+                        String name = "help_" + browser.packageName.replace('.', '_');
+                        Class res = R.raw.class;
+                        Field field = res.getField(name);
+                        file = field.getInt(null);
+                    } catch (Exception e) {
+                        file = R.raw.help_unknown_browser;
+                    }
+                }
+            } else
+                file = R.raw.help_unsupported_browser;
+        } else
+            file = R.raw.help_unknown_browser;
+        HelpHtmlFragment configFrag = HelpHtmlFragment.newInstance(file);
+        if (mTwoPane) {
+            getSupportFragmentManager().beginTransaction()
+                    .replace(R.id.detail_fragment, configFrag)
+                    .commit();
+        } else {
+            getSupportFragmentManager().beginTransaction()
+                    .replace(R.id.main_fragment, configFrag)
+                    .addToBackStack("config" + browser.packageName)
+                    .commit();
+        }
+    }
+}

app/src/main/java/net/i2p/android/help/BrowserListFragment.java

@@ -0,0 +1,191 @@
+package net.i2p.android.help;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.BetterAsyncTaskLoader;
+import net.i2p.android.widget.DividerItemDecoration;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class BrowserListFragment extends Fragment implements
+        LoaderManager.LoaderCallbacks<List<Browser>> {
+    private static final int BROWSER_LOADER_ID = 1;
+
+    private BrowserAdapter.OnBrowserSelectedListener mCallback;
+    private BrowserAdapter mAdapter;
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+
+        // This makes sure that the container activity has implemented
+        // the callback interface. If not, it throws an exception
+        try {
+            mCallback = (BrowserAdapter.OnBrowserSelectedListener) activity;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement OnBrowserSelectedListener");
+        }
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.fragment_help_browsers, container, false);
+        RecyclerView mRecyclerView = (RecyclerView) v.findViewById(R.id.browser_list);
+
+        mRecyclerView.setHasFixedSize(true);
+        mRecyclerView.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL_LIST));
+
+        // use a linear layout manager
+        RecyclerView.LayoutManager mLayoutManager = new LinearLayoutManager(getActivity());
+        mRecyclerView.setLayoutManager(mLayoutManager);
+
+        mAdapter = new BrowserAdapter(getActivity(), mCallback);
+        mRecyclerView.setAdapter(mAdapter);
+
+        return v;
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        getLoaderManager().initLoader(BROWSER_LOADER_ID, null, this);
+    }
+
+    // LoaderManager.LoaderCallbacks<List<Browser>>
+
+    @Override
+    public Loader<List<Browser>> onCreateLoader(int id, Bundle args) {
+        return new BrowserLoader(getActivity());
+    }
+
+    public static class BrowserLoader extends BetterAsyncTaskLoader<List<Browser>> {
+        private List<String> recommended;
+        private List<String> recommendedLabels;
+        private List<String> supported;
+        private List<String> supportedLabels;
+        private List<String> unsupported;
+
+        public BrowserLoader(Context context) {
+            super(context);
+            recommended = Arrays.asList(
+                    getContext().getResources().getStringArray(R.array.recommended_browsers));
+            recommendedLabels = Arrays.asList(
+                    getContext().getResources().getStringArray(R.array.recommended_browser_labels));
+            supported = Arrays.asList(
+                    getContext().getResources().getStringArray(R.array.supported_browsers));
+            supportedLabels = Arrays.asList(
+                    getContext().getResources().getStringArray(R.array.supported_browser_labels));
+            unsupported = Arrays.asList(
+                    context.getResources().getStringArray(R.array.unsupported_browsers));
+        }
+
+        @Override
+        public List<Browser> loadInBackground() {
+            List<Browser> browsers = new ArrayList<>();
+            Map<String, String> recommendedMap = new HashMap<>();
+            for (int i = 0; i < recommended.size(); i++) {
+                recommendedMap.put(recommended.get(i), recommendedLabels.get(i));
+            }
+            Map<String, String> supportedMap = new HashMap<>();
+            for (int i = 0; i < supported.size(); i++) {
+                supportedMap.put(supported.get(i), supportedLabels.get(i));
+            }
+
+            // Find all installed browsers that listen for ".i2p"
+            Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.setData(Uri.parse("http://stats.i2p"));
+
+            final PackageManager pm = getContext().getPackageManager();
+            List<ResolveInfo> installedBrowsers = pm.queryIntentActivities(intent, 0);
+
+            for (ResolveInfo browser : installedBrowsers) {
+                if (recommended.contains(browser.activityInfo.packageName)) {
+                    browsers.add(new Browser(pm, browser, true, true));
+                    recommendedMap.remove(browser.activityInfo.packageName);
+                } else if (supported.contains(browser.activityInfo.packageName) ||
+                        browser.activityInfo.packageName.startsWith("net.i2p.android")) {
+                    browsers.add(new Browser(pm, browser, true, false));
+                    supportedMap.remove(browser.activityInfo.packageName);
+                } else if (unsupported.contains(browser.activityInfo.packageName))
+                    browsers.add(new Browser(pm, browser, false, false));
+                else
+                    browsers.add(new Browser(pm, browser));
+            }
+
+            // Now add the remaining recommended and supported browsers
+            for (Map.Entry<String, String> browser : recommendedMap.entrySet()) {
+                browsers.add(new Browser(browser.getKey(), browser.getValue(),
+                        getDrawableForPackage(browser.getKey()),
+                        false, true, true, true));
+            }
+            for (Map.Entry<String, String> browser : supportedMap.entrySet()) {
+                browsers.add(new Browser(browser.getKey(), browser.getValue(),
+                        getDrawableForPackage(browser.getKey()),
+                        false, true, true, false));
+            }
+
+            Collections.sort(browsers);
+            return browsers;
+        }
+        private Drawable getDrawableForPackage(String packageName) {
+            try {
+                String name = "icon_" + packageName.replace('.', '_');
+                Class res = R.drawable.class;
+                Field field = res.getField(name);
+                int drawable = field.getInt(null);
+                return getContext().getResources().getDrawable(drawable);
+            } catch (Exception e) {
+                return null;
+            }
+        }
+
+        @Override
+        protected void onStartMonitoring() {
+        }
+
+        @Override
+        protected void onStopMonitoring() {
+        }
+
+        @Override
+        protected void releaseResources(List<Browser> data) {
+        }
+    }
+
+    @Override
+    public void onLoadFinished(Loader<List<Browser>> listLoader, List<Browser> browsers) {
+        if (listLoader.getId() == BROWSER_LOADER_ID)
+            mAdapter.setBrowsers(browsers.toArray(new Browser[browsers.size()]));
+    }
+
+    @Override
+    public void onLoaderReset(Loader<List<Browser>> listLoader) {
+        if (listLoader.getId() == BROWSER_LOADER_ID)
+            mAdapter.clear();
+    }
+}

app/src/main/java/net/i2p/android/help/HelpActivity.java

@@ -0,0 +1,165 @@
+package net.i2p.android.help;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.NavUtils;
+import android.support.v4.app.TaskStackBuilder;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+import android.view.Menu;
+import android.view.MenuItem;
+
+import net.i2p.android.router.LicenseActivity;
+import net.i2p.android.router.R;
+import net.i2p.android.router.dialog.TextResourceDialog;
+import net.i2p.android.util.LocaleManager;
+
+public class HelpActivity extends AppCompatActivity implements
+        HelpListFragment.OnEntrySelectedListener {
+    public static final String CATEGORY = "help_category";
+    public static final int CAT_MAIN = 0;
+    public static final int CAT_CONFIGURE_BROWSER = 1;
+    public static final int CAT_ADDRESSBOOK = 2;
+    public static final int CAT_I2PTUNNEL = 3;
+
+    /**
+     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
+     * device.
+     */
+    private boolean mTwoPane;
+    private int mCategory;
+
+    private final LocaleManager localeManager = new LocaleManager();
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        localeManager.onCreate(this);
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_help);
+
+        // Set the action bar
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        if (findViewById(R.id.detail_fragment) != null) {
+            // The detail container view will be present only in the
+            // large-screen layouts (res/values-large and
+            // res/values-sw600dp). If this view is present, then the
+            // activity should be in two-pane mode.
+            mTwoPane = true;
+        }
+
+        if (savedInstanceState == null) {
+            getSupportFragmentManager().beginTransaction()
+                    .add(R.id.main_fragment, new HelpListFragment())
+                    .commit();
+        }
+
+        mCategory = getIntent().getIntExtra(CATEGORY, -1);
+        if (mCategory >= 0) {
+            showCategory(mCategory);
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        localeManager.onResume(this);
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.activity_help_actions, menu);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case android.R.id.home:
+                if (mCategory >= 0) {
+                    onBackPressed();
+                } else {
+                    Intent upIntent = NavUtils.getParentActivityIntent(this);
+                    if (NavUtils.shouldUpRecreateTask(this, upIntent)) {
+                        // This activity is NOT part of this app's task, so create a new task
+                        // when navigating up, with a synthesized back stack.
+                        TaskStackBuilder.create(this)
+                                // Add all of this activity's parents to the back stack
+                                .addNextIntentWithParentStack(upIntent)
+                                        // Navigate up to the closest parent
+                                .startActivities();
+                    } else {
+                        // This activity is part of this app's task, so simply
+                        // navigate up to the logical parent activity.
+                        NavUtils.navigateUpTo(this, upIntent);
+                    }
+                }
+                return true;
+            case R.id.menu_help_licenses:
+                Intent lic = new Intent(HelpActivity.this, LicenseActivity.class);
+                startActivity(lic);
+                return true;
+            case R.id.menu_help_release_notes:
+                TextResourceDialog dialog = new TextResourceDialog();
+                Bundle args = new Bundle();
+                args.putString(TextResourceDialog.TEXT_DIALOG_TITLE,
+                        getResources().getString(R.string.label_release_notes));
+                args.putInt(TextResourceDialog.TEXT_RESOURCE_ID, R.raw.releasenotes_txt);
+                dialog.setArguments(args);
+                dialog.show(getSupportFragmentManager(), "release_notes");
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    @Override
+    public void onBackPressed() {
+        super.onBackPressed();
+        if (mCategory >= 0)
+            mCategory = -1;
+    }
+
+    // HelpListFragment.OnEntrySelectedListener
+
+    @Override
+    public void onEntrySelected(int entry) {
+        if (entry == CAT_CONFIGURE_BROWSER) {
+            Intent i = new Intent(this, BrowserConfigActivity.class);
+            startActivity(i);
+        } else {
+            mCategory = entry;
+            showCategory(entry);
+        }
+    }
+
+    private void showCategory(int category) {
+        int file;
+        switch (category) {
+            case CAT_ADDRESSBOOK:
+                file = R.raw.help_addressbook;
+                break;
+
+            case CAT_I2PTUNNEL:
+                file = R.raw.help_i2ptunnel;
+                break;
+
+            case CAT_MAIN:
+            default:
+                file = R.raw.help_main;
+                break;
+        }
+        HelpHtmlFragment f = HelpHtmlFragment.newInstance(file);
+        if (mTwoPane) {
+            getSupportFragmentManager().beginTransaction()
+                    .replace(R.id.detail_fragment, f).commit();
+        } else {
+            getSupportFragmentManager().beginTransaction()
+                    .replace(R.id.main_fragment, f)
+                    .addToBackStack("help" + category)
+                    .commit();
+        }
+    }
+}

app/src/main/java/net/i2p/android/help/HelpHtmlFragment.java

@@ -0,0 +1,36 @@
+package net.i2p.android.help;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ScrollView;
+
+import net.i2p.android.router.R;
+
+import org.sufficientlysecure.htmltextview.HtmlTextView;
+
+public class HelpHtmlFragment extends Fragment {
+    public static final String ARG_HTML_FILE = "htmlFile";
+
+    static HelpHtmlFragment newInstance(int htmlFile) {
+        HelpHtmlFragment f = new HelpHtmlFragment();
+        Bundle args = new Bundle();
+        args.putInt(ARG_HTML_FILE, htmlFile);
+        f.setArguments(args);
+        return f;
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        ScrollView scroller = new ScrollView(getActivity());
+        HtmlTextView text = new HtmlTextView(getActivity());
+        scroller.addView(text);
+        int padH = getResources().getDimensionPixelOffset(R.dimen.activity_horizontal_margin);
+        int padV = getResources().getDimensionPixelOffset(R.dimen.activity_vertical_margin);
+        text.setPadding(padH, padV, padH, padV);
+        text.setHtml(getArguments().getInt(ARG_HTML_FILE));
+        return scroller;
+    }
+}

app/src/main/java/net/i2p/android/help/HelpListFragment.java

@@ -0,0 +1,47 @@
+package net.i2p.android.help;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.support.v4.app.ListFragment;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+import net.i2p.android.router.R;
+
+public class HelpListFragment extends ListFragment {
+    OnEntrySelectedListener mEntrySelectedCallback;
+
+    // Container Activity must implement this interface
+    public interface OnEntrySelectedListener {
+        void onEntrySelected(int entry);
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+
+        // This makes sure that the container activity has implemented
+        // the callback interface. If not, it throws an exception
+        try {
+            mEntrySelectedCallback = (OnEntrySelectedListener) activity;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement OnEntrySelectedListener");
+        }
+
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        setListAdapter(ArrayAdapter.createFromResource(getActivity(),
+                R.array.help_categories, R.layout.listitem_text));
+    }
+
+    @Override
+    public void onListItemClick(ListView parent, View view, int pos, long id) {
+        super.onListItemClick(parent, view, pos, id);
+        mEntrySelectedCallback.onEntrySelected(pos);
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelDetailActivity.java

@@ -0,0 +1,65 @@
+package net.i2p.android.i2ptunnel;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.ActivityCompat;
+import android.support.v7.widget.Toolbar;
+import android.view.View;
+
+import net.i2p.android.I2PActivityBase;
+import net.i2p.android.i2ptunnel.preferences.EditTunnelActivity;
+import net.i2p.android.router.R;
+
+public class TunnelDetailActivity extends I2PActivityBase implements
+        TunnelDetailFragment.TunnelDetailListener {
+    private boolean transitionReversed;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        transitionReversed = false;
+
+        if (savedInstanceState == null) {
+            int tunnelId = getIntent().getIntExtra(TunnelDetailFragment.TUNNEL_ID, 0);
+            TunnelDetailFragment detailFrag = TunnelDetailFragment.newInstance(tunnelId);
+            getSupportFragmentManager().beginTransaction()
+                    .add(android.R.id.content, detailFrag).commit();
+        }
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        Toolbar toolbar = (Toolbar) findViewById(R.id.detail_toolbar);
+        toolbar.setNavigationIcon(getResources().getDrawable(R.drawable.ic_arrow_back_white_24dp));
+        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                onBackPressed();
+            }
+        });
+    }
+
+    @Override
+    public void finish() {
+        if (transitionReversed)
+            super.finish();
+        else {
+            transitionReversed = true;
+            ActivityCompat.finishAfterTransition(this);
+        }
+    }
+
+    // TunnelDetailFragment.TunnelDetailListener
+
+    @Override
+    public void onEditTunnel(int tunnelId) {
+        Intent editIntent = new Intent(this, EditTunnelActivity.class);
+        editIntent.putExtra(TunnelDetailFragment.TUNNEL_ID, tunnelId);
+        startActivity(editIntent);
+    }
+
+    public void onTunnelDeleted(int tunnelId, int numTunnelsLeft) {
+        finish();
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelDetailFragment.java

@@ -0,0 +1,380 @@
+package net.i2p.android.i2ptunnel;
+
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.ActivityNotFoundException;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.Fragment;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.widget.Toolbar;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.i2p.I2PAppContext;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.android.util.FragmentUtils;
+import net.i2p.app.ClientAppState;
+import net.i2p.i2ptunnel.TunnelController;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+
+import java.util.List;
+
+public class TunnelDetailFragment extends Fragment {
+    public static final String TUNNEL_ID = "tunnel_id";
+
+    TunnelDetailListener mCallback;
+    private TunnelControllerGroup mGroup;
+    private TunnelEntry mTunnel;
+    private Toolbar mToolbar;
+    private ImageView mStatus;
+
+    public static TunnelDetailFragment newInstance(int tunnelId) {
+        TunnelDetailFragment f = new TunnelDetailFragment();
+        Bundle args = new Bundle();
+        args.putInt(TUNNEL_ID, tunnelId);
+        f.setArguments(args);
+        return f;
+    }
+
+    // Container Activity must implement this interface
+    public interface TunnelDetailListener {
+        void onEditTunnel(int tunnelId);
+        void onTunnelDeleted(int tunnelId, int numTunnelsLeft);
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+
+        // This makes sure that the container activity has implemented
+        // the callback interface. If not, it throws an exception
+        mCallback = FragmentUtils.getParent(this, TunnelDetailListener.class);
+        if (mCallback == null)
+            throw new ClassCastException("Parent must implement TunnelDetailListener");
+
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        String error;
+        List<TunnelController> controllers;
+        try {
+            mGroup = TunnelControllerGroup.getInstance();
+            error = mGroup == null ? getResources().getString(R.string.i2ptunnel_not_initialized) : null;
+            controllers = mGroup.getControllers();
+        } catch (IllegalArgumentException iae) {
+            mGroup = null;
+            controllers = null;
+            error = iae.toString();
+        }
+
+        if (mGroup == null) {
+            Toast.makeText(getActivity().getApplicationContext(),
+                    error, Toast.LENGTH_LONG).show();
+            getActivity().finish();
+        } else if (getArguments().containsKey(TUNNEL_ID)) {
+            int tunnelId = getArguments().getInt(TUNNEL_ID);
+            try {
+                TunnelController controller = controllers.get(tunnelId);
+                mTunnel = new TunnelEntry(getActivity(), controller, tunnelId);
+            } catch (IndexOutOfBoundsException e) {
+                // Tunnel doesn't exist
+                Util.e("Could not load tunnel details", e);
+                Toast.makeText(getActivity().getApplicationContext(),
+                        R.string.i2ptunnel_no_tunnel_details, Toast.LENGTH_LONG).show();
+                getActivity().finish();
+            }
+        }
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.fragment_i2ptunnel_detail, container, false);
+
+        mToolbar = (Toolbar) v.findViewById(R.id.detail_toolbar);
+        mToolbar.inflateMenu(R.menu.fragment_i2ptunnel_detail_actions);
+        mToolbar.setOnMenuItemClickListener(new Toolbar.OnMenuItemClickListener() {
+            @Override
+            public boolean onMenuItemClick(MenuItem menuItem) {
+                return onToolbarItemSelected(menuItem);
+            }
+        });
+        updateToolbar();
+
+        if (mTunnel != null) {
+            mStatus = (ImageView) v.findViewById(R.id.tunnel_status);
+            updateStatus();
+            ViewCompat.setTransitionName(mStatus, "status" + mTunnel.getId());
+
+            TextView name = (TextView) v.findViewById(R.id.tunnel_name);
+            name.setText(mTunnel.getName());
+
+            TextView type = (TextView) v.findViewById(R.id.tunnel_type);
+            type.setText(mTunnel.getType());
+
+            TextView description = (TextView) v.findViewById(R.id.tunnel_description);
+            description.setText(mTunnel.getDescription());
+
+            if (!mTunnel.getDetails().isEmpty()) {
+                v.findViewById(R.id.tunnel_details_container).setVisibility(View.VISIBLE);
+                TextView details = (TextView) v.findViewById(R.id.tunnel_details);
+                View copyDetails = v.findViewById(R.id.tunnel_details_copy);
+                details.setText(mTunnel.getDetails());
+                if (!mTunnel.isClient()) {
+                    copyDetails.setVisibility(View.VISIBLE);
+                    copyDetails.setOnClickListener(new View.OnClickListener() {
+                        @Override
+                        public void onClick(View view) {
+                            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB)
+                                copyToClipbardLegacy();
+                            else
+                                copyToClipboardHoneycomb();
+
+                            Toast.makeText(getActivity(), R.string.address_copied_to_clipboard, Toast.LENGTH_SHORT).show();
+                        }
+                    });
+                }
+            }
+
+            View accessIfacePortItem = v.findViewById(R.id.tunnel_access_interface_port_item);
+            TextView accessIfacePort = (TextView) v.findViewById(R.id.tunnel_access_interface_port);
+            View accessIfaceOpen = v.findViewById(R.id.tunnel_access_open);
+            View targetIfacePortItem = v.findViewById(R.id.tunnel_target_interface_port_item);
+            TextView targetIfacePort = (TextView) v.findViewById(R.id.tunnel_target_interface_port);
+            View targetIfaceOpen = v.findViewById(R.id.tunnel_target_open);
+            switch (mTunnel.getInternalType()) {
+                case "httpbidirserver":
+                    accessIfacePort.setText(mTunnel.getClientLink(false));
+                    setupOpen(accessIfaceOpen, true);
+                    v.findViewById(R.id.icon_link_access).setVisibility(View.GONE);
+                    targetIfacePort.setText(mTunnel.getServerLink(false));
+                    setupOpen(targetIfaceOpen, false);
+                    break;
+                case "streamrserver":
+                    accessIfacePort.setText(mTunnel.getServerLink(false));
+                    setupOpen(accessIfaceOpen, true);
+                    targetIfacePortItem.setVisibility(View.GONE);
+                    break;
+                case "streamrclient":
+                    accessIfacePortItem.setVisibility(View.GONE);
+                    targetIfacePort.setText(mTunnel.getClientLink(false));
+                    setupOpen(targetIfaceOpen, false);
+                    break;
+                default:
+                    if (mTunnel.isClient()) {
+                        accessIfacePort.setText(mTunnel.getClientLink(false));
+                        setupOpen(accessIfaceOpen, true);
+                        targetIfacePortItem.setVisibility(View.GONE);
+                    } else {
+                        accessIfacePortItem.setVisibility(View.GONE);
+                        targetIfacePort.setText(mTunnel.getServerLink(false));
+                        setupOpen(targetIfaceOpen, false);
+                    }
+            }
+
+            CheckBox autoStart = (CheckBox) v.findViewById(R.id.tunnel_autostart);
+            autoStart.setChecked(mTunnel.startAutomatically());
+        }
+
+        return v;
+    }
+
+    private void setupOpen(View open, final boolean client) {
+        if (mTunnel.isRunning() &&
+                (client ? mTunnel.isClientLinkValid() : mTunnel.isServerLinkValid())) {
+            open.setVisibility(View.VISIBLE);
+            open.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View view) {
+                    Intent i = new Intent(Intent.ACTION_VIEW);
+                    i.setData(Uri.parse(client ? mTunnel.getClientLink(true) : mTunnel.getServerLink(true)));
+                    try {
+                        startActivity(i);
+                    } catch (ActivityNotFoundException e) {
+                        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+                        builder.setTitle(R.string.install_recommended_app)
+                                .setMessage(R.string.app_needed_for_this_tunnel_type)
+                                .setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
+                                    public void onClick(DialogInterface dialogInterface, int i) {
+                                        Uri uri = mTunnel.getRecommendedAppForTunnel();
+                                        if (uri != null) {
+                                            Intent intent = new Intent(Intent.ACTION_VIEW, uri);
+                                            try {
+                                                startActivity(intent);
+                                            } catch (ActivityNotFoundException e) {
+                                                Toast.makeText(getContext(),
+                                                        R.string.no_market_app,
+                                                        Toast.LENGTH_LONG).show();
+                                            }
+                                        }
+                                    }
+                                })
+                                .setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
+                                    public void onClick(DialogInterface dialogInterface, int i) {
+                                    }
+                                });
+                        builder.show();
+                    }
+                }
+            });
+        } else
+            open.setVisibility(View.GONE);
+    }
+
+    private void updateToolbar() {
+        Menu menu = mToolbar.getMenu();
+        MenuItem start = menu.findItem(R.id.action_start_tunnel);
+        MenuItem stop = menu.findItem(R.id.action_stop_tunnel);
+
+        if (mTunnel != null && mGroup != null &&
+                (mGroup.getState() == ClientAppState.STARTING ||
+                        mGroup.getState() == ClientAppState.RUNNING)) {
+            boolean isStopped = mTunnel.getStatus() == TunnelEntry.NOT_RUNNING;
+
+            start.setVisible(isStopped);
+            start.setEnabled(isStopped);
+
+            stop.setVisible(!isStopped);
+            stop.setEnabled(!isStopped);
+        } else {
+            start.setVisible(false);
+            start.setEnabled(false);
+
+            stop.setVisible(false);
+            stop.setEnabled(false);
+        }
+    }
+
+    private void updateStatus() {
+        mStatus.setImageDrawable(mTunnel.getStatusIcon());
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN)
+            mStatus.setBackgroundDrawable(mTunnel.getStatusBackground());
+        else
+            mStatus.setBackground(mTunnel.getStatusBackground());
+    }
+
+    private boolean onToolbarItemSelected(MenuItem item) {
+        if (mTunnel == null)
+            return false;
+
+        // Handle presses on the action bar items
+        switch (item.getItemId()) {
+        case R.id.action_start_tunnel:
+            mTunnel.getController().startTunnelBackground();
+            Toast.makeText(getActivity().getApplicationContext(),
+                    getResources().getString(R.string.i2ptunnel_msg_tunnel_starting)
+                    + ' ' + mTunnel.getName(), Toast.LENGTH_LONG).show();
+            // Reload the toolbar to change the start/stop action
+            updateToolbar();
+            // Update the status icon
+            updateStatus();
+            return true;
+        case R.id.action_stop_tunnel:
+            mTunnel.getController().stopTunnel();
+            Toast.makeText(getActivity().getApplicationContext(),
+                    getResources().getString(R.string.i2ptunnel_msg_tunnel_stopping)
+                    + ' ' + mTunnel.getName(), Toast.LENGTH_LONG).show();
+            // Reload the toolbar to change the start/stop action
+            updateToolbar();
+            // Update the status icon
+            updateStatus();
+            return true;
+        case R.id.action_edit_tunnel:
+            mCallback.onEditTunnel(mTunnel.getId());
+            return true;
+        case R.id.action_delete_tunnel:
+            DialogFragment dg = DeleteTunnelDialogFragment.newInstance();
+            dg.show(getChildFragmentManager(), "delete_tunnel_dialog");
+            return true;
+        default:
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    private void onDeleteTunnel() {
+        List<String> msgs = TunnelUtil.deleteTunnel(
+                I2PAppContext.getGlobalContext(),
+                mGroup, mTunnel.getId(), null);
+        Toast.makeText(getActivity().getApplicationContext(),
+                msgs.get(0), Toast.LENGTH_LONG).show();
+        mCallback.onTunnelDeleted(mTunnel.getId(),
+                mGroup.getControllers().size());
+    }
+
+    private void copyToClipbardLegacy() {
+        android.text.ClipboardManager clipboard = (android.text.ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+        clipboard.setText(mTunnel.getDetails());
+    }
+
+    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+    private void copyToClipboardHoneycomb() {
+        android.content.ClipboardManager clipboard = (android.content.ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+        android.content.ClipData clip = android.content.ClipData.newPlainText(
+                mTunnel.getName(), mTunnel.getDetails());
+        clipboard.setPrimaryClip(clip);
+    }
+
+    public static class DeleteTunnelDialogFragment extends DialogFragment {
+        TunnelDetailFragment mListener;
+
+        public static DialogFragment newInstance() {
+            return new DeleteTunnelDialogFragment();
+        }
+
+        private void onAttachToParentFragment(Fragment fragment) {
+            // Verify that the host fragment implements the callback interface
+            try {
+                // Instantiate the TunnelDetailFragment so we can send events to the host
+                mListener = (TunnelDetailFragment) fragment;
+            } catch (ClassCastException e) {
+                // The fragment doesn't implement the interface, throw exception
+                throw new ClassCastException(fragment.toString()
+                        + " must be TunnelDetailFragment");
+            }
+        }
+
+        @Override
+        public void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+            onAttachToParentFragment(getParentFragment());
+        }
+
+        @NonNull
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            return new AlertDialog.Builder(getActivity())
+                    .setMessage(R.string.i2ptunnel_delete_confirm_message)
+                    .setPositiveButton(R.string.i2ptunnel_delete_confirm_button,
+                            new DialogInterface.OnClickListener() {
+
+                                public void onClick(DialogInterface dialog, int which) {
+                                    dialog.dismiss();
+                                    mListener.onDeleteTunnel();
+                                }
+                            })
+                    .setNegativeButton(android.R.string.cancel, null)
+                    .create();
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelEntry.java

@@ -0,0 +1,307 @@
+package net.i2p.android.i2ptunnel;
+
+import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.net.Uri;
+import android.widget.Toast;
+
+import net.i2p.I2PAppContext;
+import net.i2p.android.i2ptunnel.util.SaveTunnelTask;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.data.Destination;
+import net.i2p.data.PrivateKeyFile;
+import net.i2p.i2ptunnel.TunnelController;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.i2ptunnel.ui.TunnelConfig;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+
+public class TunnelEntry {
+    public static final int RUNNING = 1;
+    public static final int STARTING = 2;
+    public static final int NOT_RUNNING = 3;
+    public static final int STANDBY = 4;
+
+    private final Context mContext;
+    private final TunnelController mController;
+    private final int mId;
+
+    /**
+     * @return the new TunnelEntry, or null if there was an error.
+     */
+    public static TunnelEntry createNewTunnel(
+            Context ctx,
+            TunnelControllerGroup tcg,
+            TunnelConfig cfg) {
+        int tunnelId = tcg.getControllers().size();
+        TunnelEntry ret = null;
+        List<String> msgs = new ArrayList<>();
+        SaveTunnelTask task = new SaveTunnelTask(tcg, -1, cfg);
+        try {
+            msgs.addAll(task.execute().get());
+            TunnelController cur = TunnelUtil.getController(tcg, tunnelId);
+            ret = new TunnelEntry(ctx, cur, tunnelId);
+        } catch (InterruptedException e) {
+            Util.e("Interrupted while saving tunnel config", e);
+            msgs.add(ctx.getString(R.string.i2ptunnel_msg_config_save_failed));
+        } catch (ExecutionException e) {
+            Util.e("Error while saving tunnel config", e);
+            msgs.add(ctx.getString(R.string.i2ptunnel_msg_config_save_failed));
+        }
+        // TODO: Do something else with the other messages.
+        Toast.makeText(ctx.getApplicationContext(),
+                msgs.get(0), Toast.LENGTH_LONG).show();
+        return ret;
+    }
+
+    public TunnelEntry(Context context, TunnelController controller, int id) {
+        mContext = context;
+        mController = controller;
+        mId = id;
+    }
+
+    public int getId() {
+        return mId;
+    }
+
+    public TunnelController getController() {
+        return mController;
+    }
+
+    /* General tunnel data for any type */
+
+    public String getName() {
+        if (mController.getName() != null)
+            return mController.getName();
+        else
+            return mContext.getResources()
+                    .getString(R.string.i2ptunnel_new_tunnel);
+    }
+
+    public String getInternalType() {
+        return mController.getType();
+    }
+
+    public String getType() {
+        return TunnelUtil.getTypeName(mController.getType(), mContext);
+    }
+
+    public String getDescription() {
+        String rv = mController.getDescription();
+        if (rv != null)
+            return rv;
+        return "";
+    }
+
+    public boolean startAutomatically() {
+        return mController.getStartOnLoad();
+    }
+
+    public int getStatus() {
+        if (mController.getIsRunning()) {
+            if (isClient() && mController.getIsStandby())
+                return STANDBY;
+            else
+                return RUNNING;
+        } else if (mController.getIsStarting()) return STARTING;
+        else return NOT_RUNNING;
+    }
+
+    public boolean isRunning() {
+        switch (getStatus()) {
+            case STANDBY:
+            case RUNNING:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public boolean isClient() {
+        return TunnelUtil.isClient(mController.getType());
+    }
+
+    /* Client tunnel data */
+
+    public boolean isSharedClient() {
+        return Boolean.parseBoolean(mController.getSharedClient());
+    }
+
+    /**
+     * Call this to see if it is okay to linkify getClientLink()
+     * @return true if getClientLink() can be linkified, false otherwise.
+     */
+    public boolean isClientLinkValid() {
+        return ("ircclient".equals(mController.getType())) &&
+                mController.getListenOnInterface() != null &&
+                mController.getListenPort() != null;
+    }
+
+    /**
+     * @return valid host:port only if isClientLinkValid() is true
+     */
+    public String getClientLink(boolean linkify) {
+        String host = getClientInterface();
+        String port = getClientPort();
+        String link =  host + ":" + port;
+        if (linkify) {
+            if ("ircclient".equals(mController.getType()))
+                link = "irc://" + link;
+        }
+        return link;
+    }
+
+    public String getClientInterface() {
+        String rv;
+        if ("streamrclient".equals(mController.getType()))
+            rv = mController.getTargetHost();
+        else
+            rv = mController.getListenOnInterface();
+        return rv != null ? rv : "";
+    }
+
+    public String getClientPort() {
+        String rv = mController.getListenPort();
+        return rv != null ? rv : "";
+    }
+
+    public String getClientDestination() {
+        String rv;
+        if ("client".equals(getInternalType()) ||
+                "ircclient".equals(getInternalType()) ||
+                "streamrclient".equals(getInternalType()))
+            rv = mController.getTargetDestination();
+        else
+            rv = mController.getProxyList();
+        return rv != null ? rv : "";
+    }
+
+    /* Server tunnel data */
+
+    /**
+     * Call this to see if it is okay to linkify getServerLink()
+     * @return true if getServerLink() can be linkified, false otherwise.
+     */
+    public boolean isServerLinkValid() {
+        return ("httpserver".equals(mController.getType()) ||
+                "httpbidirserver".equals(mController.getType())) &&
+                mController.getTargetHost() != null &&
+                mController.getTargetPort() != null;
+    }
+
+    /**
+     * @return valid host:port only if isServerLinkValid() is true
+     */
+    public String getServerLink(boolean linkify) {
+        String host;
+        if ("streamrserver".equals(getInternalType()))
+            host = mController.getListenOnInterface();
+        else
+            host = mController.getTargetHost();
+        String port = mController.getTargetPort();
+        if (host == null) host = "";
+        if (port == null) port = "";
+        if (host.indexOf(':') >= 0)
+            host = '[' + host + ']';
+        String link =  host + ":" + port;
+        if (linkify) {
+            if ("httpserver".equals(mController.getType()) ||
+                    "httpbidirserver".equals(mController.getType()))
+                link = "http://" + link;
+        }
+        return link;
+    }
+
+    public String getDestinationBase64() {
+        String rv = mController.getMyDestination();
+        if (rv != null)
+            return rv;
+        // if not running, do this the hard way
+        String keyFile = mController.getPrivKeyFile();
+        if (keyFile != null && keyFile.trim().length() > 0) {
+            PrivateKeyFile pkf = new PrivateKeyFile(keyFile);
+            try {
+                Destination d = pkf.getDestination();
+                if (d != null)
+                    return d.toBase64();
+            } catch (Exception e) {}
+        }
+        return "";
+    }
+
+    public String getDestHashBase32() {
+        String rv = mController.getMyDestHashBase32();
+        if (rv != null)
+            return rv;
+        return "";
+    }
+
+    /* Data for some client and server tunnels */
+
+    /* Other output formats */
+
+    public boolean isTunnelLinkValid() {
+        if (isClient()) return isClientLinkValid();
+        else return isServerLinkValid();
+    }
+
+    public String getTunnelLink(boolean linkify) {
+        if (isClient()) return getClientLink(linkify);
+        else return getServerLink(linkify);
+    }
+
+    public Uri getRecommendedAppForTunnel() {
+        int resId = 0;
+        if ("ircclient".equals(mController.getType()))
+            resId = R.string.market_irc;
+
+        if (resId > 0)
+            return Uri.parse(mContext.getString(resId));
+        else
+            return null;
+    }
+
+    public String getDetails() {
+        String details;
+        if (isClient())
+            details = getClientDestination();
+        else
+            details = getDestHashBase32();
+        return details;
+    }
+
+    public Drawable getStatusIcon() {
+        switch (getStatus()) {
+        case STANDBY:
+            return mContext.getResources()
+                    .getDrawable(R.drawable.ic_schedule_black_24dp);
+        case STARTING:
+            return mContext.getResources()
+                    .getDrawable(R.drawable.ic_sync_black_24dp);
+        case RUNNING:
+        case NOT_RUNNING:
+        default:
+            return null;
+        }
+    }
+
+    public Drawable getStatusBackground() {
+        switch (getStatus()) {
+            case STANDBY:
+            case STARTING:
+                return mContext.getResources()
+                        .getDrawable(R.drawable.tunnel_yellow);
+            case RUNNING:
+                return mContext.getResources()
+                        .getDrawable(R.drawable.tunnel_green);
+            case NOT_RUNNING:
+            default:
+                return mContext.getResources()
+                        .getDrawable(R.drawable.tunnel_red);
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelEntryAdapter.java

@@ -0,0 +1,184 @@
+package net.i2p.android.i2ptunnel;
+
+import android.content.Context;
+import android.os.Build;
+import android.support.v4.util.Pair;
+import android.support.v4.view.ViewCompat;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import net.i2p.android.router.R;
+import net.i2p.android.util.FragmentUtils;
+
+import java.util.List;
+
+public class TunnelEntryAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> {
+    private Context mCtx;
+    private boolean mClientTunnels;
+    private TunnelListFragment.OnTunnelSelectedListener mListener;
+    private FragmentUtils.TwoPaneProvider mTwoPane;
+    private List<TunnelEntry> mTunnels;
+    /**
+     * The current activated item position. Only used on tablets.
+     */
+    private int mActivatedPosition = -1;
+
+    public static class SimpleViewHolder extends RecyclerView.ViewHolder {
+        public SimpleViewHolder(View itemView) {
+            super(itemView);
+        }
+    }
+
+    public static class TunnelViewHolder extends RecyclerView.ViewHolder {
+        public ImageView status;
+        public TextView name;
+        public TextView description;
+        public TextView interfacePort;
+
+        public TunnelViewHolder(View itemView) {
+            super(itemView);
+
+            status = (ImageView) itemView.findViewById(R.id.tunnel_status);
+            name = (TextView) itemView.findViewById(R.id.tunnel_name);
+            description = (TextView) itemView.findViewById(R.id.tunnel_description);
+            interfacePort = (TextView) itemView.findViewById(R.id.tunnel_interface_port);
+        }
+    }
+
+    public TunnelEntryAdapter(Context context, boolean clientTunnels,
+                              TunnelListFragment.OnTunnelSelectedListener listener,
+                              FragmentUtils.TwoPaneProvider twoPane) {
+        super();
+        mCtx = context;
+        mClientTunnels = clientTunnels;
+        mListener = listener;
+        mTwoPane = twoPane;
+    }
+
+    public void setTunnels(List<TunnelEntry> tunnels) {
+        mTunnels = tunnels;
+        notifyDataSetChanged();
+    }
+
+    public void addTunnel(TunnelEntry tunnel) {
+        boolean wasEmpty = mTunnels.isEmpty();
+        mTunnels.add(tunnel);
+        if (wasEmpty) {
+            notifyDataSetChanged();
+        } else {
+            notifyItemInserted(mTunnels.size() - 1);
+        }
+    }
+
+    public TunnelEntry getTunnel(int position) {
+        if (position < 0)
+            return null;
+
+        return mTunnels.get(position);
+    }
+
+    public void setActivatedPosition(int position) {
+        mActivatedPosition = position;
+    }
+
+    public int getActivatedPosition() {
+        return mActivatedPosition;
+    }
+
+    public void clearActivatedPosition() {
+        mActivatedPosition = -1;
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        if (mTunnels == null)
+            return R.string.router_not_running;
+        else if (mTunnels.isEmpty())
+            return R.layout.listitem_empty;
+        else
+            return R.layout.listitem_i2ptunnel;
+    }
+
+    // Create new views (invoked by the layout manager)
+    @Override
+    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        int vt = viewType;
+        if (viewType == R.string.router_not_running)
+            vt = R.layout.listitem_empty;
+
+        View v = LayoutInflater.from(parent.getContext())
+                .inflate(vt, parent, false);
+        switch (viewType) {
+            case R.layout.listitem_i2ptunnel:
+                return new TunnelViewHolder(v);
+            default:
+                return new SimpleViewHolder(v);
+        }
+    }
+
+    // Replace the contents of a view (invoked by the layout manager)
+    @Override
+    public void onBindViewHolder(RecyclerView.ViewHolder holder, final int position) {
+        switch (holder.getItemViewType()) {
+            case R.string.router_not_running:
+                ((TextView) holder.itemView).setText(
+                        mCtx.getString(R.string.router_not_running));
+                break;
+
+            case R.layout.listitem_empty:
+                ((TextView) holder.itemView).setText(mClientTunnels ?
+                        R.string.no_configured_client_tunnels :
+                        R.string.no_configured_server_tunnels);
+                break;
+
+            case R.layout.listitem_i2ptunnel:
+                final TunnelViewHolder tvh = (TunnelViewHolder) holder;
+                final TunnelEntry tunnel = getTunnel(position);
+
+                tvh.status.setImageDrawable(tunnel.getStatusIcon());
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN)
+                    tvh.status.setBackgroundDrawable(tunnel.getStatusBackground());
+                else
+                    tvh.status.setBackground(tunnel.getStatusBackground());
+                ViewCompat.setTransitionName(tvh.status,
+                        "status" + tunnel.getId());
+
+                tvh.name.setText(tunnel.getName());
+                tvh.description.setText(tunnel.getDescription());
+                tvh.interfacePort.setText(tunnel.getTunnelLink(false));
+
+                tvh.itemView.setSelected(mTwoPane.isTwoPane() && position == mActivatedPosition);
+                tvh.itemView.setOnClickListener(new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        int oldPosition = mActivatedPosition;
+                        mActivatedPosition = position;
+                        notifyItemChanged(oldPosition);
+                        notifyItemChanged(position);
+                        Pair<View, String> statusPair = Pair.create(
+                                (View)tvh.status,
+                                ViewCompat.getTransitionName(tvh.status));
+                        Pair<View, String>[] pairs = new Pair[]{ statusPair};
+                        mListener.onTunnelSelected(tunnel.getId(), pairs);
+                    }
+                });
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    // Return the size of the dataset (invoked by the layout manager)
+    @Override
+    public int getItemCount() {
+        if (mTunnels == null || mTunnels.isEmpty())
+            return 1;
+
+        return mTunnels.size();
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelEntryLoader.java

@@ -0,0 +1,148 @@
+package net.i2p.android.i2ptunnel;
+
+import android.content.Context;
+import android.os.Handler;
+import android.support.v4.content.AsyncTaskLoader;
+
+import net.i2p.android.router.util.Util;
+import net.i2p.i2ptunnel.TunnelController;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.router.RouterContext;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TunnelEntryLoader extends AsyncTaskLoader<List<TunnelEntry>> {
+    private TunnelControllerGroup mGroup;
+    private boolean mClientTunnels;
+    private List<TunnelEntry> mData;
+    private Handler mHandler;
+    private TunnelControllerMonitor mMonitor;
+
+    public TunnelEntryLoader(Context context, TunnelControllerGroup tcg, boolean clientTunnels) {
+        super(context);
+        mGroup = tcg;
+        mClientTunnels = clientTunnels;
+        mHandler = new Handler();
+    }
+
+    @Override
+    public List<TunnelEntry> loadInBackground() {
+        // Don't load tunnels if the router is not running
+        // TODO: in future we might be able to view and edit tunnels while router is not running
+        RouterContext routerContext = Util.getRouterContext();
+        if (routerContext == null)
+            return null;
+
+        List<TunnelEntry> ret = new ArrayList<>();
+        List<TunnelController> controllers = mGroup.getControllers();
+        for (int i = 0; i < controllers.size(); i++) {
+            TunnelEntry tunnel = new TunnelEntry(getContext(), controllers.get(i), i);
+            if ( (mClientTunnels && tunnel.isClient()) ||
+                 (!mClientTunnels && !tunnel.isClient()) )
+                ret.add(tunnel);
+        }
+        return ret;
+    }
+
+    @Override
+    public void deliverResult(List<TunnelEntry> data) {
+        if (isReset()) {
+            // The Loader has been reset; ignore the result and invalidate the data.
+            if (data != null) {
+                releaseResources(data);
+                return;
+            }
+        }
+
+        // Hold a reference to the old data so it doesn't get garbage collected.
+        // We must protect it until the new data has been delivered.
+        List<TunnelEntry> oldData = mData;
+        mData = data;
+
+        if (isStarted()) {
+            // If the Loader is in a started state, have the superclass deliver the
+            // results to the client.
+            super.deliverResult(data);
+        }
+
+        // Invalidate the old data as we don't need it any more.
+        if (oldData != null && oldData != data) {
+            releaseResources(oldData);
+        }
+    }
+
+    @Override
+    protected void onStartLoading() {
+        if (mData != null) {
+            // Deliver any previously loaded data immediately.
+            deliverResult(mData);
+        }
+
+        // Begin monitoring the underlying data source.
+        mMonitor = new TunnelControllerMonitor();
+        mHandler.postDelayed(mMonitor, 50);
+
+        if (takeContentChanged() || mData == null) {
+            // When the observer detects a change, it should call onContentChanged()
+            // on the Loader, which will cause the next call to takeContentChanged()
+            // to return true. If this is ever the case (or if the current data is
+            // null), we force a new load.
+            forceLoad();
+        }
+    }
+
+    @Override
+    protected void onStopLoading() {
+        // The Loader is in a stopped state, so we should attempt to cancel the 
+        // current load (if there is one).
+        cancelLoad();
+
+        // Note that we leave the observer as is. Loaders in a stopped state
+        // should still monitor the data source for changes so that the Loader
+        // will know to force a new load if it is ever started again.
+    }
+
+    @Override
+    protected void onReset() {
+        // Ensure the loader has been stopped.
+        onStopLoading();
+
+        // At this point we can release the resources associated with 'mData'.
+        if (mData != null) {
+            releaseResources(mData);
+            mData = null;
+        }
+
+        // The Loader is being reset, so we should stop monitoring for changes.
+        if (mMonitor != null) {
+            mHandler.removeCallbacks(mMonitor);
+            mMonitor = null;
+        }
+    }
+
+    @Override
+    public void onCanceled(List<TunnelEntry> data) {
+        // Attempt to cancel the current asynchronous load.
+        super.onCanceled(data);
+
+        // The load has been canceled, so we should release the resources
+        // associated with 'data'.
+        releaseResources(data);
+    }
+
+    private void releaseResources(List<TunnelEntry> data) {
+        // For a simple List, there is nothing to do. For something like a Cursor, we 
+        // would close it in this method. All resources associated with the Loader
+        // should be released here.
+    }
+
+    private class TunnelControllerMonitor implements Runnable {
+        public void run() {
+            // There is no way (yet) to monitor for changes to the list of
+            // TunnelControllers, so just force a refresh every 10 seconds.
+            onContentChanged();
+            mHandler.postDelayed(this, 10 * 1000);
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelListFragment.java

@@ -0,0 +1,239 @@
+package net.i2p.android.i2ptunnel;
+
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v4.util.Pair;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.pnikosis.materialishprogress.ProgressWheel;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.service.RouterService;
+import net.i2p.android.router.service.State;
+import net.i2p.android.router.util.Util;
+import net.i2p.android.util.FragmentUtils;
+import net.i2p.android.widget.DividerItemDecoration;
+import net.i2p.android.widget.LoadingRecyclerView;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TunnelListFragment extends Fragment implements
+        LoaderManager.LoaderCallbacks<List<TunnelEntry>> {
+    public static final String SHOW_CLIENT_TUNNELS = "show_client_tunnels";
+
+    private static final int CLIENT_LOADER_ID = 1;
+    private static final int SERVER_LOADER_ID = 2;
+    /**
+     * The serialization (saved instance state) Bundle key representing the
+     * activated item position. Only used on tablets.
+     */
+    private static final String STATE_ACTIVATED_POSITION = "activated_position";
+
+    OnTunnelSelectedListener mCallback;
+    FragmentUtils.TwoPaneProvider mTwoPane;
+    private TunnelControllerGroup mGroup;
+
+    private LoadingRecyclerView mRecyclerView;
+    private TunnelEntryAdapter mAdapter;
+    private boolean mClientTunnels;
+
+    // Container Activity must implement this interface
+    public interface OnTunnelSelectedListener {
+        void onTunnelSelected(int tunnelId, Pair<View, String>[] pairs);
+    }
+
+    public static TunnelListFragment newInstance(boolean showClientTunnels) {
+        TunnelListFragment f = new TunnelListFragment();
+        Bundle args = new Bundle();
+        args.putBoolean(TunnelListFragment.SHOW_CLIENT_TUNNELS, showClientTunnels);
+        f.setArguments(args);
+        return f;
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+
+        // This makes sure that the container activity has implemented
+        // the callback interface. If not, it throws an exception
+        mCallback = FragmentUtils.getParent(this, OnTunnelSelectedListener.class);
+        if (mCallback == null)
+            throw new ClassCastException("Parent must implement OnTunnelSelectedListener");
+        mTwoPane = FragmentUtils.getParent(this, FragmentUtils.TwoPaneProvider.class);
+        if (mTwoPane == null)
+            throw new ClassCastException("Parent must implement TwoPaneProvider");
+
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.fragment_list, container, false);
+
+        mRecyclerView = (LoadingRecyclerView) v.findViewById(R.id.list);
+        View empty = v.findViewById(R.id.empty);
+        ProgressWheel loading = (ProgressWheel) v.findViewById(R.id.loading);
+        mRecyclerView.setLoadingView(empty, loading);
+
+        return v;
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        mClientTunnels = getArguments().getBoolean(SHOW_CLIENT_TUNNELS);
+
+        mRecyclerView.setHasFixedSize(true);
+        mRecyclerView.addItemDecoration(new DividerItemDecoration(getActivity(), DividerItemDecoration.VERTICAL_LIST));
+
+        // use a linear layout manager
+        RecyclerView.LayoutManager mLayoutManager = new LinearLayoutManager(getActivity());
+        mRecyclerView.setLayoutManager(mLayoutManager);
+
+        // Set the adapter for the list view
+        mAdapter = new TunnelEntryAdapter(getActivity(), mClientTunnels, mCallback, mTwoPane);
+        mRecyclerView.setAdapter(mAdapter);
+
+        // Restore the previously serialized activated item position.
+        if (savedInstanceState != null
+                && savedInstanceState.containsKey(STATE_ACTIVATED_POSITION))
+            mAdapter.setActivatedPosition(savedInstanceState
+                    .getInt(STATE_ACTIVATED_POSITION));
+        else
+            mAdapter.clearActivatedPosition();
+
+        // Initialize the adapter in case the RouterService has not been created
+        if (Util.getRouterContext() == null)
+            mAdapter.setTunnels(null);
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(getActivity());
+
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(RouterService.LOCAL_BROADCAST_STATE_NOTIFICATION);
+        filter.addAction(RouterService.LOCAL_BROADCAST_STATE_CHANGED);
+        lbm.registerReceiver(onStateChange, filter);
+    }
+
+    private State lastRouterState = null;
+    private BroadcastReceiver onStateChange = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            State state = intent.getParcelableExtra(RouterService.LOCAL_BROADCAST_EXTRA_STATE);
+            if (lastRouterState == null || lastRouterState != state) {
+                updateState(state);
+                lastRouterState = state;
+            }
+        }
+    };
+
+    public void updateState(State state) {
+        try {
+            if (state == State.INIT ||
+                    state == State.STARTING || // Wait until RouterContext is initialised
+                    state == State.STOPPING ||
+                    state == State.STOPPED ||
+                    state == State.MANUAL_STOPPING ||
+                    state == State.MANUAL_STOPPED ||
+                    state == State.MANUAL_QUITTING ||
+                    state == State.MANUAL_QUITTED)
+                getLoaderManager().destroyLoader(mClientTunnels ? CLIENT_LOADER_ID : SERVER_LOADER_ID);
+            else
+                initTunnels();
+        } catch (IllegalStateException ise) {
+            // Fragment isn't attached to any activity, so ignore state change
+        }
+    }
+
+    private void initTunnels() {
+        if (mGroup == null) {
+            try {
+                mGroup = TunnelControllerGroup.getInstance();
+            } catch (IllegalArgumentException iae) {
+                Util.e("Could not load tunnels", iae);
+                mGroup = null;
+            }
+        }
+
+        if (mGroup != null && isAdded()) {
+            mRecyclerView.setLoading(true);
+            getLoaderManager().initLoader(mClientTunnels ? CLIENT_LOADER_ID
+                    : SERVER_LOADER_ID, null, this);
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        // Triggers loader init via updateState() if the router is running
+        LocalBroadcastManager.getInstance(getActivity()).sendBroadcast(new Intent(RouterService.LOCAL_BROADCAST_REQUEST_STATE));
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        int activatedPosition = mAdapter.getActivatedPosition();
+        if (activatedPosition >= 0) {
+            // Serialize and persist the activated item position.
+            outState.putInt(STATE_ACTIVATED_POSITION, activatedPosition);
+        }
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+
+        LocalBroadcastManager.getInstance(getActivity()).unregisterReceiver(onStateChange);
+    }
+
+    public void addTunnel(TunnelEntry tunnelEntry) {
+        mAdapter.addTunnel(tunnelEntry);
+    }
+
+    // LoaderManager.LoaderCallbacks<List<TunnelEntry>>
+
+    public Loader<List<TunnelEntry>> onCreateLoader(int id, Bundle args) {
+        return new TunnelEntryLoader(getActivity(), mGroup, mClientTunnels);
+    }
+
+    public void onLoadFinished(Loader<List<TunnelEntry>> loader,
+                               List<TunnelEntry> data) {
+        if (loader.getId() == (mClientTunnels ?
+                CLIENT_LOADER_ID : SERVER_LOADER_ID)) {
+            mAdapter.setTunnels(data);
+        }
+    }
+
+    public void onLoaderReset(Loader<List<TunnelEntry>> loader) {
+        if (loader.getId() == (mClientTunnels ?
+                CLIENT_LOADER_ID : SERVER_LOADER_ID)) {
+            if (Util.getRouterContext() == null)
+                mAdapter.setTunnels(null);
+            else
+                mAdapter.setTunnels(new ArrayList<TunnelEntry>());
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelWizardActivity.java

@@ -0,0 +1,72 @@
+package net.i2p.android.i2ptunnel;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v7.app.AlertDialog;
+
+import net.i2p.android.router.R;
+import net.i2p.android.wizard.model.AbstractWizardModel;
+import net.i2p.android.wizard.ui.AbstractWizardActivity;
+
+public class TunnelWizardActivity extends AbstractWizardActivity {
+    @Override
+    protected AbstractWizardModel onCreateModel() {
+        return new TunnelWizardModel(this);
+    }
+
+    @Override
+    protected DialogFragment onGetFinishWizardDialog() {
+        return FinishWizardDialogFragment.newInstance();
+    }
+
+    public void onFinishWizard() {
+        Intent result = new Intent();
+        result.putExtra(TunnelsContainer.TUNNEL_WIZARD_DATA, mWizardModel.save());
+        setResult(Activity.RESULT_OK, result);
+        finish();
+    }
+
+    public static class FinishWizardDialogFragment extends DialogFragment {
+        TunnelWizardActivity mListener;
+
+        public static DialogFragment newInstance() {
+            return new FinishWizardDialogFragment();
+        }
+
+        public void onAttach(Context context) {
+            super.onAttach(context);
+            // Verify that the host fragment implements the callback interface
+            try {
+                // Instantiate the TunnelWizardActivity so we can send events to the host
+                mListener = (TunnelWizardActivity) context;
+            } catch (ClassCastException e) {
+                // The fragment doesn't implement the interface, throw exception
+                throw new ClassCastException(context.toString()
+                        + " must be TunnelWizardActivity");
+            }
+        }
+
+        @NonNull
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            return new AlertDialog.Builder(getActivity())
+                    .setMessage(R.string.i2ptunnel_wizard_submit_confirm_message)
+                    .setPositiveButton(R.string.i2ptunnel_wizard_submit_confirm_button,
+                            new DialogInterface.OnClickListener() {
+
+                                public void onClick(DialogInterface dialog, int which) {
+                                    dialog.dismiss();
+                                    mListener.onFinishWizard();
+                                }
+                            })
+                    .setNegativeButton(android.R.string.cancel, null)
+                    .create();
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelWizardModel.java

@@ -0,0 +1,125 @@
+package net.i2p.android.i2ptunnel;
+
+import android.content.Context;
+import android.content.res.Resources;
+import net.i2p.android.router.R;
+import net.i2p.android.wizard.model.AbstractWizardModel;
+import net.i2p.android.wizard.model.BranchPage;
+import net.i2p.android.wizard.model.Conditional;
+import net.i2p.android.wizard.model.I2PDestinationPage;
+import net.i2p.android.wizard.model.PageList;
+import net.i2p.android.wizard.model.SingleFixedBooleanPage;
+import net.i2p.android.wizard.model.SingleFixedChoicePage;
+import net.i2p.android.wizard.model.SingleTextFieldPage;
+
+public class TunnelWizardModel extends AbstractWizardModel {
+    public TunnelWizardModel(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected PageList onNewRootPageList() {
+        Resources res = mContext.getResources();
+        Conditional cTunnelType = new Conditional();
+        Conditional cClientType = new Conditional();
+        Conditional cServerType = new Conditional();
+
+        return new PageList(
+            new BranchPage(this, res.getString(R.string.i2ptunnel_wizard_k_client_server))
+                .addBranch(res.getString(R.string.i2ptunnel_wizard_v_client),
+                    new SingleFixedChoicePage(this, res.getString(R.string.i2ptunnel_wizard_k_type))
+                        .setChoices(
+                                res.getString(R.string.i2ptunnel_type_client),
+                                res.getString(R.string.i2ptunnel_type_httpclient),
+                                res.getString(R.string.i2ptunnel_type_ircclient),
+                                res.getString(R.string.i2ptunnel_type_sockstunnel),
+                                res.getString(R.string.i2ptunnel_type_socksirctunnel),
+                                res.getString(R.string.i2ptunnel_type_connectclient),
+                                res.getString(R.string.i2ptunnel_type_streamrclient))
+                        .setRequired(true)
+                        .makeConditional(cClientType))
+                .addBranch(res.getString(R.string.i2ptunnel_wizard_v_server),
+                    new SingleFixedChoicePage(this, res.getString(R.string.i2ptunnel_wizard_k_type))
+                        .setChoices(
+                                res.getString(R.string.i2ptunnel_type_server),
+                                res.getString(R.string.i2ptunnel_type_httpserver),
+                                res.getString(R.string.i2ptunnel_type_httpbidirserver),
+                                res.getString(R.string.i2ptunnel_type_ircserver),
+                                res.getString(R.string.i2ptunnel_type_streamrserver))
+                        .setRequired(true)
+                        .makeConditional(cServerType))
+                .setRequired(true)
+                .makeConditional(cTunnelType),
+
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_name))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_name))
+                .setRequired(true),
+
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_desc))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_desc)),
+
+            new I2PDestinationPage(this, res.getString(R.string.i2ptunnel_wizard_k_dest))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_dest))
+                .setRequired(true)
+                .setEqualAnyCondition(cClientType,
+                        res.getString(R.string.i2ptunnel_type_client),
+                        res.getString(R.string.i2ptunnel_type_ircclient),
+                        res.getString(R.string.i2ptunnel_type_streamrclient)),
+
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_outproxies))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_outproxies))
+                .setEqualAnyCondition(cClientType,
+                        res.getString(R.string.i2ptunnel_type_httpclient),
+                        res.getString(R.string.i2ptunnel_type_connectclient),
+                        res.getString(R.string.i2ptunnel_type_sockstunnel),
+                        res.getString(R.string.i2ptunnel_type_socksirctunnel)),
+
+            // Not set required because a default is specified.
+            // Otherwise user would need to edit the field to
+            // enable the Next button.
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_target_host))
+                .setDefault("127.0.0.1")
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_target_host))
+                .setEqualCondition(cClientType,
+                        res.getString(R.string.i2ptunnel_type_streamrclient))
+                .setEqualAnyCondition(cServerType,
+                        res.getString(R.string.i2ptunnel_type_server),
+                        res.getString(R.string.i2ptunnel_type_httpserver),
+                        res.getString(R.string.i2ptunnel_type_httpbidirserver),
+                        res.getString(R.string.i2ptunnel_type_ircserver)),
+
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_target_port))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_target_port))
+                .setNumeric(true)
+                .setRequired(true)
+                .setEqualCondition(cTunnelType, res.getString(R.string.i2ptunnel_wizard_v_server)),
+
+            // Not set required because a default is specified.
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_reachable_on))
+                .setDefault("127.0.0.1")
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_reachable_on))
+                .setEqualAnyCondition(cClientType,
+                        res.getString(R.string.i2ptunnel_type_client),
+                        res.getString(R.string.i2ptunnel_type_httpclient),
+                        res.getString(R.string.i2ptunnel_type_ircclient),
+                        res.getString(R.string.i2ptunnel_type_sockstunnel),
+                        res.getString(R.string.i2ptunnel_type_socksirctunnel),
+                        res.getString(R.string.i2ptunnel_type_connectclient))
+                .setEqualAnyCondition(cServerType,
+                        res.getString(R.string.i2ptunnel_type_httpbidirserver),
+                        res.getString(R.string.i2ptunnel_type_streamrserver)),
+
+            new SingleTextFieldPage(this, res.getString(R.string.i2ptunnel_wizard_k_binding_port))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_k_binding_port))
+                .setNumeric(true)
+                .setRequired(true)
+                .setEqualCondition(cTunnelType, res.getString(R.string.i2ptunnel_wizard_v_client))
+                .setEqualCondition(cServerType, res.getString(R.string.i2ptunnel_type_httpbidirserver)),
+
+            new SingleFixedBooleanPage(this, res.getString(R.string.i2ptunnel_wizard_k_auto_start))
+                .setDescription(res.getString(R.string.i2ptunnel_wizard_desc_auto_start))
+                .setRequired(true)
+            );
+    }
+
+}

app/src/main/java/net/i2p/android/i2ptunnel/TunnelsContainer.java

@@ -0,0 +1,301 @@
+package net.i2p.android.i2ptunnel;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.ActivityCompat;
+import android.support.v4.app.ActivityOptionsCompat;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentPagerAdapter;
+import android.support.v4.util.Pair;
+import android.support.v4.view.ViewPager;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageButton;
+import android.widget.Toast;
+
+import com.viewpagerindicator.TitlePageIndicator;
+
+import net.i2p.android.i2ptunnel.preferences.EditTunnelContainerFragment;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.android.util.FragmentUtils;
+import net.i2p.app.ClientAppState;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.i2ptunnel.ui.TunnelConfig;
+import net.i2p.router.RouterContext;
+
+import java.util.List;
+
+public class TunnelsContainer extends Fragment implements
+        FragmentUtils.TwoPaneProvider,
+        TunnelListFragment.OnTunnelSelectedListener,
+        TunnelDetailFragment.TunnelDetailListener {
+    static final int TUNNEL_WIZARD_REQUEST = 1;
+    public static final String TUNNEL_WIZARD_DATA = "tunnel_wizard_data";
+
+    /**
+     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
+     * device.
+     */
+    private boolean mTwoPane;
+
+    ViewPager mViewPager;
+    TitlePageIndicator mPageIndicator;
+    FragmentPagerAdapter mFragPagerAdapter;
+
+    private static final String FRAGMENT_CLIENT = "client_fragment";
+    private static final String FRAGMENT_SERVER = "server_fragment";
+    private static final int FRAGMENT_ID_CLIENT = 0;
+    private static final int FRAGMENT_ID_SERVER = 1;
+    TunnelListFragment mClientFrag;
+    TunnelListFragment mServerFrag;
+
+    private ImageButton mNewTunnel;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    private boolean showActions() {
+        RouterContext rCtx = Util.getRouterContext();
+        TunnelControllerGroup tcg = TunnelControllerGroup.getInstance();
+        return rCtx != null && tcg != null &&
+                (tcg.getState() == ClientAppState.STARTING ||
+                        tcg.getState() == ClientAppState.RUNNING);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.container_tunnels, container, false);
+
+        mViewPager = (ViewPager) v.findViewById(R.id.pager);
+        mPageIndicator = (TitlePageIndicator) v.findViewById(R.id.page_indicator);
+        mNewTunnel = (ImageButton) v.findViewById(R.id.promoted_action);
+        mNewTunnel.setVisibility(showActions() ? View.VISIBLE : View.GONE);
+
+        if (v.findViewById(R.id.detail_fragment) != null) {
+            // The detail container view will be present only in the
+            // large-screen layouts (res/values-w720dp). If this view
+            // is present, then the activity should be in two-pane mode.
+            mTwoPane = true;
+        }
+
+        if (savedInstanceState != null) {
+            mClientFrag = (TunnelListFragment) getChildFragmentManager().getFragment(
+                    savedInstanceState, FRAGMENT_CLIENT);
+            mServerFrag = (TunnelListFragment) getChildFragmentManager().getFragment(
+                    savedInstanceState, FRAGMENT_SERVER);
+        }
+
+        return v;
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        mFragPagerAdapter = new TunnelsPagerAdapter(getChildFragmentManager());
+        mViewPager.setAdapter(mFragPagerAdapter);
+
+        // Bind the page indicator to the pager.
+        mPageIndicator.setViewPager(mViewPager);
+
+        mNewTunnel.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent wi = new Intent(getActivity(), TunnelWizardActivity.class);
+                startActivityForResult(wi, TUNNEL_WIZARD_REQUEST);
+            }
+        });
+    }
+
+    public class TunnelsPagerAdapter extends FragmentPagerAdapter {
+        private static final int NUM_ITEMS = 2;
+
+        public TunnelsPagerAdapter(FragmentManager fm) {
+            super(fm);
+        }
+
+        @Override
+        public int getCount() {
+            return NUM_ITEMS;
+        }
+
+        @Override
+        public Fragment getItem(int position) {
+            switch (position) {
+                case FRAGMENT_ID_CLIENT:
+                    return (mClientFrag = TunnelListFragment.newInstance(true));
+                case FRAGMENT_ID_SERVER:
+                    return (mServerFrag = TunnelListFragment.newInstance(false));
+                default:
+                    return null;
+            }
+        }
+
+        @Override
+        public CharSequence getPageTitle(int position) {
+            switch (position) {
+                case FRAGMENT_ID_CLIENT:
+                    return getActivity().getString(R.string.label_i2ptunnel_client);
+                case FRAGMENT_ID_SERVER:
+                    return getActivity().getString(R.string.label_i2ptunnel_server);
+                default:
+                    return null;
+            }
+        }
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        super.onCreateOptionsMenu(menu, inflater);
+        inflater.inflate(R.menu.fragment_i2ptunnel_list_actions, menu);
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(Menu menu) {
+        boolean showActions = showActions();
+
+        menu.findItem(R.id.action_start_all_tunnels).setVisible(showActions);
+        menu.findItem(R.id.action_stop_all_tunnels).setVisible(showActions);
+        menu.findItem(R.id.action_restart_all_tunnels).setVisible(showActions);
+
+        // Was causing a NPE in version 4745238 (0.9.31)
+        if (mNewTunnel != null) {
+            mNewTunnel.setVisibility(showActions ? View.VISIBLE : View.GONE);
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        TunnelControllerGroup tcg = TunnelControllerGroup.getInstance();
+        if (tcg == null)
+            return false;
+
+        // Handle presses on the action bar items
+        List<String> msgs;
+        switch (item.getItemId()) {
+            case R.id.action_start_all_tunnels:
+                msgs = tcg.startAllControllers();
+                break;
+            case R.id.action_stop_all_tunnels:
+                msgs = tcg.stopAllControllers();
+                break;
+            case R.id.action_restart_all_tunnels:
+                // Do a manual stop-start cycle, because tcg.restartAllControllers() happens in the
+                // foreground, whereas tcg.startAllControllers() fires off threads for starting.
+                msgs = tcg.stopAllControllers();
+                msgs.addAll(tcg.startAllControllers());
+                break;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+        // TODO: Do something with the other messages
+        if (msgs.size() > 0)
+            Toast.makeText(getActivity().getApplicationContext(),
+                    msgs.get(0), Toast.LENGTH_LONG).show();
+        return true;
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == TUNNEL_WIZARD_REQUEST) {
+            if (resultCode == Activity.RESULT_OK) {
+                Bundle tunnelData = data.getExtras().getBundle(TUNNEL_WIZARD_DATA);
+                // TODO fetch earlier
+                TunnelControllerGroup tcg = TunnelControllerGroup.getInstance();
+                TunnelConfig cfg = TunnelUtil.createConfigFromWizard(getActivity(), tcg, tunnelData);
+                TunnelEntry tunnel = TunnelEntry.createNewTunnel(getActivity(), tcg, cfg);
+
+                if (tunnel != null) {
+                    if (tunnel.isClient() && mClientFrag != null)
+                        mClientFrag.addTunnel(tunnel);
+                    else if (mServerFrag != null)
+                        mServerFrag.addTunnel(tunnel);
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+
+        // Since the pager fragments don't have known tags or IDs, the only way to persist the
+        // reference is to use putFragment/getFragment. Remember, we're not persisting the exact
+        // Fragment instance. This mechanism simply gives us a way to persist access to the
+        // 'current' fragment instance for the given fragment (which changes across orientation
+        // changes).
+        //
+        // The outcome of all this is that the "Refresh" menu button refreshes the stream across
+        // orientation changes.
+        if (mClientFrag != null)
+            getChildFragmentManager().putFragment(outState, FRAGMENT_CLIENT, mClientFrag);
+        if (mServerFrag != null)
+            getChildFragmentManager().putFragment(outState, FRAGMENT_SERVER, mServerFrag);
+    }
+
+    // FragmentUtils.TwoPaneProvider
+
+    public boolean isTwoPane() {
+        return mTwoPane;
+    }
+
+    // TunnelListFragment.OnTunnelSelectedListener
+
+    public final void onTunnelSelected(int tunnelId, Pair<View, String>[] pairs) {
+        if (mTwoPane) {
+            // In two-pane mode, show the detail view in this activity by
+            // adding or replacing the detail fragment using a
+            // fragment transaction.
+            TunnelDetailFragment detailFrag = TunnelDetailFragment.newInstance(tunnelId);
+            getChildFragmentManager().beginTransaction()
+                    .replace(R.id.detail_fragment, detailFrag).commit();
+        } else {
+            // In single-pane mode, simply start the detail activity
+            // for the selected item ID.
+            Intent detailIntent = new Intent(getActivity(), TunnelDetailActivity.class);
+            detailIntent.putExtra(TunnelDetailFragment.TUNNEL_ID, tunnelId);
+
+            ActivityOptionsCompat options = ActivityOptionsCompat.makeSceneTransitionAnimation(
+                    getActivity(), pairs);
+            ActivityCompat.startActivity(getActivity(), detailIntent, options.toBundle());
+        }
+    }
+
+    // TunnelDetailFragment.TunnelDetailListener
+
+    @Override
+    public void onEditTunnel(int tunnelId) {
+        Fragment editFrag = EditTunnelContainerFragment.newInstance(tunnelId);
+        getChildFragmentManager().beginTransaction()
+                .replace(R.id.detail_fragment, editFrag)
+                .addToBackStack("")
+                .commit();
+    }
+
+    public void onTunnelDeleted(int tunnelId, int numTunnelsLeft) {
+        // Should only get here in two-pane mode, but just to be safe:
+        if (mTwoPane) {
+            if (numTunnelsLeft > 0) {
+                TunnelDetailFragment detailFrag = TunnelDetailFragment.newInstance(
+                        (tunnelId > 0 ? tunnelId - 1 : 0));
+                getChildFragmentManager().beginTransaction()
+                        .replace(R.id.detail_fragment, detailFrag).commit();
+            } else {
+                TunnelDetailFragment detailFrag = (TunnelDetailFragment) getChildFragmentManager().findFragmentById(R.id.detail_fragment);
+                getChildFragmentManager().beginTransaction()
+                        .remove(detailFrag).commit();
+            }
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/preferences/AdvancedTunnelPreferenceFragment.java

@@ -0,0 +1,193 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.preference.CheckBoxPreference;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceCategory;
+import android.support.v7.preference.PreferenceScreen;
+
+import net.i2p.android.i2ptunnel.util.TunnelLogic;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.router.R;
+
+public class AdvancedTunnelPreferenceFragment extends BaseTunnelPreferenceFragment {
+    public static AdvancedTunnelPreferenceFragment newInstance(int tunnelId) {
+        AdvancedTunnelPreferenceFragment f = new AdvancedTunnelPreferenceFragment();
+        Bundle args = new Bundle();
+        args.putInt(ARG_TUNNEL_ID, tunnelId);
+        f.setArguments(args);
+        return f;
+    }
+
+    @Override
+    protected void loadPreferences() {
+        String type = TunnelUtil.getController(mGroup, mTunnelId).getType();
+        new TunnelPreferences(type).runLogic();
+    }
+
+    class TunnelPreferences extends TunnelLogic {
+        PreferenceScreen ps;
+        PreferenceCategory tunParamCategory;
+
+        public TunnelPreferences(String type) {
+            super(type);
+        }
+
+        @Override
+        protected void general() {
+        }
+
+        @Override
+        protected void generalClient() {
+        }
+
+        @Override
+        protected void generalClientStreamr(boolean isStreamr) {
+        }
+
+        @Override
+        protected void generalClientPort() {
+        }
+
+        @Override
+        protected void generalClientPortStreamr(boolean isStreamr) {
+        }
+
+        @Override
+        protected void generalClientProxy(boolean isProxy) {
+        }
+
+        @Override
+        protected void generalClientProxyHttp(boolean isHttp) {
+        }
+
+        @Override
+        protected void generalClientStandardOrIrc(boolean isStandardOrIrc) {
+        }
+
+        @Override
+        protected void generalClientIrc() {
+        }
+
+        @Override
+        protected void generalServerHttp() {
+        }
+
+        @Override
+        protected void generalServerHttpBidirOrStreamr(boolean isStreamr) {
+        }
+
+        @Override
+        protected void generalServerPort() {
+        }
+
+        @Override
+        protected void generalServerPortStreamr(boolean isStreamr) {
+        }
+
+        @Override
+        protected void advanced() {
+            addPreferencesFromResource(R.xml.tunnel_adv);
+            ps = getPreferenceScreen();
+            tunParamCategory = (PreferenceCategory) ps.findPreference(
+                    getString(R.string.TUNNEL_CAT_TUNNEL_PARAMS));
+        }
+
+        @Override
+        protected void advancedStreamr(boolean isStreamr) {
+            if (isStreamr)
+                tunParamCategory.removePreference(tunParamCategory.findPreference(getString(R.string.TUNNEL_OPT_PROFILE)));
+        }
+
+        @Override
+        protected void advancedServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (isServerOrStreamrClient)
+                tunParamCategory.removePreference(tunParamCategory.findPreference(getString(R.string.TUNNEL_OPT_DELAY_CONNECT)));
+        }
+
+        @Override
+        protected void advancedServer() {
+            addPreferencesFromResource(R.xml.tunnel_adv_server);
+        }
+
+        @Override
+        protected void advancedServerHttp(boolean isHttp) {
+            if (isHttp)
+                addPreferencesFromResource(R.xml.tunnel_adv_server_http);
+            else {
+                PreferenceCategory accessCtlCategory = (PreferenceCategory) ps.findPreference(
+                        getString(R.string.TUNNEL_CAT_ACCESS_CONTROL));
+                accessCtlCategory.removePreference(accessCtlCategory.findPreference(getString(R.string.TUNNEL_OPT_REJECT_INPROXY)));
+            }
+        }
+
+        @Override
+        protected void advancedIdle() {
+            addPreferencesFromResource(R.xml.tunnel_adv_idle);
+        }
+
+        @Override
+        protected void advancedIdleServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (isServerOrStreamrClient)
+                ps.removePreference(ps.findPreference(getString(R.string.TUNNEL_OPT_DELAY_OPEN)));
+        }
+
+        @Override
+        protected void advancedClient() {
+            PreferenceCategory idleCategory = (PreferenceCategory) ps.findPreference(
+                    getString(R.string.TUNNEL_CAT_IDLE)
+            );
+            addPreferencesFromResource(R.xml.tunnel_adv_idle_client, idleCategory);
+
+            // PERSISTENT_KEY and NEW_KEYS can't be set simultaneously
+            final CheckBoxPreference nk = (CheckBoxPreference) findPreference(getString(R.string.TUNNEL_OTP_NEW_KEYS));
+            nk.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+                @Override
+                public boolean onPreferenceChange(Preference preference, Object o) {
+                    final SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
+                    if ((Boolean) o && prefs.getBoolean(getString(R.string.TUNNEL_OPT_PERSISTENT_KEY),
+                            getResources().getBoolean(R.bool.DEFAULT_PERSISTENT_KEY))) {
+                        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+                        builder.setTitle(R.string.new_keys_on_reopen_conflict_title)
+                                .setMessage(R.string.new_keys_on_reopen_conflict_msg)
+                                .setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
+                                    @Override
+                                    public void onClick(DialogInterface dialogInterface, int i) {
+                                        SharedPreferences.Editor editor = prefs.edit();
+                                        editor.putBoolean(getString(R.string.TUNNEL_OPT_PERSISTENT_KEY), false);
+                                        editor.apply();
+                                        nk.setChecked(true);
+                                    }
+                                })
+                                .setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
+                                    @Override
+                                    public void onClick(DialogInterface dialogInterface, int i) {
+                                    }
+                                });
+                        builder.show();
+                        return false;
+                    } else
+                        return true;
+                }
+            });
+        }
+
+        @Override
+        protected void advancedClientHttp() {
+            addPreferencesFromResource(R.xml.tunnel_adv_client_http);
+        }
+
+        @Override
+        protected void advancedClientProxy() {
+            addPreferencesFromResource(R.xml.tunnel_adv_client_proxy);
+        }
+
+        @Override
+        protected void advancedOther() {
+            addPreferencesFromResource(R.xml.tunnel_adv_other);
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/preferences/BaseTunnelPreferenceFragment.java

@@ -0,0 +1,118 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceGroup;
+import android.support.v7.preference.PreferenceScreen;
+import android.widget.Toast;
+
+import net.i2p.android.i2ptunnel.util.SaveTunnelTask;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.preferences.util.CustomPreferenceFragment;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.i2ptunnel.ui.TunnelConfig;
+
+import java.util.concurrent.ExecutionException;
+
+public abstract class BaseTunnelPreferenceFragment extends CustomPreferenceFragment {
+    protected static final String ARG_TUNNEL_ID = "tunnelId";
+
+    protected TunnelControllerGroup mGroup;
+    protected int mTunnelId;
+
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        String error;
+        try {
+            mGroup = TunnelControllerGroup.getInstance();
+            error = mGroup == null ? getResources().getString(R.string.i2ptunnel_not_initialized) : null;
+        } catch (IllegalArgumentException iae) {
+            mGroup = null;
+            error = iae.toString();
+        }
+
+        if (mGroup == null) {
+            Toast.makeText(getActivity().getApplicationContext(),
+                    error, Toast.LENGTH_LONG).show();
+            getActivity().finish();
+        } else if (getArguments().containsKey(ARG_TUNNEL_ID)) {
+            mTunnelId = getArguments().getInt(ARG_TUNNEL_ID, 0);
+            try {
+                TunnelUtil.writeTunnelToPreferences(getActivity(), mGroup, mTunnelId);
+            } catch (IllegalArgumentException e) {
+                // Tunnel doesn't exist, or the tunnel config file could not be read
+                Util.e("Could not load tunnel details", e);
+                Toast.makeText(getActivity().getApplicationContext(),
+                        R.string.i2ptunnel_no_tunnel_details, Toast.LENGTH_LONG).show();
+                getActivity().finish();
+            }
+            // https://stackoverflow.com/questions/17880437/which-settings-file-does-preferencefragment-read-write
+            getPreferenceManager().setSharedPreferencesName(TunnelUtil.getPreferencesFilename(mTunnelId));
+            try {
+                loadPreferences();
+            } catch (IllegalArgumentException iae) {
+                // mGroup couldn't load its config file
+                Toast.makeText(getActivity().getApplicationContext(),
+                        iae.toString(), Toast.LENGTH_LONG).show();
+                getActivity().finish();
+            }
+        }
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+
+        // Pre-Honeycomb: onPause() is the last method guaranteed to be called.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB)
+            saveTunnel();
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+
+        // Honeycomb and above: onStop() is the last method guaranteed to be called.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB)
+            saveTunnel();
+    }
+
+    private void saveTunnel() {
+        if (mGroup != null) {
+            TunnelConfig cfg = TunnelUtil.createConfigFromPreferences(getActivity(), mGroup, mTunnelId);
+            SaveTunnelTask task = new SaveTunnelTask(mGroup, mTunnelId, cfg);
+            try {
+                // TODO: There used to be a possible ANR here, because the underlying I2P code
+                // checks if the session is open as part of updating its config. We may need to save
+                // completely asynchronously (and ensure we do actually save before the app closes).
+                task.execute().get();
+            } catch (InterruptedException e) {
+                Util.e("Interrupted while saving tunnel config", e);
+            } catch (ExecutionException e) {
+                Util.e("Error while saving tunnel config", e);
+            }
+        }
+    }
+
+    protected abstract void loadPreferences();
+
+    /**
+     * http://stackoverflow.com/a/20806812
+     *
+     * @param id        the Preferences XML to load
+     * @param newParent the parent PreferenceGroup to add the new Preferences to.
+     */
+    protected void addPreferencesFromResource(int id, PreferenceGroup newParent) {
+        PreferenceScreen screen = getPreferenceScreen();
+        int last = screen.getPreferenceCount();
+        addPreferencesFromResource(id);
+        while (screen.getPreferenceCount() > last) {
+            Preference p = screen.getPreference(last);
+            screen.removePreference(p); // decreases the preference count
+            newParent.addPreference(p);
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/preferences/EditTunnelActivity.java

@@ -0,0 +1,59 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+
+import net.i2p.android.i2ptunnel.TunnelDetailActivity;
+import net.i2p.android.i2ptunnel.TunnelDetailFragment;
+import net.i2p.android.router.R;
+import net.i2p.android.util.LocaleManager;
+
+public class EditTunnelActivity extends AppCompatActivity {
+    private int mTunnelId;
+
+    private final LocaleManager localeManager = new LocaleManager();
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        localeManager.onCreate(this);
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_single_fragment);
+
+        // Set the action bar
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        if (savedInstanceState == null) {
+            mTunnelId = getIntent().getIntExtra(TunnelDetailFragment.TUNNEL_ID, 0);
+            Fragment editFrag = GeneralTunnelPreferenceFragment.newInstance(mTunnelId);
+            getSupportFragmentManager().beginTransaction()
+                .add(R.id.fragment, editFrag).commit();
+        }
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        localeManager.onResume(this);
+    }
+
+    @Override
+    public boolean onSupportNavigateUp() {
+        FragmentManager fragmentManager = getSupportFragmentManager();
+        if (fragmentManager.getBackStackEntryCount() > 0) {
+            fragmentManager.popBackStack();
+        } else {
+            Intent intent = new Intent(this, TunnelDetailActivity.class);
+            intent.putExtra(TunnelDetailFragment.TUNNEL_ID, mTunnelId);
+            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            startActivity(intent);
+            finish();
+        }
+        return true;
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/preferences/EditTunnelContainerFragment.java

@@ -0,0 +1,64 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v7.widget.Toolbar;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import net.i2p.android.router.R;
+
+/**
+ * A shim that emulates EditTunnelActivity to provide a Toolbar with navigation
+ * in two-pane mode.
+ */
+public class EditTunnelContainerFragment extends Fragment {
+    private static final String ARG_TUNNEL_ID = "tunnelId";
+
+    public static EditTunnelContainerFragment newInstance(int tunnelId) {
+        EditTunnelContainerFragment f = new EditTunnelContainerFragment();
+        Bundle args = new Bundle();
+        args.putInt(ARG_TUNNEL_ID, tunnelId);
+        f.setArguments(args);
+        return f;
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.activity_single_fragment, container, false);
+
+        // Set the action bar
+        Toolbar toolbar = (Toolbar) v.findViewById(R.id.main_toolbar);
+        toolbar.setTitle(R.string.edit_tunnel);
+        toolbar.setNavigationIcon(getResources().getDrawable(R.drawable.ic_arrow_back_white_24dp));
+        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                // Try and navigate back through the edit tunnel fragments.
+                // Otherwise, pop us back off.
+                FragmentManager fragmentManager = getChildFragmentManager();
+                if (fragmentManager.getBackStackEntryCount() > 0)
+                    fragmentManager.popBackStack();
+                else
+                    getFragmentManager().popBackStack();
+            }
+        });
+
+        return v;
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        if (savedInstanceState == null) {
+            int tunnelId = getArguments().getInt(ARG_TUNNEL_ID);
+            BaseTunnelPreferenceFragment editFrag = GeneralTunnelPreferenceFragment.newInstance(tunnelId);
+            getChildFragmentManager().beginTransaction()
+                .add(R.id.fragment, editFrag).commit();
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/preferences/GeneralTunnelPreferenceFragment.java

@@ -0,0 +1,267 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.app.Activity;
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v7.app.AlertDialog;
+import android.support.v7.preference.CheckBoxPreference;
+import android.support.v7.preference.ListPreference;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceCategory;
+import android.support.v7.preference.PreferenceScreen;
+
+import net.i2p.android.i2ptunnel.util.TunnelLogic;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.router.R;
+import net.i2p.util.Addresses;
+
+import java.util.Set;
+
+public class GeneralTunnelPreferenceFragment extends BaseTunnelPreferenceFragment {
+    private CheckBoxPreference persistentKeys;
+
+    public static GeneralTunnelPreferenceFragment newInstance(int tunnelId) {
+        GeneralTunnelPreferenceFragment f = new GeneralTunnelPreferenceFragment();
+        Bundle args = new Bundle();
+        args.putInt(ARG_TUNNEL_ID, tunnelId);
+        f.setArguments(args);
+        return f;
+    }
+
+    @Override
+    protected void loadPreferences() {
+        String type = TunnelUtil.getController(mGroup, mTunnelId).getType();
+        new TunnelPreferences(type).runLogic();
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+
+        // In case this was changed when toggling NEW_KEYS and then we navigated back
+        if (persistentKeys != null)
+            persistentKeys.setChecked(getPreferenceManager().getSharedPreferences().getBoolean(
+                    getString(R.string.TUNNEL_OPT_PERSISTENT_KEY),
+                    getResources().getBoolean(R.bool.DEFAULT_PERSISTENT_KEY)
+            ));
+    }
+
+    class TunnelPreferences extends TunnelLogic {
+        PreferenceScreen ps;
+        PreferenceCategory generalCategory;
+        PreferenceCategory portCategory;
+
+        public TunnelPreferences(String type) {
+            super(type);
+        }
+
+        @Override
+        protected void general() {
+            addPreferencesFromResource(R.xml.tunnel_gen);
+            ps = getPreferenceScreen();
+            generalCategory = (PreferenceCategory) ps.findPreference(
+                    getString(R.string.TUNNEL_CAT_GENERAL));
+            portCategory = (PreferenceCategory) ps.findPreference(
+                    getString(R.string.TUNNEL_CAT_PORT));
+        }
+
+        @Override
+        protected void generalClient() {
+            addPreferencesFromResource(R.xml.tunnel_gen_client, generalCategory);
+
+            // PERSISTENT_KEY and NEW_KEYS can't be set simultaneously
+            persistentKeys = (CheckBoxPreference) findPreference(getString(R.string.TUNNEL_OPT_PERSISTENT_KEY));
+            persistentKeys.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+                @Override
+                public boolean onPreferenceChange(Preference preference, Object o) {
+                    final SharedPreferences prefs = getPreferenceManager().getSharedPreferences();
+                    if ((Boolean) o && prefs.getBoolean(getString(R.string.TUNNEL_OTP_NEW_KEYS),
+                            getResources().getBoolean(R.bool.DEFAULT_NEW_KEYS))) {
+                        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+                        builder.setTitle(R.string.persistent_key_conflict_title)
+                                .setMessage(R.string.persistent_key_conflict_msg)
+                                .setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
+                                    @Override
+                                    public void onClick(DialogInterface dialogInterface, int i) {
+                                        SharedPreferences.Editor editor = prefs.edit();
+                                        editor.putBoolean(getString(R.string.TUNNEL_OTP_NEW_KEYS), false);
+                                        editor.apply();
+                                        persistentKeys.setChecked(true);
+                                    }
+                                })
+                                .setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
+                                    @Override
+                                    public void onClick(DialogInterface dialogInterface, int i) {
+                                    }
+                                });
+                        builder.show();
+                        return false;
+                    } else
+                        return true;
+                }
+            });
+        }
+
+        @Override
+        protected void generalClientStreamr(boolean isStreamr) {
+            if (isStreamr) {
+                generalCategory.removePreference(generalCategory.findPreference(getString(R.string.TUNNEL_SHARED_CLIENT)));
+                addPreferencesFromResource(R.xml.tunnel_gen_server_port, portCategory);
+                portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_TARGET_PORT)));
+                portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_USE_SSL)));
+            }
+        }
+
+        @Override
+        protected void generalClientPort() {
+            addPreferencesFromResource(R.xml.tunnel_gen_client_port, portCategory);
+        }
+
+        @Override
+        protected void generalClientPortStreamr(boolean isStreamr) {
+            ListPreference reachableBy = (ListPreference) portCategory.findPreference(getString(R.string.TUNNEL_INTERFACE));
+            if (isStreamr)
+                portCategory.removePreference(reachableBy);
+            else
+                setupReachableBy(reachableBy);
+        }
+
+        private void setupReachableBy(final ListPreference reachableBy) {
+            reachableBy.setEnabled(false);
+            new AsyncTask<Void, Void, Void>() {
+                @Override
+                protected Void doInBackground(Void... voids) {
+                    Set<String> interfaceSet = Addresses.getAllAddresses();
+                    final String[] interfaces = interfaceSet.toArray(new String[interfaceSet.size()]);
+                    Activity activity = getActivity();
+                    if (activity != null) {
+                        activity.runOnUiThread(new Runnable() {
+                            @Override
+                            public void run() {
+                                reachableBy.setEntries(interfaces);
+                                reachableBy.setEntryValues(interfaces);
+                                reachableBy.setEnabled(true);
+                            }
+                        });
+                    }
+                    return null;
+                }
+            }.execute();
+        }
+
+        @Override
+        protected void generalClientProxy(boolean isProxy) {
+            if (isProxy) {
+                generalCategory.removePreference(generalCategory.findPreference(getString(R.string.TUNNEL_DEST)));
+                addPreferencesFromResource(R.xml.tunnel_gen_client_proxy);
+            }
+        }
+
+        @Override
+        protected void generalClientProxyHttp(boolean isHttp) {
+            if (!isHttp)
+                ps.removePreference(ps.findPreference(getString(R.string.TUNNEL_HTTPCLIENT_SSL_OUTPROXIES)));
+        }
+
+        @Override
+        protected void generalClientStandardOrIrc(boolean isStandardOrIrc) {
+            if (!isStandardOrIrc)
+                portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_USE_SSL)));
+        }
+
+        @Override
+        protected void generalClientIrc() {
+            addPreferencesFromResource(R.xml.tunnel_gen_client_irc);
+        }
+
+        @Override
+        protected void generalServerHttp() {
+            addPreferencesFromResource(R.xml.tunnel_gen_server_http, generalCategory);
+        }
+
+        @Override
+        protected void generalServerHttpBidirOrStreamr(boolean isStreamr) {
+            addPreferencesFromResource(R.xml.tunnel_gen_client_port, portCategory);
+            portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_USE_SSL)));
+            if (isStreamr)
+                portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_LISTEN_PORT)));
+
+            setupReachableBy((ListPreference) portCategory.findPreference(getString(R.string.TUNNEL_INTERFACE)));
+        }
+
+        @Override
+        protected void generalServerPort() {
+            addPreferencesFromResource(R.xml.tunnel_gen_server_port, portCategory);
+        }
+
+        @Override
+        protected void generalServerPortStreamr(boolean isStreamr) {
+            if (isStreamr) {
+                portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_TARGET_HOST)));
+                portCategory.removePreference(portCategory.findPreference(getString(R.string.TUNNEL_USE_SSL)));
+            }
+        }
+
+        @Override
+        protected void advanced() {
+            Preference advanced = new Preference(getActivity());
+            advanced.setKey(getString(R.string.TUNNEL_CAT_ADVANCED));
+            advanced.setTitle(R.string.settings_label_advanced);
+            advanced.setOnPreferenceClickListener(new Preference.OnPreferenceClickListener() {
+                @Override
+                public boolean onPreferenceClick(Preference preference) {
+                    Fragment fragment = AdvancedTunnelPreferenceFragment.newInstance(mTunnelId);
+                    getFragmentManager().beginTransaction()
+                            .replace(R.id.fragment, fragment)
+                            .addToBackStack(null)
+                            .commit();
+                    return true;
+                }
+            });
+            ps.addPreference(advanced);
+        }
+
+        @Override
+        protected void advancedStreamr(boolean isStreamr) {
+        }
+
+        @Override
+        protected void advancedServerOrStreamrClient(boolean isServerOrStreamrClient) {
+        }
+
+        @Override
+        protected void advancedServer() {
+        }
+
+        @Override
+        protected void advancedServerHttp(boolean isHttp) {
+        }
+
+        @Override
+        protected void advancedIdle() {
+        }
+
+        @Override
+        protected void advancedIdleServerOrStreamrClient(boolean isServerOrStreamrClient) {
+        }
+
+        @Override
+        protected void advancedClient() {
+        }
+
+        @Override
+        protected void advancedClientHttp() {
+        }
+
+        @Override
+        protected void advancedClientProxy() {
+        }
+
+        @Override
+        protected void advancedOther() {
+        }
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/util/SaveTunnelTask.java

@@ -0,0 +1,32 @@
+package net.i2p.android.i2ptunnel.util;
+
+import android.os.AsyncTask;
+
+import net.i2p.I2PAppContext;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.i2ptunnel.ui.TunnelConfig;
+
+import java.util.List;
+
+/**
+ * Save a TunnelConfig.
+ *
+ * This must be performed in a background thread, because the underlying I2P code calls
+ * InetAddress.getByName(), which will trigger a NetworkOnMainThreadException otherwise.
+ */
+public class SaveTunnelTask  extends AsyncTask<Void, Void, List<String>> {
+    TunnelControllerGroup mGroup;
+    int mTunnelId;
+    TunnelConfig mCfg;
+
+    public SaveTunnelTask(TunnelControllerGroup group, int tunnelId, TunnelConfig cfg) {
+        mGroup = group;
+        mTunnelId = tunnelId;
+        mCfg = cfg;
+    }
+
+    @Override
+    protected List<String> doInBackground(Void... voids) {
+        return TunnelUtil.saveTunnel(I2PAppContext.getGlobalContext(), mGroup, mTunnelId, mCfg);
+    }
+}

app/src/main/java/net/i2p/android/i2ptunnel/util/TunnelLogic.java

@@ -0,0 +1,101 @@
+package net.i2p.android.i2ptunnel.util;
+
+/**
+ * Generic class for handling the composition of tunnel properties.
+ * <p/>
+ * See I2PTunnel's editClient.jsp and editServer.jsp for composition logic.
+ * <p/>
+ * Some of the abstract methods have boolean parameters. These are the methods
+ * where the corresponding tunnel properties may or may not exist, depending on
+ * the value of the boolean. In all other abstract methods, all corresponding
+ * tunnel properties always exist.
+ */
+public abstract class TunnelLogic {
+    protected String mType;
+
+    public TunnelLogic(String type) {
+        mType = type;
+    }
+
+    public void runLogic() {
+        boolean isProxy = "httpclient".equals(mType) ||
+                "connectclient".equals(mType) ||
+                "sockstunnel".equals(mType) ||
+                "socksirctunnel".equals(mType);
+
+        general();
+
+        if (TunnelUtil.isClient(mType)) {
+            generalClient();
+            generalClientStreamr("streamrclient".equals(mType));
+
+            generalClientPort();
+            generalClientPortStreamr("streamrclient".equals(mType));
+
+            generalClientProxy(isProxy);
+            if (isProxy)
+                generalClientProxyHttp("httpclient".equals(mType));
+
+            generalClientStandardOrIrc("client".equals(mType) || "ircclient".equals(mType));
+            if ("ircclient".equals(mType))
+                generalClientIrc();
+        } else {
+            if ("httpserver".equals(mType) || "httpbidirserver".equals(mType))
+                generalServerHttp();
+            if ("httpbidirserver".equals(mType) || "streamrserver".equals(mType))
+                generalServerHttpBidirOrStreamr("streamrserver".equals(mType));
+
+            generalServerPort();
+            generalServerPortStreamr("streamrserver".equals(mType));
+        }
+
+        advanced();
+        advancedStreamr("streamrclient".equals(mType) || "streamrserver".equals(mType));
+        advancedServerOrStreamrClient(!TunnelUtil.isClient(mType) || "streamrclient".equals(mType));
+
+        if (!TunnelUtil.isClient(mType)) {
+            advancedServer();
+            advancedServerHttp("httpserver".equals(mType) || "httpbidirserver".equals(mType));
+        }
+
+        advancedIdle();
+        // streamr client sends pings so it will never be idle
+        advancedIdleServerOrStreamrClient(!TunnelUtil.isClient(mType) || "streamrclient".equals(mType));
+
+        if (TunnelUtil.isClient(mType)) {
+            advancedClient();
+            if ("httpclient".equals(mType))
+                advancedClientHttp();
+            if (isProxy)
+                advancedClientProxy();
+        }
+
+        advancedOther();
+    }
+
+    protected abstract void general();
+    protected abstract void generalClient();
+    protected abstract void generalClientStreamr(boolean isStreamr);
+    protected abstract void generalClientPort();
+    protected abstract void generalClientPortStreamr(boolean isStreamr);
+    protected abstract void generalClientProxy(boolean isProxy);
+    protected abstract void generalClientProxyHttp(boolean isHttp);
+    protected abstract void generalClientStandardOrIrc(boolean isStandardOrIrc);
+    protected abstract void generalClientIrc();
+    protected abstract void generalServerHttp();
+    protected abstract void generalServerHttpBidirOrStreamr(boolean isStreamr);
+    protected abstract void generalServerPort();
+    protected abstract void generalServerPortStreamr(boolean isStreamr);
+
+    protected abstract void advanced();
+    protected abstract void advancedStreamr(boolean isStreamr);
+    protected abstract void advancedServerOrStreamrClient(boolean isServerOrStreamrClient);
+    protected abstract void advancedServer();
+    protected abstract void advancedServerHttp(boolean isHttp);
+    protected abstract void advancedIdle();
+    protected abstract void advancedIdleServerOrStreamrClient(boolean isServerOrStreamrClient);
+    protected abstract void advancedClient();
+    protected abstract void advancedClientHttp();
+    protected abstract void advancedClientProxy();
+    protected abstract void advancedOther();
+}

app/src/main/java/net/i2p/android/i2ptunnel/util/TunnelUtil.java

@@ -0,0 +1,782 @@
+package net.i2p.android.i2ptunnel.util;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.res.Resources;
+import android.os.Bundle;
+
+import net.i2p.I2PAppContext;
+import net.i2p.android.router.R;
+import net.i2p.android.wizard.model.Page;
+import net.i2p.i2ptunnel.TunnelController;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.i2ptunnel.ui.GeneralHelper;
+import net.i2p.i2ptunnel.ui.TunnelConfig;
+
+public class TunnelUtil extends GeneralHelper {
+    public static final String PREFERENCES_FILENAME_PREFIX = "tunnel.";
+
+    public TunnelUtil(I2PAppContext context, TunnelControllerGroup tcg) {
+        super(context, tcg);
+    }
+
+    public TunnelUtil(TunnelControllerGroup tcg) {
+        super(tcg);
+    }
+
+    /* General tunnel data for any type */
+
+    public static String getTypeFromName(String typeName, Context ctx) {
+        Resources res = ctx.getResources();
+        if (res.getString(R.string.i2ptunnel_type_client).equals(typeName))
+            return "client";
+        else if (res.getString(R.string.i2ptunnel_type_httpclient).equals(typeName))
+            return "httpclient";
+        else if (res.getString(R.string.i2ptunnel_type_ircclient).equals(typeName))
+            return "ircclient";
+        else if (res.getString(R.string.i2ptunnel_type_server).equals(typeName))
+            return "server";
+        else if (res.getString(R.string.i2ptunnel_type_httpserver).equals(typeName))
+            return "httpserver";
+        else if (res.getString(R.string.i2ptunnel_type_sockstunnel).equals(typeName))
+            return "sockstunnel";
+        else if (res.getString(R.string.i2ptunnel_type_socksirctunnel).equals(typeName))
+            return "socksirctunnel";
+        else if (res.getString(R.string.i2ptunnel_type_connectclient).equals(typeName))
+            return "connectclient";
+        else if (res.getString(R.string.i2ptunnel_type_ircserver).equals(typeName))
+            return "ircserver";
+        else if (res.getString(R.string.i2ptunnel_type_streamrclient).equals(typeName))
+            return "streamrclient";
+        else if (res.getString(R.string.i2ptunnel_type_streamrserver).equals(typeName))
+            return "streamrserver";
+        else if (res.getString(R.string.i2ptunnel_type_httpbidirserver).equals(typeName))
+            return "httpbidirserver";
+        else
+            return typeName;
+    }
+
+    public static String getTypeName(String type, Context context) {
+        Resources res = context.getResources();
+        switch (type) {
+            case "client":
+                return res.getString(R.string.i2ptunnel_type_client);
+            case "httpclient":
+                return res.getString(R.string.i2ptunnel_type_httpclient);
+            case "ircclient":
+                return res.getString(R.string.i2ptunnel_type_ircclient);
+            case "server":
+                return res.getString(R.string.i2ptunnel_type_server);
+            case "httpserver":
+                return res.getString(R.string.i2ptunnel_type_httpserver);
+            case "sockstunnel":
+                return res.getString(R.string.i2ptunnel_type_sockstunnel);
+            case "socksirctunnel":
+                return res.getString(R.string.i2ptunnel_type_socksirctunnel);
+            case "connectclient":
+                return res.getString(R.string.i2ptunnel_type_connectclient);
+            case "ircserver":
+                return res.getString(R.string.i2ptunnel_type_ircserver);
+            case "streamrclient":
+                return res.getString(R.string.i2ptunnel_type_streamrclient);
+            case "streamrserver":
+                return res.getString(R.string.i2ptunnel_type_streamrserver);
+            case "httpbidirserver":
+                return res.getString(R.string.i2ptunnel_type_httpbidirserver);
+            default:
+                return type;
+        }
+    }
+
+    public static boolean isClient(String type) {
+        return TunnelController.isClient(type);
+    }
+
+    public static String getPreferencesFilename(int tunnel) {
+        return PREFERENCES_FILENAME_PREFIX + tunnel;
+    }
+
+    public static void writeTunnelToPreferences(Context ctx, TunnelControllerGroup tcg, int tunnel) {
+        new TunnelUtil(tcg).writeTunnelToPreferences(ctx, tunnel);
+    }
+    public void writeTunnelToPreferences(Context ctx, int tunnel) {
+        Resources res = ctx.getResources();
+
+        if (getController(tunnel) == null)
+            throw new IllegalArgumentException("Cannot write non-existent tunnel to Preferences");
+
+        // Get the current preferences for this tunnel
+        SharedPreferences preferences = ctx.getSharedPreferences(
+                getPreferencesFilename(tunnel), Context.MODE_PRIVATE);
+
+        // Clear all previous values
+        SharedPreferences.Editor ed = preferences.edit().clear();
+
+        // Load the tunnel config into the preferences
+        String type = getTunnelType(tunnel);
+        ed.putString(res.getString(R.string.TUNNEL_TYPE), type);
+
+        new TunnelToPreferences(ed, res, tunnel, type).runLogic();
+
+        ed.apply();
+    }
+
+    class TunnelToPreferences extends TunnelLogic {
+        SharedPreferences.Editor ed;
+        Resources res;
+        int tunnel;
+
+        public TunnelToPreferences(SharedPreferences.Editor ed, Resources res, int tunnel, String type) {
+            super(type);
+            this.ed = ed;
+            this.res = res;
+            this.tunnel = tunnel;
+        }
+
+        @Override
+        protected void general() {
+            ed.putString(res.getString(R.string.TUNNEL_NAME), getTunnelName(tunnel));
+            ed.putString(res.getString(R.string.TUNNEL_DESCRIPTION), getTunnelDescription(tunnel));
+            ed.putBoolean(res.getString(R.string.TUNNEL_START_ON_LOAD), shouldStartAutomatically(tunnel));
+            if (!isClient(mType) || getPersistentClientKey(tunnel))
+                ed.putString(res.getString(R.string.TUNNEL_PRIV_KEY_FILE), getPrivateKeyFile(tunnel));
+        }
+
+        @Override
+        protected void generalClient() {
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_PERSISTENT_KEY), getPersistentClientKey(tunnel));
+        }
+
+        @Override
+        protected void generalClientStreamr(boolean isStreamr) {
+            if (isStreamr)
+                ed.putString(res.getString(R.string.TUNNEL_TARGET_HOST), getTargetHost(tunnel));
+            else
+                ed.putBoolean(res.getString(R.string.TUNNEL_SHARED_CLIENT), isSharedClient(tunnel));
+        }
+
+        @Override
+        protected void generalClientPort() {
+            ed.putInt(res.getString(R.string.TUNNEL_LISTEN_PORT), getClientPort(tunnel));
+        }
+
+        @Override
+        protected void generalClientPortStreamr(boolean isStreamr) {
+            if (!isStreamr)
+                ed.putString(res.getString(R.string.TUNNEL_INTERFACE), getClientInterface(tunnel));
+        }
+
+        @Override
+        protected void generalClientProxy(boolean isProxy) {
+            if (isProxy)
+                ed.putString(res.getString(R.string.TUNNEL_PROXIES), getClientDestination(tunnel));
+            else
+                ed.putString(res.getString(R.string.TUNNEL_DEST), getClientDestination(tunnel));
+        }
+
+        @Override
+        protected void generalClientProxyHttp(boolean isHttp) {
+            if (isHttp)
+                ed.putString(res.getString(R.string.TUNNEL_HTTPCLIENT_SSL_OUTPROXIES), getSslProxies(tunnel));
+        }
+
+        @Override
+        protected void generalClientStandardOrIrc(boolean isStandardOrIrc) {
+            if (isStandardOrIrc)
+                ed.putBoolean(res.getString(R.string.TUNNEL_USE_SSL), isSSLEnabled(tunnel));
+        }
+
+        @Override
+        protected void generalClientIrc() {
+            ed.putBoolean(res.getString(R.string.TUNNEL_IRCCLIENT_ENABLE_DCC), getDCC(tunnel));
+        }
+
+        @Override
+        protected void generalServerHttp() {
+            ed.putString(res.getString(R.string.TUNNEL_SPOOFED_HOST), getSpoofedHost(tunnel));
+        }
+
+        @Override
+        protected void generalServerHttpBidirOrStreamr(boolean isStreamr) {
+            ed.putString(res.getString(R.string.TUNNEL_INTERFACE), getClientInterface(tunnel));
+            if (!isStreamr)
+                ed.putInt(res.getString(R.string.TUNNEL_LISTEN_PORT), getClientPort(tunnel));
+        }
+
+        @Override
+        protected void generalServerPort() {
+            ed.putInt(res.getString(R.string.TUNNEL_TARGET_PORT), getTargetPort(tunnel));
+        }
+
+        @Override
+        protected void generalServerPortStreamr(boolean isStreamr) {
+            if (!isStreamr) {
+                ed.putString(res.getString(R.string.TUNNEL_TARGET_HOST), getTargetHost(tunnel));
+                ed.putBoolean(res.getString(R.string.TUNNEL_USE_SSL), isSSLEnabled(tunnel));
+            }
+        }
+
+        @Override
+        protected void advanced() {
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_LENGTH),
+                    getTunnelDepth(tunnel, res.getInteger(R.integer.DEFAULT_TUNNEL_LENGTH)));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_VARIANCE),
+                    getTunnelVariance(tunnel, res.getInteger(R.integer.DEFAULT_TUNNEL_VARIANCE)));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_QUANTITY),
+                    getTunnelQuantity(tunnel, res.getInteger(R.integer.DEFAULT_TUNNEL_QUANTITY)));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_BACKUP_QUANTITY),
+                    getTunnelBackupQuantity(tunnel, res.getInteger(R.integer.DEFAULT_TUNNEL_BACKUP_QUANTITY)));
+        }
+
+        @Override
+        protected void advancedStreamr(boolean isStreamr) {
+            if (!isStreamr)
+                ed.putString(res.getString(R.string.TUNNEL_OPT_PROFILE),
+                        isInteractive(tunnel) ? "interactive" : "bulk");
+        }
+
+        @Override
+        protected void advancedServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (!isServerOrStreamrClient)
+                ed.putBoolean(res.getString(R.string.TUNNEL_OPT_DELAY_CONNECT),
+                        shouldDelayConnect(tunnel));
+        }
+
+        @Override
+        protected void advancedServer() {
+            //ed.putBoolean(res.getString(R.string.TUNNEL_OPT_ENCRYPT), getEncrypt(tunnel));
+            //ed.putString(res.getString(R.string.TUNNEL_OPT_ENCRYPT_KEY), getEncryptKey(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_ACCESS_MODE), getAccessMode(tunnel));
+            ed.putString(res.getString(R.string.TUNNEL_OPT_ACCESS_LIST), getAccessList(tunnel));
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_UNIQUE_LOCAL), getUniqueLocal(tunnel));
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_MULTIHOME), getMultihome(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_LIMIT_MINUTE), getLimitMinute(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_LIMIT_HOUR), getLimitHour(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_LIMIT_DAY), getLimitDay(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_TOTAL_MINUTE), getTotalMinute(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_TOTAL_HOUR), getTotalHour(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_TOTAL_DAY), getTotalDay(tunnel));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_MAX_STREAMS), getMaxStreams(tunnel));
+        }
+
+        @Override
+        protected void advancedServerHttp(boolean isHttp) {
+            if (isHttp) {
+                ed.putBoolean(res.getString(R.string.TUNNEL_OPT_REJECT_INPROXY), getRejectInproxy(tunnel));
+                ed.putInt(res.getString(R.string.TUNNEL_OPT_POST_CHECK_TIME), getPostCheckTime(tunnel));
+                ed.putInt(res.getString(R.string.TUNNEL_OPT_POST_MAX), getPostMax(tunnel));
+                ed.putInt(res.getString(R.string.TUNNEL_OPT_POST_BAN_TIME), getPostBanTime(tunnel));
+                ed.putInt(res.getString(R.string.TUNNEL_OPT_POST_TOTAL_MAX), getPostTotalMax(tunnel));
+                ed.putInt(res.getString(R.string.TUNNEL_OPT_POST_TOTAL_BAN_TIME), getPostTotalBanTime(tunnel));
+            }
+        }
+
+        @Override
+        protected void advancedIdle() {
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_REDUCE_IDLE),
+                    getReduceOnIdle(tunnel, res.getBoolean(R.bool.DEFAULT_REDUCE_ON_IDLE)));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_REDUCE_QUANTITY),
+                    getReduceCount(tunnel, res.getInteger(R.integer.DEFAULT_REDUCE_COUNT)));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_REDUCE_TIME),
+                    getReduceTime(tunnel, res.getInteger(R.integer.DEFAULT_REDUCE_TIME)));
+        }
+
+        @Override
+        protected void advancedIdleServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (!isServerOrStreamrClient)
+                ed.putBoolean(res.getString(R.string.TUNNEL_OPT_DELAY_OPEN), getDelayOpen(tunnel));
+        }
+
+        @Override
+        protected void advancedClient() {
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_CLOSE_IDLE),
+                    getCloseOnIdle(tunnel, res.getBoolean(R.bool.DEFAULT_CLOSE_ON_IDLE)));
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_CLOSE_TIME),
+                    getCloseTime(tunnel, res.getInteger(R.integer.DEFAULT_CLOSE_TIME)));
+            ed.putBoolean(res.getString(R.string.TUNNEL_OTP_NEW_KEYS), getNewDest(tunnel));
+        }
+
+        @Override
+        protected void advancedClientHttp() {
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_PASS_UA), getAllowUserAgent(tunnel));
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_PASS_REFERER), getAllowReferer(tunnel));
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_PASS_ACCEPT), getAllowAccept(tunnel));
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_ALLOW_SSL), getAllowInternalSSL(tunnel));
+            ed.putString(res.getString(R.string.TUNNEL_OPT_JUMP_LIST), getJumpList(tunnel));
+        }
+
+        @Override
+        protected void advancedClientProxy() {
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_LOCAL_AUTH), !"false".equals(getProxyAuth(tunnel)));
+            ed.putString(res.getString(R.string.TUNNEL_OPT_LOCAL_USERNAME), "");
+            ed.putString(res.getString(R.string.TUNNEL_OPT_LOCAL_PASSWORD), "");
+            ed.putBoolean(res.getString(R.string.TUNNEL_OPT_OUTPROXY_AUTH), getOutproxyAuth(tunnel));
+            ed.putString(res.getString(R.string.TUNNEL_OPT_OUTPROXY_USERNAME), getOutproxyUsername(tunnel));
+            ed.putString(res.getString(R.string.TUNNEL_OPT_OUTPROXY_PASSWORD), getOutproxyPassword(tunnel));
+        }
+
+        @Override
+        protected void advancedOther() {
+            ed.putInt(res.getString(R.string.TUNNEL_OPT_SIGTYPE), getSigType(tunnel, mType));
+            ed.putString(res.getString(R.string.TUNNEL_OPT_CUSTOM_OPTIONS), getCustomOptionsString(tunnel));
+        }
+    }
+
+    public static TunnelConfig createConfigFromPreferences(Context ctx, TunnelControllerGroup tcg, int tunnel) {
+        return new TunnelUtil(tcg).createConfigFromPreferences(ctx, tunnel);
+    }
+    public TunnelConfig createConfigFromPreferences(Context ctx, int tunnel) {
+        Resources res = ctx.getResources();
+
+        // Get the current preferences for this tunnel
+        SharedPreferences prefs = ctx.getSharedPreferences(
+                getPreferencesFilename(tunnel), Context.MODE_PRIVATE);
+
+        // Create the TunnelConfig
+        TunnelConfig cfg = new TunnelConfig();
+
+        // Update the TunnelConfig from the preferences
+        cfg.setType(prefs.getString(res.getString(R.string.TUNNEL_TYPE), null));
+        String type = cfg.getType();
+
+        new TunnelConfigFromPreferences(cfg, prefs, res, _group, tunnel, type).runLogic();
+
+        return cfg;
+    }
+
+    class TunnelConfigFromPreferences extends TunnelLogic {
+        TunnelConfig cfg;
+        SharedPreferences prefs;
+        Resources res;
+        TunnelControllerGroup tcg;
+        int tunnel;
+
+        public TunnelConfigFromPreferences(TunnelConfig cfg, SharedPreferences prefs, Resources res,
+                                           TunnelControllerGroup tcg, int tunnel, String type) {
+            super(type);
+            this.cfg = cfg;
+            this.prefs = prefs;
+            this.res = res;
+            this.tcg = tcg;
+            this.tunnel = tunnel;
+        }
+
+        @Override
+        protected void general() {
+            cfg.setName(prefs.getString(res.getString(R.string.TUNNEL_NAME), null));
+            cfg.setDescription(prefs.getString(res.getString(R.string.TUNNEL_DESCRIPTION), null));
+            cfg.setStartOnLoad(prefs.getBoolean(res.getString(R.string.TUNNEL_START_ON_LOAD),
+                    res.getBoolean(R.bool.DEFAULT_START_ON_LOAD)));
+            if (!isClient(mType) || prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_PERSISTENT_KEY),
+                    res.getBoolean(R.bool.DEFAULT_PERSISTENT_KEY)))
+                cfg.setPrivKeyFile(prefs.getString(res.getString(R.string.TUNNEL_PRIV_KEY_FILE),
+                        getPrivateKeyFile(tcg, tunnel)));
+        }
+
+        @Override
+        protected void generalClient() {
+            // See advancedClient() for persistent key handling
+        }
+
+        @Override
+        protected void generalClientStreamr(boolean isStreamr) {
+            if (isStreamr)
+                cfg.setTargetHost(prefs.getString(res.getString(R.string.TUNNEL_TARGET_HOST), null));
+            else
+                cfg.setShared(prefs.getBoolean(res.getString(R.string.TUNNEL_SHARED_CLIENT),
+                        res.getBoolean(R.bool.DEFAULT_SHARED_CLIENTS)));
+        }
+
+        @Override
+        protected void generalClientPort() {
+            cfg.setPort(prefs.getInt(res.getString(R.string.TUNNEL_LISTEN_PORT), -1));
+        }
+
+        @Override
+        protected void generalClientPortStreamr(boolean isStreamr) {
+            if (!isStreamr)
+                cfg.setReachableBy(prefs.getString(res.getString(R.string.TUNNEL_INTERFACE), "127.0.0.1"));
+        }
+
+        @Override
+        protected void generalClientProxy(boolean isProxy) {
+            if (isProxy)
+                cfg.setProxyList(prefs.getString(res.getString(R.string.TUNNEL_PROXIES), null));
+            else
+                cfg.setTargetDestination(prefs.getString(res.getString(R.string.TUNNEL_DEST), null));
+        }
+
+        @Override
+        protected void generalClientProxyHttp(boolean isHttp) {
+            if (isHttp)
+                cfg.setSslProxies(prefs.getString(res.getString(R.string.TUNNEL_HTTPCLIENT_SSL_OUTPROXIES), null));
+        }
+
+        @Override
+        protected void generalClientStandardOrIrc(boolean isStandardOrIrc) {
+            if (isStandardOrIrc)
+                cfg.setUseSSL(prefs.getBoolean(res.getString(R.string.TUNNEL_USE_SSL), false));
+        }
+
+        @Override
+        protected void generalClientIrc() {
+            cfg.setDCC(prefs.getBoolean(res.getString(R.string.TUNNEL_IRCCLIENT_ENABLE_DCC), false));
+        }
+
+        @Override
+        protected void generalServerHttp() {
+            cfg.setSpoofedHost(prefs.getString(res.getString(R.string.TUNNEL_SPOOFED_HOST), null));
+        }
+
+        @Override
+        protected void generalServerHttpBidirOrStreamr(boolean isStreamr) {
+            cfg.setReachableBy(prefs.getString(res.getString(R.string.TUNNEL_INTERFACE), "127.0.0.1"));
+            if (!isStreamr)
+                cfg.setPort(prefs.getInt(res.getString(R.string.TUNNEL_LISTEN_PORT), -1));
+        }
+
+        @Override
+        protected void generalServerPort() {
+            cfg.setTargetPort(prefs.getInt(res.getString(R.string.TUNNEL_TARGET_PORT), -1));
+        }
+
+        @Override
+        protected void generalServerPortStreamr(boolean isStreamr) {
+            if (!isStreamr) {
+                cfg.setTargetHost(prefs.getString(res.getString(R.string.TUNNEL_TARGET_HOST), "127.0.0.1"));
+                cfg.setUseSSL(prefs.getBoolean(res.getString(R.string.TUNNEL_USE_SSL), false));
+            }
+        }
+
+        @Override
+        protected void advanced() {
+            cfg.setTunnelDepth(prefs.getInt(res.getString(R.string.TUNNEL_OPT_LENGTH),
+                    res.getInteger(R.integer.DEFAULT_TUNNEL_LENGTH)));
+            cfg.setTunnelVariance(prefs.getInt(res.getString(R.string.TUNNEL_OPT_VARIANCE),
+                    res.getInteger(R.integer.DEFAULT_TUNNEL_VARIANCE)));
+            cfg.setTunnelQuantity(prefs.getInt(res.getString(R.string.TUNNEL_OPT_QUANTITY),
+                    res.getInteger(R.integer.DEFAULT_TUNNEL_QUANTITY)));
+            cfg.setTunnelBackupQuantity(prefs.getInt(res.getString(R.string.TUNNEL_OPT_BACKUP_QUANTITY),
+                    res.getInteger(R.integer.DEFAULT_TUNNEL_BACKUP_QUANTITY)));
+        }
+
+        @Override
+        protected void advancedStreamr(boolean isStreamr) {
+            if (!isStreamr)
+                cfg.setProfile(prefs.getString(res.getString(R.string.TUNNEL_OPT_PROFILE), "bulk"));
+        }
+
+        @Override
+        protected void advancedServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (!isServerOrStreamrClient)
+                cfg.setConnectDelay(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_DELAY_CONNECT), false));
+        }
+
+        @Override
+        protected void advancedServer() {
+            //cfg.setEncrypt(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_ENCRYPT), false));
+            //cfg.setEncryptKey(prefs.getString(res.getString(R.string.TUNNEL_OPT_ENCRYPT_KEY), ""));
+            cfg.setAccessMode(prefs.getInt(res.getString(R.string.TUNNEL_OPT_ACCESS_MODE), 0));
+            cfg.setAccessList(prefs.getString(res.getString(R.string.TUNNEL_OPT_ACCESS_LIST), ""));
+            cfg.setUniqueLocal(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_UNIQUE_LOCAL), false));
+            cfg.setMultihome(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_MULTIHOME), false));
+            cfg.setLimitMinute(prefs.getInt(res.getString(R.string.TUNNEL_OPT_LIMIT_MINUTE), 0));
+            cfg.setLimitHour(prefs.getInt(res.getString(R.string.TUNNEL_OPT_LIMIT_HOUR), 0));
+            cfg.setLimitDay(prefs.getInt(res.getString(R.string.TUNNEL_OPT_LIMIT_DAY), 0));
+            cfg.setTotalMinute(prefs.getInt(res.getString(R.string.TUNNEL_OPT_TOTAL_MINUTE), 0));
+            cfg.setTotalHour(prefs.getInt(res.getString(R.string.TUNNEL_OPT_TOTAL_HOUR), 0));
+            cfg.setTotalDay(prefs.getInt(res.getString(R.string.TUNNEL_OPT_TOTAL_DAY), 0));
+            cfg.setMaxStreams(prefs.getInt(res.getString(R.string.TUNNEL_OPT_MAX_STREAMS), 0));
+        }
+
+        @Override
+        protected void advancedServerHttp(boolean isHttp) {
+            if (isHttp) {
+                cfg.setRejectInproxy(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_REJECT_INPROXY), false));
+                cfg.setPostCheckTime(prefs.getInt(res.getString(R.string.TUNNEL_OPT_POST_CHECK_TIME), 0));
+                cfg.setPostMax(prefs.getInt(res.getString(R.string.TUNNEL_OPT_POST_MAX), 0));
+                cfg.setPostBanTime(prefs.getInt(res.getString(R.string.TUNNEL_OPT_POST_BAN_TIME), 0));
+                cfg.setPostTotalMax(prefs.getInt(res.getString(R.string.TUNNEL_OPT_POST_TOTAL_MAX), 0));
+                cfg.setPostTotalBanTime(prefs.getInt(res.getString(R.string.TUNNEL_OPT_POST_TOTAL_BAN_TIME), 0));
+            }
+        }
+
+        @Override
+        protected void advancedIdle() {
+            cfg.setReduce(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_REDUCE_IDLE),
+                    res.getBoolean(R.bool.DEFAULT_REDUCE_ON_IDLE)));
+            cfg.setReduceCount(prefs.getInt(res.getString(R.string.TUNNEL_OPT_REDUCE_QUANTITY),
+                    res.getInteger(R.integer.DEFAULT_REDUCE_COUNT)));
+            cfg.setReduceTime(prefs.getInt(res.getString(R.string.TUNNEL_OPT_REDUCE_TIME),
+                    res.getInteger(R.integer.DEFAULT_REDUCE_TIME)));
+        }
+
+        @Override
+        protected void advancedIdleServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (!isServerOrStreamrClient)
+                cfg.setDelayOpen(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_DELAY_OPEN),
+                        res.getBoolean(R.bool.DEFAULT_DELAY_OPEN)));
+        }
+
+        @Override
+        protected void advancedClient() {
+            cfg.setClose(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_CLOSE_IDLE),
+                    res.getBoolean(R.bool.DEFAULT_CLOSE_ON_IDLE)));
+            cfg.setCloseTime(prefs.getInt(res.getString(R.string.TUNNEL_OPT_CLOSE_TIME),
+                    res.getInteger(R.integer.DEFAULT_CLOSE_TIME)));
+            cfg.setNewDest(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_PERSISTENT_KEY),
+                    res.getBoolean(R.bool.DEFAULT_PERSISTENT_KEY)) ? 2 :
+                    prefs.getBoolean(res.getString(R.string.TUNNEL_OTP_NEW_KEYS), res.getBoolean(R.bool.DEFAULT_NEW_KEYS)) ? 1 : 0);
+        }
+
+        @Override
+        protected void advancedClientHttp() {
+            cfg.setAllowUserAgent(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_PASS_UA), false));
+            cfg.setAllowReferer(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_PASS_REFERER), false));
+            cfg.setAllowAccept(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_PASS_ACCEPT), false));
+            cfg.setAllowInternalSSL(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_HTTPCLIENT_ALLOW_SSL), false));
+            cfg.setJumpList(prefs.getString(res.getString(R.string.TUNNEL_OPT_JUMP_LIST),
+                    res.getString(R.string.DEFAULT_JUMP_LIST)));
+        }
+
+        @Override
+        protected void advancedClientProxy() {
+            cfg.setProxyAuth(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_LOCAL_AUTH), false) ? "digest" : "false");
+            String username = prefs.getString(res.getString(R.string.TUNNEL_OPT_LOCAL_USERNAME), "");
+            if (!username.isEmpty()) {
+                cfg.setProxyUsername(username);
+                cfg.setProxyPassword(prefs.getString(res.getString(R.string.TUNNEL_OPT_LOCAL_PASSWORD), ""));
+            }
+            cfg.setOutproxyAuth(prefs.getBoolean(res.getString(R.string.TUNNEL_OPT_OUTPROXY_AUTH), false));
+            cfg.setOutproxyUsername(prefs.getString(res.getString(R.string.TUNNEL_OPT_OUTPROXY_USERNAME), ""));
+            cfg.setOutproxyPassword(prefs.getString(res.getString(R.string.TUNNEL_OPT_OUTPROXY_PASSWORD), ""));
+        }
+
+        @Override
+        protected void advancedOther() {
+            cfg.setSigType(Integer.toString(prefs.getInt(res.getString(R.string.TUNNEL_OPT_SIGTYPE),
+                    res.getInteger(R.integer.DEFAULT_SIGTYPE))));
+            cfg.setCustomOptions(prefs.getString(res.getString(R.string.TUNNEL_OPT_CUSTOM_OPTIONS), null));
+        }
+    }
+
+    public static TunnelConfig createConfigFromWizard(
+            Context ctx, TunnelControllerGroup tcg, Bundle data) {
+        return new TunnelUtil(tcg).createConfigFromWizard(ctx, data);
+    }
+    public TunnelConfig createConfigFromWizard(Context ctx, Bundle data) {
+        // Get the Bundle keys
+        Resources res = ctx.getResources();
+
+        // Create the TunnelConfig
+        TunnelConfig cfg = new TunnelConfig();
+
+        // Update the TunnelConfig from the tunnel wizard settings
+        String kClientServer = res.getString(R.string.i2ptunnel_wizard_k_client_server);
+        String kType = res.getString(R.string.i2ptunnel_wizard_k_type);
+        String clientServer = data.getBundle(kClientServer).getString(Page.SIMPLE_DATA_KEY);
+        String typeName = data.getBundle(clientServer + ":" + kType).getString(Page.SIMPLE_DATA_KEY);
+        String type = getTypeFromName(typeName, ctx);
+        cfg.setType(type);
+
+        new TunnelConfigFromWizard(cfg, data, res, _group, type).runLogic();
+
+        return cfg;
+    }
+
+    class TunnelConfigFromWizard extends TunnelLogic {
+        TunnelConfig cfg;
+        Bundle data;
+        Resources res;
+        TunnelControllerGroup tcg;
+
+        public TunnelConfigFromWizard(TunnelConfig cfg, Bundle data, Resources res,
+                                           TunnelControllerGroup tcg, String type) {
+            super(type);
+            this.cfg = cfg;
+            this.data = data;
+            this.res = res;
+            this.tcg = tcg;
+        }
+
+        @Override
+        protected void general() {
+            cfg.setName(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_name)).getString(Page.SIMPLE_DATA_KEY));
+            cfg.setDescription(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_desc)).getString(Page.SIMPLE_DATA_KEY));
+            cfg.setStartOnLoad(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_auto_start)).getBoolean(Page.SIMPLE_DATA_KEY));
+
+            if (!isClient(mType) || res.getBoolean(R.bool.DEFAULT_PERSISTENT_KEY))
+                cfg.setPrivKeyFile(getPrivateKeyFile(tcg, -1));
+        }
+
+        @Override
+        protected void generalClient() {
+            // See advancedClient() for persistent key handling
+        }
+
+        @Override
+        protected void generalClientStreamr(boolean isStreamr) {
+            if (isStreamr)
+                cfg.setTargetHost(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_target_host)).getString(Page.SIMPLE_DATA_KEY));
+            else
+                cfg.setShared(res.getBoolean(R.bool.DEFAULT_SHARED_CLIENTS));
+
+            // Only set default tunnel parameters if this is not going to be a shared tunnel
+            if (isStreamr || res.getBoolean(R.bool.DEFAULT_SHARED_CLIENTS)) {
+                cfg.setTunnelDepth(res.getInteger(R.integer.DEFAULT_TUNNEL_LENGTH));
+                cfg.setTunnelVariance(res.getInteger(R.integer.DEFAULT_TUNNEL_VARIANCE));
+                cfg.setTunnelQuantity(res.getInteger(R.integer.DEFAULT_TUNNEL_QUANTITY));
+                cfg.setTunnelBackupQuantity(res.getInteger(R.integer.DEFAULT_TUNNEL_BACKUP_QUANTITY));
+            }
+        }
+
+        @Override
+        protected void generalClientPort() {
+            cfg.setPort(Integer.parseInt(data.getBundle(
+                    res.getString(R.string.i2ptunnel_wizard_k_binding_port)).getString(Page.SIMPLE_DATA_KEY)));
+        }
+
+        @Override
+        protected void generalClientPortStreamr(boolean isStreamr) {
+            if (!isStreamr)
+                cfg.setReachableBy(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_reachable_on)).getString(Page.SIMPLE_DATA_KEY));
+        }
+
+        @Override
+        protected void generalClientProxy(boolean isProxy) {
+            if (isProxy)
+                cfg.setProxyList(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_outproxies)).getString(Page.SIMPLE_DATA_KEY));
+            else
+                cfg.setTargetDestination(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_dest)).getString(Page.SIMPLE_DATA_KEY));
+        }
+
+        @Override
+        protected void generalClientProxyHttp(boolean isHttp) {
+            if (isHttp)
+                cfg.setSslProxies(null);
+        }
+
+        @Override
+        protected void generalClientStandardOrIrc(boolean isStandardOrIrc) {
+            if (isStandardOrIrc)
+                cfg.setUseSSL(false);
+        }
+
+        @Override
+        protected void generalClientIrc() {
+            cfg.setDCC(false);
+        }
+
+        @Override
+        protected void generalServerHttp() {
+            cfg.setSpoofedHost(null);
+        }
+
+        @Override
+        protected void generalServerHttpBidirOrStreamr(boolean isStreamr) {
+            cfg.setReachableBy(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_reachable_on)).getString(Page.SIMPLE_DATA_KEY));
+            if (!isStreamr)
+                cfg.setPort(Integer.parseInt(data.getBundle(
+                        res.getString(R.string.i2ptunnel_wizard_k_binding_port)).getString(Page.SIMPLE_DATA_KEY)));
+        }
+
+        @Override
+        protected void generalServerPort() {
+            cfg.setTargetPort(Integer.parseInt(data.getBundle(
+                    res.getString(R.string.i2ptunnel_wizard_k_target_port)).getString(Page.SIMPLE_DATA_KEY)));
+        }
+
+        @Override
+        protected void generalServerPortStreamr(boolean isStreamr) {
+            if (!isStreamr) {
+                cfg.setTargetHost(data.getBundle(res.getString(R.string.i2ptunnel_wizard_k_target_host)).getString(Page.SIMPLE_DATA_KEY));
+                cfg.setUseSSL(false);
+            }
+        }
+
+        @Override
+        protected void advanced() {
+            // Tunnel parameters handled in generalClientStreamr()
+        }
+
+        @Override
+        protected void advancedStreamr(boolean isStreamr) {
+            if (!isStreamr)
+                cfg.setProfile("bulk");
+        }
+
+        @Override
+        protected void advancedServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (!isServerOrStreamrClient)
+                cfg.setConnectDelay(false);
+        }
+
+        @Override
+        protected void advancedServer() {
+            cfg.setEncrypt(false);
+            cfg.setAccessMode(0);
+            cfg.setUniqueLocal(false);
+            cfg.setMultihome(false);
+            cfg.setLimitMinute(0);
+            cfg.setLimitHour(0);
+            cfg.setLimitDay(0);
+            cfg.setTotalMinute(0);
+            cfg.setTotalHour(0);
+            cfg.setTotalDay(0);
+            cfg.setMaxStreams(0);
+        }
+
+        @Override
+        protected void advancedServerHttp(boolean isHttp) {
+            if (isHttp) {
+                cfg.setRejectInproxy(false);
+                cfg.setPostCheckTime(0);
+                cfg.setPostMax(0);
+                cfg.setPostBanTime(0);
+                cfg.setPostTotalMax(0);
+                cfg.setPostTotalBanTime(0);
+            }
+        }
+
+        @Override
+        protected void advancedIdle() {
+            cfg.setReduce(res.getBoolean(R.bool.DEFAULT_REDUCE_ON_IDLE));
+            cfg.setReduceCount(res.getInteger(R.integer.DEFAULT_REDUCE_COUNT));
+            cfg.setReduceTime(res.getInteger(R.integer.DEFAULT_REDUCE_TIME));
+        }
+
+        @Override
+        protected void advancedIdleServerOrStreamrClient(boolean isServerOrStreamrClient) {
+            if (!isServerOrStreamrClient)
+                cfg.setDelayOpen(res.getBoolean(R.bool.DEFAULT_DELAY_OPEN));
+        }
+
+        @Override
+        protected void advancedClient() {
+            cfg.setClose(res.getBoolean(R.bool.DEFAULT_CLOSE_ON_IDLE));
+            cfg.setCloseTime(res.getInteger(R.integer.DEFAULT_CLOSE_TIME));
+            cfg.setNewDest(res.getBoolean(R.bool.DEFAULT_PERSISTENT_KEY) ? 2 :
+                    res.getBoolean(R.bool.DEFAULT_NEW_KEYS) ? 1 : 0);
+        }
+
+        @Override
+        protected void advancedClientHttp() {
+            cfg.setAllowUserAgent(false);
+            cfg.setAllowReferer(false);
+            cfg.setAllowAccept(false);
+            cfg.setAllowInternalSSL(false);
+            cfg.setJumpList(res.getString(R.string.DEFAULT_JUMP_LIST));
+        }
+
+        @Override
+        protected void advancedClientProxy() {
+            cfg.setProxyAuth("false");
+            cfg.setOutproxyAuth(false);
+        }
+
+        @Override
+        protected void advancedOther() {
+            cfg.setSigType(Integer.toString(res.getInteger(R.integer.DEFAULT_SIGTYPE)));
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/AdvancedPreferenceFragment.java

@@ -0,0 +1,59 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceFragmentCompat;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+
+public class AdvancedPreferenceFragment extends PreferenceFragmentCompat {
+    private static final String PREFERENCE_CATEGORY_TRANSPORTS = "preference_category_transports";
+    private static final String PREFERENCE_CATEGORY_EXPL_TUNNELS = "preference_category_expl_tunnels";
+
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        addPreferencesFromResource(R.xml.settings_advanced);
+
+        findPreference(PREFERENCE_CATEGORY_TRANSPORTS)
+                .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_TRANSPORTS));
+        findPreference(PREFERENCE_CATEGORY_EXPL_TUNNELS)
+                .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_EXPL_TUNNELS));
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.settings_label_advanced);
+    }
+
+    private class CategoryClickListener implements Preference.OnPreferenceClickListener {
+        private String category;
+
+        public CategoryClickListener(String category) {
+            this.category = category;
+        }
+
+        @Override
+        public boolean onPreferenceClick(Preference preference) {
+            Fragment fragment;
+            switch (category) {
+                case PREFERENCE_CATEGORY_TRANSPORTS:
+                    fragment = new TransportsPreferenceFragment();
+                    break;
+                case PREFERENCE_CATEGORY_EXPL_TUNNELS:
+                    fragment = new ExploratoryPoolPreferenceFragment();
+                    break;
+                default:
+                    throw new AssertionError();
+            }
+
+            getActivity().getSupportFragmentManager().beginTransaction()
+                    .replace(R.id.fragment, fragment)
+                    .addToBackStack(null)
+                    .commit();
+            return true;
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/AppearancePreferenceFragment.java

@@ -0,0 +1,35 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+
+public class AppearancePreferenceFragment extends I2PreferenceFragment {
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        addPreferencesFromResource(R.xml.settings_appearance);
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        getPreferenceScreen().getSharedPreferences().registerOnSharedPreferenceChangeListener(
+                (SettingsActivity) getActivity()
+        );
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.settings_label_appearance);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        getPreferenceScreen().getSharedPreferences().unregisterOnSharedPreferenceChangeListener(
+                (SettingsActivity) getActivity()
+        );
+    }
+}

app/src/main/java/net/i2p/android/preferences/ExploratoryPoolPreferenceFragment.java

@@ -0,0 +1,19 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+
+public class ExploratoryPoolPreferenceFragment extends I2PreferenceFragment {
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        addPreferencesFromResource(R.xml.settings_expl_tunnels);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.settings_label_exploratory_pool);
+    }
+}

app/src/main/java/net/i2p/android/preferences/GraphsPreferenceFragment.java

@@ -0,0 +1,107 @@
+package net.i2p.android.preferences;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.support.v7.preference.CheckBoxPreference;
+import android.support.v7.preference.PreferenceCategory;
+import android.support.v7.preference.PreferenceManager;
+import android.support.v7.preference.PreferenceScreen;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+import net.i2p.android.router.service.StatSummarizer;
+import net.i2p.android.router.util.Util;
+import net.i2p.router.RouterContext;
+import net.i2p.stat.FrequencyStat;
+import net.i2p.stat.Rate;
+import net.i2p.stat.RateStat;
+import net.i2p.stat.StatManager;
+
+import java.util.Map;
+import java.util.SortedSet;
+
+public class GraphsPreferenceFragment extends I2PreferenceFragment {
+    public static final String GRAPH_PREFERENCES_SEEN = "graphPreferencesSeen";
+
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        addPreferencesFromResource(R.xml.settings_graphs);
+        setupGraphSettings();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.label_graphs);
+    }
+
+    private void setupGraphSettings() {
+        PreferenceScreen ps = getPreferenceScreen();
+        RouterContext ctx = Util.getRouterContext();
+        if (ctx == null) {
+            PreferenceCategory noRouter = new PreferenceCategory(getActivity());
+            noRouter.setTitle(R.string.router_not_running);
+            ps.addPreference(noRouter);
+        } else if (StatSummarizer.instance() == null) {
+            PreferenceCategory noStats = new PreferenceCategory(getActivity());
+            noStats.setTitle(R.string.stats_not_ready);
+            ps.addPreference(noStats);
+        } else {
+            StatManager mgr = ctx.statManager();
+            Map<String, SortedSet<String>> all = mgr.getStatsByGroup();
+            for (String group : all.keySet()) {
+                SortedSet<String> stats = all.get(group);
+                if (stats.size() == 0) continue;
+                PreferenceCategory groupPrefs = new PreferenceCategory(getActivity());
+                groupPrefs.setKey("stat.groups." + group);
+                groupPrefs.setTitle(group);
+                ps.addPreference(groupPrefs);
+                for (String stat : stats) {
+                    String key;
+                    String description;
+                    boolean canBeGraphed = false;
+                    boolean currentIsGraphed = false;
+                    RateStat rs = mgr.getRate(stat);
+                    if (rs != null) {
+                        description = rs.getDescription();
+                        long period = rs.getPeriods()[0]; // should be the minimum
+                        key = stat + "." + period;
+                        if (period <= 10*60*1000) {
+                            Rate r = rs.getRate(period);
+                            canBeGraphed = r != null;
+                            if (canBeGraphed) {
+                                currentIsGraphed = r.getSummaryListener() != null;
+                            }
+                        }
+                    } else {
+                        FrequencyStat fs = mgr.getFrequency(stat);
+                        if (fs != null) {
+                            key = stat;
+                            description = fs.getDescription();
+                            // FrequencyStats cannot be graphed, but can be logged.
+                            // XXX: Should log settings be here as well, or in a
+                            // separate settings menu?
+                        } else {
+                            Util.e("Stat does not exist?!  [" + stat + "]");
+                            continue;
+                        }
+                    }
+                    CheckBoxPreference statPref = new CheckBoxPreference(getActivity());
+                    statPref.setKey("stat.summaries." + key);
+                    statPref.setTitle(stat);
+                    statPref.setSummary(description);
+                    statPref.setEnabled(canBeGraphed);
+                    statPref.setChecked(currentIsGraphed);
+                    groupPrefs.addPreference(statPref);
+                }
+            }
+
+            // The user has now seen the current (possibly default) configuration
+            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
+            if (!prefs.getBoolean(GRAPH_PREFERENCES_SEEN, false))
+                prefs.edit()
+                        .putBoolean(GRAPH_PREFERENCES_SEEN, true)
+                        .apply();
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/I2PreferenceFragment.java

@@ -0,0 +1,72 @@
+package net.i2p.android.preferences;
+
+import android.widget.Toast;
+
+import net.i2p.I2PAppContext;
+import net.i2p.android.preferences.util.CustomPreferenceFragment;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.router.RouterContext;
+
+import java.util.List;
+import java.util.Properties;
+import java.util.Set;
+
+/**
+ * A PreferenceFragment that handles saving router settings.
+ */
+public abstract class I2PreferenceFragment extends CustomPreferenceFragment {
+    @Override
+    public void onPause() {
+        List<Properties> lProps = Util.getPropertiesFromPreferences(getActivity());
+        Properties props = lProps.get(0);
+        Properties propsToRemove = lProps.get(1);
+        Properties logSettings = lProps.get(2);
+
+        Set toRemove = propsToRemove.keySet();
+
+        boolean restartRequired = Util.checkAndCorrectRouterConfig(getActivity(), props, toRemove);
+
+        // Apply new config if we are running.
+        RouterContext rCtx = Util.getRouterContext();
+        if (rCtx != null) {
+            rCtx.router().saveConfig(props, toRemove);
+
+            // Merge in new log settings
+            saveLoggingChanges(rCtx, logSettings);
+        } else {
+            // Merge in new config settings, write the file.
+            Util.mergeResourceToFile(getActivity(),
+                    Util.getFileDir(getActivity()),
+                    "router.config", R.raw.router_config, props, toRemove);
+
+            // Merge in new log settings
+            saveLoggingChanges(I2PAppContext.getGlobalContext(), logSettings);
+        }
+
+        // Store the settings in Android
+        super.onPause();
+
+        if (restartRequired)
+            Toast.makeText(getActivity(), R.string.settings_router_restart_required, Toast.LENGTH_LONG).show();
+    }
+
+    private void saveLoggingChanges(I2PAppContext ctx, Properties logSettings) {
+        boolean shouldSave = false;
+
+        for (Object key : logSettings.keySet()) {
+            if ("logger.defaultLevel".equals(key)) {
+                String defaultLevel = (String) logSettings.get(key);
+                String oldDefault = ctx.logManager().getDefaultLimit();
+                if (!defaultLevel.equals(oldDefault)) {
+                    shouldSave = true;
+                    ctx.logManager().setDefaultLimit(defaultLevel);
+                }
+            }
+        }
+
+        if (shouldSave) {
+            ctx.logManager().saveConfig();
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/LoggingPreferenceFragment.java

@@ -0,0 +1,53 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+import android.support.v7.preference.PreferenceScreen;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+import net.i2p.android.router.util.Util;
+import net.i2p.router.RouterContext;
+import net.i2p.util.LogManager;
+
+public class LoggingPreferenceFragment extends I2PreferenceFragment {
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        addPreferencesFromResource(R.xml.settings_logging);
+        setupLoggingSettings();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.settings_label_logging);
+    }
+
+    private void setupLoggingSettings() {
+        PreferenceScreen ps = getPreferenceScreen();
+        RouterContext ctx = Util.getRouterContext();
+        if (ctx != null) {
+            LogManager mgr = ctx.logManager();
+            // Log level overrides
+            /*
+            StringBuilder buf = new StringBuilder(32*1024);
+            Properties limits = mgr.getLimits();
+            TreeSet<String> sortedLogs = new TreeSet<String>();
+            for (Iterator iter = limits.keySet().iterator(); iter.hasNext(); ) {
+                String prefix = (String)iter.next();
+                sortedLogs.add(prefix);
+            }
+            for (Iterator iter = sortedLogs.iterator(); iter.hasNext(); ) {
+                String prefix = (String)iter.next();
+                String level = limits.getProperty(prefix);
+                buf.append(prefix).append('=').append(level).append('\n');
+            }
+            */
+            /* Don't show, there are no settings that require the router
+        } else {
+            PreferenceCategory noRouter = new PreferenceCategory(getActivity());
+            noRouter.setTitle(R.string.router_not_running);
+            ps.addPreference(noRouter);
+            */
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/NetworkPreferenceFragment.java

@@ -0,0 +1,19 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+
+public class NetworkPreferenceFragment extends I2PreferenceFragment {
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        addPreferencesFromResource(R.xml.settings_net);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.settings_label_bandwidth_net);
+    }
+}

app/src/main/java/net/i2p/android/preferences/TransportsPreferenceFragment.java

@@ -0,0 +1,121 @@
+package net.i2p.android.preferences;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.support.v7.preference.CheckBoxPreference;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceManager;
+import android.support.v7.preference.PreferenceScreen;
+import android.widget.Toast;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+import net.i2p.android.preferences.util.PortPreference;
+import net.i2p.android.router.util.Util;
+import net.i2p.router.RouterContext;
+
+public class TransportsPreferenceFragment extends I2PreferenceFragment {
+    @Override
+    public void onCreatePreferences(Bundle paramBundle, String s) {
+        // Load any properties that the router might have changed on us.
+        loadProperties();
+        addPreferencesFromResource(R.xml.settings_transports);
+        setupTransportSettings();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.settings_label_transports);
+    }
+
+    private void loadProperties() {
+        Context context= getActivity();
+        RouterContext ctx = Util.getRouterContext();
+        if (ctx != null) {
+            final String udpPortKey = context.getString(R.string.PROP_UDP_INTERNAL_PORT);
+            final String ntcpPortKey = context.getString(R.string.PROP_I2NP_NTCP_PORT);
+            final String ntcpAutoPortKey = context.getString(R.string.PROP_I2NP_NTCP_AUTO_PORT);
+
+            int udpPort = ctx.getProperty(udpPortKey, -1);
+            int ntcpPort = ctx.getProperty(ntcpPortKey, -1);
+            boolean ntcpAutoPort = ctx.getBooleanPropertyDefaultTrue(ntcpAutoPortKey);
+            if (ntcpPort < 0 && ntcpAutoPort)
+                ntcpPort = udpPort;
+
+            SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+            if (prefs.getInt(udpPortKey, -1) != udpPort ||
+                    prefs.getInt(ntcpPortKey, -1) != ntcpPort) {
+                SharedPreferences.Editor editor = prefs.edit();
+                editor.putInt(udpPortKey, udpPort);
+                editor.putInt(ntcpPortKey, ntcpPort);
+                // commit() instead of apply() because this needs to happen
+                // before AdvancedPreferenceFragment loads its Preferences.
+                editor.commit();
+            }
+        }
+    }
+
+    private void setupTransportSettings() {
+        final Context context= getActivity();
+        PreferenceScreen ps = getPreferenceScreen();
+
+        final String udpEnableKey = context.getString(R.string.PROP_ENABLE_UDP);
+        final String ntcpEnableKey = context.getString(R.string.PROP_ENABLE_NTCP);
+        final String udpPortKey = context.getString(R.string.PROP_UDP_INTERNAL_PORT);
+        final String ntcpPortKey = context.getString(R.string.PROP_I2NP_NTCP_PORT);
+        final String ntcpAutoPortKey = context.getString(R.string.PROP_I2NP_NTCP_AUTO_PORT);
+
+        final CheckBoxPreference udpEnable = (CheckBoxPreference) ps.findPreference(udpEnableKey);
+        final CheckBoxPreference ntcpEnable = (CheckBoxPreference) ps.findPreference(ntcpEnableKey);
+        final PortPreference udpPort = (PortPreference) ps.findPreference(udpPortKey);
+        final PortPreference ntcpPort = (PortPreference) ps.findPreference(ntcpPortKey);
+        final CheckBoxPreference ntcpAutoPort = (CheckBoxPreference) ps.findPreference(ntcpAutoPortKey);
+
+        udpEnable.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+            @Override
+            public boolean onPreferenceChange(Preference preference, Object newValue) {
+                final Boolean checked = (Boolean) newValue;
+                if (checked || ntcpEnable.isChecked())
+                    return true;
+                else {
+                    Toast.makeText(context, R.string.settings_need_transport_enabled, Toast.LENGTH_LONG).show();
+                    return false;
+                }
+            }
+        });
+
+        ntcpEnable.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+            @Override
+            public boolean onPreferenceChange(Preference preference, Object newValue) {
+                final Boolean checked = (Boolean) newValue;
+                if (checked || udpEnable.isChecked())
+                    return true;
+                else {
+                    Toast.makeText(context, R.string.settings_need_transport_enabled, Toast.LENGTH_LONG).show();
+                    return false;
+                }
+            }
+        });
+
+        udpPort.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+            @Override
+            public boolean onPreferenceChange(Preference preference, Object newValue) {
+                if (ntcpAutoPort.isChecked())
+                    ntcpPort.setText((String) newValue);
+                return true;
+            }
+        });
+
+        ntcpAutoPort.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+            @Override
+            public boolean onPreferenceChange(Preference preference, Object newValue) {
+                final Boolean checked = (Boolean) newValue;
+                if (checked)
+                    ntcpPort.setText(udpPort.getText());
+                return true;
+            }
+        });
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/ConnectionLimitPreference.java

@@ -0,0 +1,77 @@
+package net.i2p.android.preferences.util;
+
+import android.content.Context;
+import android.content.res.TypedArray;
+import android.support.v7.preference.EditTextPreference;
+import android.util.AttributeSet;
+
+import net.i2p.android.router.R;
+
+public class ConnectionLimitPreference extends EditTextPreference {
+    private boolean mValueInTitle;
+
+    public ConnectionLimitPreference(Context context) {
+        this(context, null);
+    }
+
+    public ConnectionLimitPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+        init(context, attrs);
+    }
+
+    public ConnectionLimitPreference(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+        init(context, attrs);
+    }
+
+    void init(Context context, AttributeSet attrs) {
+        TypedArray attr = context.obtainStyledAttributes(attrs, R.styleable.ConnectionLimitPreference, 0, 0);
+        mValueInTitle = attr.getBoolean(R.styleable.ConnectionLimitPreference_clp_valueInTitle, false);
+        attr.recycle();
+    }
+
+    @Override
+    public CharSequence getTitle() {
+        if (mValueInTitle)
+            return formatValue((String) super.getTitle());
+        else
+            return super.getTitle();
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        if (mValueInTitle)
+            return super.getSummary();
+        else
+            return formatValue((String) super.getSummary());
+    }
+
+    private CharSequence formatValue(String format) {
+        String text = getText();
+        if ("0".equals(text))
+            text = getContext().getString(R.string.unlimited);
+
+        if (format == null)
+            format = "%s";
+        return String.format(format, text);
+    }
+
+    @Override
+    protected String getPersistedString(String defaultReturnValue) {
+        if(getSharedPreferences().contains(getKey())) {
+            int intValue = getPersistedInt(0);
+            return String.valueOf(intValue);
+        } else {
+            return defaultReturnValue;
+        }
+    }
+
+    @Override
+    protected boolean persistString(String value) {
+        try {
+            return value != null && persistInt(Integer.valueOf(value));
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/ConnectionLimitPreferenceDialog.java

@@ -0,0 +1,24 @@
+package net.i2p.android.preferences.util;
+
+import android.os.Bundle;
+import android.support.v7.preference.EditTextPreferenceDialogFragmentCompat;
+import android.text.InputType;
+import android.view.View;
+import android.widget.EditText;
+
+public class ConnectionLimitPreferenceDialog extends EditTextPreferenceDialogFragmentCompat {
+    public static ConnectionLimitPreferenceDialog newInstance(String key) {
+        final ConnectionLimitPreferenceDialog fragment = new ConnectionLimitPreferenceDialog();
+        final Bundle b = new Bundle(1);
+        b.putString(ARG_KEY, key);
+        fragment.setArguments(b);
+        return fragment;
+    }
+
+    @Override
+    protected void onBindDialogView(View view) {
+        super.onBindDialogView(view);
+        ((EditText)view.findViewById(android.R.id.edit)).setInputType(
+                InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED);
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/CustomPreferenceFragment.java

@@ -0,0 +1,36 @@
+package net.i2p.android.preferences.util;
+
+import android.support.v4.app.DialogFragment;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceFragmentCompat;
+
+/**
+ * Handles custom Preferences.
+ */
+public abstract class CustomPreferenceFragment extends PreferenceFragmentCompat {
+    private static final String DIALOG_FRAGMENT_TAG =
+            "android.support.v7.preference.PreferenceFragment.DIALOG";
+
+    @Override
+    public void onDisplayPreferenceDialog(Preference preference) {
+        // check if dialog is already showing
+        if (getFragmentManager().findFragmentByTag(DIALOG_FRAGMENT_TAG) != null) {
+            return;
+        }
+
+        DialogFragment f = null;
+        if (preference instanceof ConnectionLimitPreference) {
+            f = ConnectionLimitPreferenceDialog.newInstance(preference.getKey());
+        } else if (preference instanceof IntEditTextPreference) {
+            f = IntEditTextPreferenceDialog.newInstance(preference.getKey());
+        } else if (preference instanceof PortPreference) {
+            f = PortPreferenceDialog.newInstance(preference.getKey());
+        } else {
+            super.onDisplayPreferenceDialog(preference);
+        }
+        if (f != null) {
+            f.setTargetFragment(this, 0);
+            f.show(getFragmentManager(), DIALOG_FRAGMENT_TAG);
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/IntEditTextPreference.java

@@ -0,0 +1,47 @@
+package net.i2p.android.preferences.util;
+
+import android.content.Context;
+import android.support.v7.preference.EditTextPreference;
+import android.util.AttributeSet;
+
+public class IntEditTextPreference extends EditTextPreference {
+
+    public IntEditTextPreference(Context context) {
+        super(context);
+    }
+
+    public IntEditTextPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public IntEditTextPreference(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        String summary = (String) super.getSummary();
+        if (summary == null)
+            summary = "%s";
+        return String.format(summary, getText());
+    }
+
+    @Override
+    protected String getPersistedString(String defaultReturnValue) {
+        if(getSharedPreferences().contains(getKey())) {
+            int intValue = getPersistedInt(0);
+            return String.valueOf(intValue);
+        } else {
+            return defaultReturnValue;
+        }
+    }
+
+    @Override
+    protected boolean persistString(String value) {
+        try {
+            return value != null && persistInt(Integer.valueOf(value));
+        } catch (NumberFormatException e) {
+            return false;
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/IntEditTextPreferenceDialog.java

@@ -0,0 +1,24 @@
+package net.i2p.android.preferences.util;
+
+import android.os.Bundle;
+import android.support.v7.preference.EditTextPreferenceDialogFragmentCompat;
+import android.text.InputType;
+import android.view.View;
+import android.widget.EditText;
+
+public class IntEditTextPreferenceDialog extends EditTextPreferenceDialogFragmentCompat {
+    public static IntEditTextPreferenceDialog newInstance(String key) {
+        final IntEditTextPreferenceDialog fragment = new IntEditTextPreferenceDialog();
+        final Bundle b = new Bundle(1);
+        b.putString(ARG_KEY, key);
+        fragment.setArguments(b);
+        return fragment;
+    }
+
+    @Override
+    protected void onBindDialogView(View view) {
+        super.onBindDialogView(view);
+        ((EditText)view.findViewById(android.R.id.edit)).setInputType(
+                InputType.TYPE_CLASS_NUMBER | InputType.TYPE_NUMBER_FLAG_SIGNED);
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/IntListPreference.java

@@ -0,0 +1,43 @@
+package net.i2p.android.preferences.util;
+
+import android.content.Context;
+import android.support.v7.preference.ListPreference;
+import android.util.AttributeSet;
+
+public class IntListPreference extends ListPreference {
+    public IntListPreference(Context context) {
+        super(context);
+    }
+
+    public IntListPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @Override
+    protected boolean persistString(String value) {
+        if (getSharedPreferences().contains(getKey())) {
+            try {
+                getPersistedInt(0);
+            } catch (ClassCastException e) {
+                // Fix for where this preference was previously stored in a ListPreference
+                getSharedPreferences().edit().remove(getKey()).commit();
+            }
+        }
+
+        return value != null && persistInt(Integer.valueOf(value));
+    }
+
+    @Override
+    protected String getPersistedString(String defaultReturnValue) {
+        if(getSharedPreferences().contains(getKey())) {
+            try {
+                int intValue = getPersistedInt(0);
+                return String.valueOf(intValue);
+            } catch (ClassCastException e) {
+                return super.getPersistedString("0");
+            }
+        } else {
+            return defaultReturnValue;
+        }
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/PortPreference.java

@@ -0,0 +1,56 @@
+package net.i2p.android.preferences.util;
+
+import android.content.Context;
+import android.support.v7.preference.EditTextPreference;
+import android.util.AttributeSet;
+
+import net.i2p.android.router.R;
+
+public class PortPreference extends EditTextPreference {
+    public PortPreference(Context context) {
+        super(context);
+    }
+
+    public PortPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public PortPreference(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        int port = getPersistedInt(-1);
+        if (port < 0)
+            return getContext().getResources().getString(R.string.unset);
+        else
+            return String.valueOf(port);
+    }
+
+    @Override
+    protected String getPersistedString(String defaultReturnValue) {
+        int port = getPersistedInt(-1);
+        if (port < 0)
+            return defaultReturnValue;
+        else
+            return String.valueOf(port);
+    }
+
+    @Override
+    protected boolean persistString(String value) {
+        if (value == null || value.isEmpty())
+            return persistInt(-1);
+
+        int port;
+        try {
+            port = Integer.valueOf(value);
+            if (port < 0)
+                port = -1;
+        } catch (NumberFormatException e) {
+            port = -1;
+        }
+
+        return persistInt(port);
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/PortPreferenceDialog.java

@@ -0,0 +1,23 @@
+package net.i2p.android.preferences.util;
+
+import android.os.Bundle;
+import android.support.v7.preference.EditTextPreferenceDialogFragmentCompat;
+import android.text.InputType;
+import android.view.View;
+import android.widget.EditText;
+
+public class PortPreferenceDialog extends EditTextPreferenceDialogFragmentCompat {
+    public static PortPreferenceDialog newInstance(String key) {
+        final PortPreferenceDialog fragment = new PortPreferenceDialog();
+        final Bundle b = new Bundle(1);
+        b.putString(ARG_KEY, key);
+        fragment.setArguments(b);
+        return fragment;
+    }
+
+    @Override
+    protected void onBindDialogView(View view) {
+        super.onBindDialogView(view);
+        ((EditText)view.findViewById(android.R.id.edit)).setInputType(InputType.TYPE_CLASS_NUMBER);
+    }
+}

app/src/main/java/net/i2p/android/preferences/util/SummaryEditTextPreference.java

@@ -0,0 +1,28 @@
+package net.i2p.android.preferences.util;
+
+import android.content.Context;
+import android.support.v7.preference.EditTextPreference;
+import android.util.AttributeSet;
+
+public class SummaryEditTextPreference extends EditTextPreference {
+
+    public SummaryEditTextPreference(Context context) {
+        super(context);
+    }
+
+    public SummaryEditTextPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public SummaryEditTextPreference(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    @Override
+    public CharSequence getSummary() {
+        String summary = (String) super.getSummary();
+        if (summary == null)
+            summary = "%s";
+        return String.format(summary, getText());
+    }
+}

app/src/main/java/net/i2p/android/router/ConsoleContainer.java

@@ -0,0 +1,127 @@
+package net.i2p.android.router;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.preference.PreferenceManager;
+import android.support.v4.app.Fragment;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+
+import net.i2p.android.ext.floatingactionbutton.FloatingActionsMenu;
+import net.i2p.android.router.dialog.AboutDialog;
+import net.i2p.android.router.dialog.TextResourceDialog;
+import net.i2p.android.router.log.LogActivity;
+import net.i2p.android.router.netdb.NetDbActivity;
+import net.i2p.android.router.stats.PeersActivity;
+import net.i2p.android.router.stats.RateGraphActivity;
+import net.i2p.android.router.util.Util;
+
+public class ConsoleContainer extends Fragment {
+    MainFragment mMainFragment = null;
+    FloatingActionsMenu mConsoleMenu;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.container_console, container, false);
+        // Start with the home view
+        if (savedInstanceState == null && getChildFragmentManager().findFragmentById(R.id.main_fragment) == null) {
+            mMainFragment = new MainFragment();
+            mMainFragment.setArguments(getActivity().getIntent().getExtras());
+            getChildFragmentManager().beginTransaction()
+                    .add(R.id.main_fragment, mMainFragment).commit();
+        }
+
+        mConsoleMenu = (FloatingActionsMenu) v.findViewById(R.id.console_action_menu);
+        mConsoleMenu.findViewById(R.id.action_news).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent news = new Intent(getActivity(), NewsActivity.class);
+                startActivity(news);
+            }
+        });
+        mConsoleMenu.findViewById(R.id.action_logs).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent log = new Intent(getActivity(), LogActivity.class);
+                startActivity(log);
+            }
+        });
+        mConsoleMenu.findViewById(R.id.action_graphs).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent graphs = new Intent(getActivity(), RateGraphActivity.class);
+                startActivity(graphs);
+            }
+        });
+//        mConsoleMenu.findViewById(R.id.action_peers).setOnClickListener(new View.OnClickListener() {
+//            @Override
+//            public void onClick(View view) {
+//                Intent peers = new Intent(getActivity(), PeersActivity.class);
+//                startActivity(peers);
+//            }
+//        });
+        mConsoleMenu.findViewById(R.id.action_netdb).setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent netdb = new Intent(getActivity(), NetDbActivity.class);
+                startActivity(netdb);
+            }
+        });
+        setMenuVisibility();
+
+        return v;
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.activity_main_actions, menu);
+    }
+
+    private void setMenuVisibility() {
+        boolean routerRunning = Util.getRouterContext() != null;
+        mConsoleMenu.findViewById(R.id.action_logs).setVisibility(routerRunning ? View.VISIBLE : View.GONE);
+        mConsoleMenu.findViewById(R.id.action_graphs).setVisibility(routerRunning ? View.VISIBLE : View.GONE);
+
+        if (getActivity() != null) {
+            boolean advanced = PreferenceManager.getDefaultSharedPreferences(getActivity())
+                    .getBoolean("i2pandroid.main.showStats", false);
+//            mConsoleMenu.findViewById(R.id.action_peers).setVisibility(
+//                    advanced && routerRunning ? View.VISIBLE : View.GONE);
+            mConsoleMenu.findViewById(R.id.action_netdb).setVisibility(
+                    advanced && routerRunning ? View.VISIBLE : View.GONE);
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.menu_about:
+                AboutDialog dialog = new AboutDialog();
+                dialog.show(getFragmentManager(), "about");
+                return true;
+
+            case R.id.menu_help_release_notes:
+                TextResourceDialog rDdialog = new TextResourceDialog();
+                Bundle args = new Bundle();
+                args.putString(TextResourceDialog.TEXT_DIALOG_TITLE,
+                        getResources().getString(R.string.label_release_notes));
+                args.putInt(TextResourceDialog.TEXT_RESOURCE_ID, R.raw.releasenotes_txt);
+                rDdialog.setArguments(args);
+                rDdialog.show(getFragmentManager(), "release_notes");
+                return true;
+
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/I2PConstants.java

@@ -0,0 +1,5 @@
+package net.i2p.android.router;
+
+public interface I2PConstants {
+    String ANDROID_PREF_PREFIX = "i2pandroid.";
+}

app/src/main/java/net/i2p/android/router/I2PFragmentBase.java

@@ -0,0 +1,94 @@
+package net.i2p.android.router;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+
+import net.i2p.android.router.util.Util;
+import net.i2p.router.CommSystemFacade;
+import net.i2p.router.NetworkDatabaseFacade;
+import net.i2p.router.Router;
+import net.i2p.router.RouterContext;
+import net.i2p.router.TunnelManagerFacade;
+import net.i2p.router.peermanager.ProfileOrganizer;
+import net.i2p.router.transport.FIFOBandwidthLimiter;
+import net.i2p.stat.StatManager;
+
+public class I2PFragmentBase extends Fragment {
+    private boolean mOnActivityCreated;
+
+    public static final String PREF_INSTALLED_VERSION = "app.version";
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        mOnActivityCreated = true;
+        if (getRouterContext() != null)
+            onRouterConnectionReady();
+        else
+            onRouterConnectionNotReady();
+    }
+
+    public void onRouterBind() {
+        if (mOnActivityCreated)
+            onRouterConnectionReady();
+    }
+
+    /** callback from I2PFragmentBase, override as necessary */
+    public void onRouterConnectionReady() {}
+
+    /** callback from I2PFragmentBase, override as necessary */
+    public void onRouterConnectionNotReady() {}
+
+    protected RouterContext getRouterContext() {
+        return Util.getRouterContext();
+    }
+
+    protected Router getRouter() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.router();
+    }
+
+    protected NetworkDatabaseFacade getNetDb() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.netDb();
+    }
+
+    protected ProfileOrganizer getProfileOrganizer() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.profileOrganizer();
+    }
+
+    protected TunnelManagerFacade getTunnelManager() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.tunnelManager();
+    }
+
+    protected CommSystemFacade getCommSystem() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.commSystem();
+    }
+
+    protected FIFOBandwidthLimiter getBandwidthLimiter() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.bandwidthLimiter();
+    }
+
+    protected StatManager getStatManager() {
+        RouterContext ctx = getRouterContext();
+        if (ctx == null)
+            return null;
+        return ctx.statManager();
+    }
+}

app/src/main/java/net/i2p/android/router/LicenseActivity.java

@@ -0,0 +1,24 @@
+package net.i2p.android.router;
+
+import android.os.Bundle;
+import android.support.v7.widget.Toolbar;
+
+import net.i2p.android.I2PActivityBase;
+
+public class LicenseActivity extends I2PActivityBase {
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_onepane);
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+        // Start with the base view
+        if (savedInstanceState == null) {
+            LicenseFragment f = new LicenseFragment();
+            f.setArguments(getIntent().getExtras());
+            getSupportFragmentManager().beginTransaction()
+                    .add(R.id.main_fragment, f).commit();
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/LicenseFragment.java

@@ -0,0 +1,43 @@
+package net.i2p.android.router;
+
+import android.os.Bundle;
+import android.support.v4.app.ListFragment;
+import android.view.View;
+import android.widget.ArrayAdapter;
+import android.widget.ListView;
+
+import net.i2p.android.router.dialog.TextResourceDialog;
+
+public class LicenseFragment extends ListFragment {
+
+    private static final String[] names = {
+        "Android Application License", "Apache 2.0",
+        "Router License Overview", "Blockfile", "Crypto Filters", "ElGamal / DSA",
+        "GPLv2", "LGPLv2.1", "GPLv3", "LGPLv3", "FatCowIcons",
+        "Ministreaming",
+        "InstallCert", "SHA-256", "SNTP", "Addressbook"};
+
+    private static final int[] files = {
+        R.raw.license_app_txt, R.raw.license_apache20_txt,
+        R.raw.licenses_txt, R.raw.license_blockfile_txt, R.raw.license_bsd_txt, R.raw.license_elgamaldsa_txt,
+        R.raw.license_gplv2_txt, R.raw.license_lgplv2_1_txt, R.raw.license_gplv3_txt, R.raw.license_lgplv3_txt,
+        R.raw.license_fatcowicons_txt, R.raw.license_bsd_txt,
+        R.raw.license_installcert_txt, R.raw.license_sha256_txt, R.raw.license_sntp_txt, R.raw.license_addressbook_txt};
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        setListAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, names));
+    }
+
+    @Override
+    public void onListItemClick(ListView parent, View view, int pos, long id) {
+        TextResourceDialog dialog = new TextResourceDialog();
+        Bundle args = new Bundle();
+        args.putString(TextResourceDialog.TEXT_DIALOG_TITLE, names[pos]);
+        args.putInt(TextResourceDialog.TEXT_RESOURCE_ID, files[pos]);
+        dialog.setArguments(args);
+        dialog.show(getActivity().getSupportFragmentManager(), "license");
+    }
+}

app/src/main/java/net/i2p/android/router/MainFragment.java

@@ -0,0 +1,659 @@
+package net.i2p.android.router;
+
+import android.app.Activity;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.graphics.Typeface;
+import android.os.Bundle;
+import android.os.Handler;
+import android.preference.PreferenceManager;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v7.app.AlertDialog;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.ScrollView;
+import android.widget.TableLayout;
+import android.widget.TableRow;
+import android.widget.TextView;
+import android.widget.ToggleButton;
+
+import net.i2p.android.I2PActivityBase;
+import net.i2p.android.help.BrowserConfigActivity;
+import net.i2p.android.router.dialog.FirstStartDialog;
+import net.i2p.android.router.service.RouterService;
+import net.i2p.android.router.service.State;
+import net.i2p.android.router.util.Connectivity;
+import net.i2p.android.router.util.LongToggleButton;
+import net.i2p.android.router.util.Util;
+import net.i2p.data.DataHelper;
+import net.i2p.data.Destination;
+import net.i2p.data.Hash;
+import net.i2p.data.LeaseSet;
+import net.i2p.router.RouterContext;
+import net.i2p.router.TunnelPoolSettings;
+
+import java.text.Collator;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+public class MainFragment extends I2PFragmentBase {
+
+    private Handler _handler;
+    private Runnable _updater;
+    private Runnable _oneShotUpdate;
+    private String _savedStatus;
+
+    private ImageView mConsoleLights;
+    private LongToggleButton mOnOffButton;
+    private LinearLayout vGracefulButtons;
+    private ScrollView mScrollView;
+    private View vStatusContainer;
+    private ImageView vNetStatusLevel;
+    private TextView vNetStatusText;
+    private View vNonNetStatus;
+    private TextView vUptime;
+    private TextView vActive;
+    private TextView vKnown;
+    private TableLayout vTunnels;
+    private LinearLayout vAdvStatus;
+    private TextView vAdvStatusText;
+
+    private static final String PREF_CONFIGURE_BROWSER = "app.dialog.configureBrowser";
+    private static final String PREF_FIRST_START = "app.router.firstStart";
+    private static final String PREF_SHOW_STATS = "i2pandroid.main.showStats";
+    protected static final String PROP_NEW_INSTALL = "i2p.newInstall";
+    protected static final String PROP_NEW_VERSION = "i2p.newVersion";
+    RouterControlListener mCallback;
+
+    // Container Activity must implement this interface
+    public interface RouterControlListener {
+        boolean shouldShowOnOff();
+
+        boolean shouldBeOn();
+
+        void onStartRouterClicked();
+
+        boolean onStopRouterClicked();
+
+        /**
+         * @since 0.9.19
+         */
+        boolean isGracefulShutdownInProgress();
+
+        /**
+         * @since 0.9.19
+         */
+        boolean onGracefulShutdownClicked();
+
+        /**
+         * @since 0.9.19
+         */
+        boolean onCancelGracefulShutdownClicked();
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+
+        // This makes sure that the container activity has implemented
+        // the callback interface. If not, it throws an exception
+        try {
+            mCallback = (RouterControlListener) activity;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement RouterControlListener");
+        }
+
+    }
+
+    /**
+     * Called when the fragment is first created.
+     */
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        // Init stuff here so settings work.
+        if (savedInstanceState != null) {
+            lastRouterState = savedInstanceState.getParcelable("lastState");
+            String saved = savedInstanceState.getString("status");
+            if (saved != null) {
+                _savedStatus = saved;
+            }
+        }
+
+        _handler = new Handler();
+        _updater = new Updater();
+        _oneShotUpdate = new OneShotUpdate();
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.fragment_main, container, false);
+
+        mConsoleLights = (ImageView) v.findViewById(R.id.console_lights);
+        mOnOffButton = (LongToggleButton) v.findViewById(R.id.router_onoff_button);
+        vGracefulButtons = (LinearLayout) v.findViewById(R.id.router_graceful_buttons);
+        mScrollView = (ScrollView) v.findViewById(R.id.main_scrollview);
+        vStatusContainer = v.findViewById(R.id.status_container);
+        vNetStatusLevel = (ImageView) v.findViewById(R.id.console_net_status_level);
+        vNetStatusText = (TextView) v.findViewById(R.id.console_net_status_text);
+        vNonNetStatus = v.findViewById(R.id.console_non_net_status_container);
+        vUptime = (TextView) v.findViewById(R.id.console_uptime);
+        vActive = (TextView) v.findViewById(R.id.console_active);
+        vKnown = (TextView) v.findViewById(R.id.console_known);
+        vTunnels = (TableLayout) v.findViewById(R.id.main_tunnels);
+        vAdvStatus = (LinearLayout) v.findViewById(R.id.console_advanced_status);
+        vAdvStatusText = (TextView) v.findViewById(R.id.console_advanced_status_text);
+
+        updateState(lastRouterState);
+
+        mOnOffButton.setOnLongClickListener(new View.OnLongClickListener() {
+
+            public boolean onLongClick(View view) {
+                boolean on = ((ToggleButton) view).isChecked();
+                if (on) {
+                    mCallback.onStartRouterClicked();
+                    updateOneShot();
+                    checkFirstStart();
+                } else if (mCallback.onGracefulShutdownClicked())
+                    updateOneShot();
+                return true;
+            }
+        });
+
+        Button gb = (Button) v.findViewById(R.id.button_shutdown_now);
+        gb.setOnLongClickListener(new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View view) {
+                if (mCallback.isGracefulShutdownInProgress())
+                    if (mCallback.onStopRouterClicked())
+                        updateOneShot();
+                return true;
+            }
+        });
+        gb = (Button) v.findViewById(R.id.button_cancel_graceful);
+        gb.setOnLongClickListener(new View.OnLongClickListener() {
+            @Override
+            public boolean onLongClick(View view) {
+                if (mCallback.isGracefulShutdownInProgress())
+                    if (mCallback.onCancelGracefulShutdownClicked())
+                        updateOneShot();
+                return true;
+            }
+        });
+
+        return v;
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        _handler.removeCallbacks(_updater);
+        _handler.removeCallbacks(_oneShotUpdate);
+        if (_savedStatus != null) {
+            TextView tv = (TextView) getActivity().findViewById(R.id.console_advanced_status_text);
+            tv.setText(_savedStatus);
+        }
+        checkDialog();
+        _handler.postDelayed(_updater, 100);
+
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(getActivity());
+
+        IntentFilter filter = new IntentFilter();
+        filter.addAction(RouterService.LOCAL_BROADCAST_STATE_NOTIFICATION);
+        filter.addAction(RouterService.LOCAL_BROADCAST_STATE_CHANGED);
+        lbm.registerReceiver(onStateChange, filter);
+
+        lbm.sendBroadcast(new Intent(RouterService.LOCAL_BROADCAST_REQUEST_STATE));
+    }
+
+    private State lastRouterState;
+    private BroadcastReceiver onStateChange = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            State state = intent.getParcelableExtra(RouterService.LOCAL_BROADCAST_EXTRA_STATE);
+            if (lastRouterState == null || lastRouterState != state) {
+                updateState(state);
+                // If we have stopped, clear the status info immediately
+                if (Util.isStopped(state)) {
+                    updateOneShot();
+                }
+                lastRouterState = state;
+            }
+        }
+    };
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        _handler.removeCallbacks(_updater);
+        _handler.removeCallbacks(_oneShotUpdate);
+
+        LocalBroadcastManager.getInstance(getActivity()).unregisterReceiver(onStateChange);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        updateOneShot();
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        if (lastRouterState != null)
+            outState.putParcelable("lastState", lastRouterState);
+        if (_savedStatus != null)
+            outState.putString("status", _savedStatus);
+        super.onSaveInstanceState(outState);
+    }
+
+    private void updateOneShot() {
+        _handler.postDelayed(_oneShotUpdate, 10);
+    }
+
+    private class OneShotUpdate implements Runnable {
+
+        public void run() {
+            updateVisibility();
+            try {
+                updateStatus();
+            } catch (NullPointerException npe) {
+                // RouterContext wasn't quite ready
+                Util.w("Status was updated before RouterContext was ready", npe);
+            }
+        }
+    }
+
+    private class Updater implements Runnable {
+
+        private int counter;
+        private final int delay = 1000;
+        private final int toloop = delay / 500;
+
+        public void run() {
+            updateVisibility();
+            if (counter++ % toloop == 0) {
+                try {
+                    updateStatus();
+                } catch (NullPointerException npe) {
+                    // RouterContext wasn't quite ready
+                    Util.w("Status was updated before RouterContext was ready", npe);
+                }
+            }
+            //_handler.postDelayed(this, 2500);
+            _handler.postDelayed(this, delay);
+        }
+    }
+
+    private void updateVisibility() {
+        boolean showOnOff = mCallback.shouldShowOnOff();
+        mOnOffButton.setVisibility(showOnOff ? View.VISIBLE : View.GONE);
+
+        boolean isOn = mCallback.shouldBeOn();
+        mOnOffButton.setChecked(isOn);
+
+        boolean isGraceful = mCallback.isGracefulShutdownInProgress();
+        vGracefulButtons.setVisibility(isGraceful ? View.VISIBLE : View.GONE);
+        if (isOn && isGraceful) {
+            RouterContext ctx = getRouterContext();
+            if (ctx != null) {
+                TextView tv = (TextView) vGracefulButtons.findViewById(R.id.router_graceful_status);
+                long ms = ctx.router().getShutdownTimeRemaining();
+                if (ms > 1000) {
+                    tv.setText(getActivity().getResources().getString(R.string.button_router_graceful,
+                            DataHelper.formatDuration(ms)));
+                } else {
+                    tv.setText(getActivity().getString(R.string.notification_status_stopping));
+                }
+            }
+        }
+    }
+
+    public void updateState(State newState) {
+        if (newState == State.INIT ||
+                newState == State.STOPPED ||
+                newState == State.MANUAL_STOPPED ||
+                newState == State.MANUAL_QUITTED ||
+                newState == State.NETWORK_STOPPED) {
+            mConsoleLights.setImageResource(R.drawable.routerlogo_0);
+        } else if (newState == State.STARTING ||
+                //newState == State.GRACEFUL_SHUTDOWN || // Don't change lights for graceful
+                newState == State.STOPPING ||
+                newState == State.MANUAL_STOPPING ||
+                newState == State.MANUAL_QUITTING ||
+                newState == State.NETWORK_STOPPING) {
+            mConsoleLights.setImageResource(R.drawable.routerlogo_1);
+        } else if (newState == State.RUNNING) {
+            mConsoleLights.setImageResource(R.drawable.routerlogo_2);
+        } else if (newState == State.ACTIVE) {
+            mConsoleLights.setImageResource(R.drawable.routerlogo_3);
+        } else if (newState == State.WAITING) {
+            mConsoleLights.setImageResource(R.drawable.routerlogo_4);
+        } // Ignore unknown states.
+    }
+
+    private void updateStatus() {
+        RouterContext ctx = getRouterContext();
+
+        if (!Connectivity.isConnected(getActivity())) {
+            // Manually set state, RouterService won't be running
+            updateState(State.WAITING);
+            vNetStatusText.setText(R.string.no_internet);
+            vStatusContainer.setVisibility(View.VISIBLE);
+            vNonNetStatus.setVisibility(View.GONE);
+        } else if (lastRouterState != null &&
+                !Util.isStopping(lastRouterState) &&
+                !Util.isStopped(lastRouterState) &&
+                ctx != null) {
+            Util.NetStatus netStatus = Util.getNetStatus(getActivity(), ctx);
+            switch (netStatus.level) {
+                case ERROR:
+                    vNetStatusLevel.setImageDrawable(getResources().getDrawable(R.drawable.ic_error_red_24dp));
+                    vNetStatusLevel.setVisibility(View.VISIBLE);
+                    break;
+                case WARN:
+                    vNetStatusLevel.setImageDrawable(getResources().getDrawable(R.drawable.ic_warning_amber_24dp));
+                    vNetStatusLevel.setVisibility(View.VISIBLE);
+                    break;
+                case INFO:
+                default:
+                    vNetStatusLevel.setVisibility(View.GONE);
+            }
+            vNetStatusText.setText(getString(R.string.settings_label_network) + ": " + netStatus.status);
+
+            String uptime = DataHelper.formatDuration(ctx.router().getUptime());
+            int active = ctx.commSystem().countActivePeers();
+            int known = Math.max(ctx.netDb().getKnownRouters() - 1, 0);
+            vUptime.setText("" + uptime);
+            vActive.setText("" + active);
+            vKnown.setText("" + known);
+
+            // Load running tunnels
+            loadDestinations(ctx);
+
+            if (PreferenceManager.getDefaultSharedPreferences(getActivity()).getBoolean(PREF_SHOW_STATS, false)) {
+                int inEx = ctx.tunnelManager().getFreeTunnelCount();
+                int outEx = ctx.tunnelManager().getOutboundTunnelCount();
+                int inCl = ctx.tunnelManager().getInboundClientTunnelCount();
+                int outCl = ctx.tunnelManager().getOutboundClientTunnelCount();
+                int part = ctx.tunnelManager().getParticipatingCount();
+                double dLag = ctx.statManager().getRate("jobQueue.jobLag").getRate(60000).getAverageValue();
+                String jobLag = DataHelper.formatDuration((long) dLag);
+                String msgDelay = DataHelper.formatDuration(ctx.throttle().getMessageDelay());
+
+                String tunnelStatus = ctx.throttle().getTunnelStatus();
+                //ctx.commSystem().getReachabilityStatus();
+
+                String status =
+                        "Exploratory Tunnels in/out: " + inEx + " / " + outEx
+                                + "\nClient Tunnels in/out: " + inCl + " / " + outCl;
+
+
+                // Need to see if we have the participation option set to on.
+                // I thought there was a router method for that? I guess not! WHY NOT?
+                // It would be easier if we had a number to test status.
+                String participate = "\nParticipation: " + tunnelStatus + " (" + part + ")";
+
+                String details =
+                        "\nMemory: " + DataHelper.formatSize(Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory())
+                                + "B / " + DataHelper.formatSize(Runtime.getRuntime().maxMemory()) + 'B'
+                                + "\nJob Lag: " + jobLag
+                                + "\nMsg Delay: " + msgDelay;
+
+                _savedStatus = status + participate + details;
+                vAdvStatusText.setText(_savedStatus);
+                vAdvStatus.setVisibility(View.VISIBLE);
+            } else {
+                vAdvStatus.setVisibility(View.GONE);
+            }
+            vStatusContainer.setVisibility(View.VISIBLE);
+            vNonNetStatus.setVisibility(View.VISIBLE);
+
+            // Usage stats in bottom toolbar
+
+            double inBw = ctx.bandwidthLimiter().getReceiveBps();
+            double outBw = ctx.bandwidthLimiter().getSendBps();
+            double inData = ctx.bandwidthLimiter().getTotalAllocatedInboundBytes();
+            double outData = ctx.bandwidthLimiter().getTotalAllocatedOutboundBytes();
+
+            ((TextView) getActivity().findViewById(R.id.console_download_stats)).setText(
+                    Util.formatSpeed(inBw) + "Bps / " + Util.formatSize(inData) + "B");
+            ((TextView) getActivity().findViewById(R.id.console_upload_stats)).setText(
+                    Util.formatSpeed(outBw) + "Bps / " + Util.formatSize(outData) + "B");
+
+            getActivity().findViewById(R.id.console_usage_stats).setVisibility(View.VISIBLE);
+        } else {
+            // network but no router context
+            vStatusContainer.setVisibility(View.GONE);
+            getActivity().findViewById(R.id.console_usage_stats).setVisibility(View.INVISIBLE);
+            /**
+             * **
+             * RouterService svc = _routerService; String status = "connected? "
+             * + Util.isConnected(this) + "\nMemory: " +
+             * DataHelper.formatSize(Runtime.getRuntime().totalMemory() -
+             * Runtime.getRuntime().freeMemory()) + "B / " +
+             * DataHelper.formatSize(Runtime.getRuntime().maxMemory()) + 'B' +
+             * "\nhave ctx? " + (ctx != null) + "\nhave svc? " + (svc != null) +
+             * "\nis bound? " + _isBound + "\nsvc state: " + (svc == null ?
+             * "null" : svc.getState()) + "\ncan start? " + (svc == null ?
+             * "null" : svc.canManualStart()) + "\ncan stop? " + (svc == null ?
+             * "null" : svc.canManualStop()); tv.setText(status);
+             * tv.setVisibility(View.VISIBLE);
+             ***
+             */
+        }
+    }
+
+    /**
+     * Based on net.i2p.router.web.SummaryHelper.getDestinations()
+     *
+     * @param ctx The RouterContext
+     */
+    private void loadDestinations(RouterContext ctx) {
+        vTunnels.removeAllViews();
+
+        List<Destination> clients = null;
+        if (ctx.clientManager() != null)
+            clients = new ArrayList<Destination>(ctx.clientManager().listClients());
+
+        if (clients != null && !clients.isEmpty()) {
+            Collections.sort(clients, new AlphaComparator(ctx));
+            for (Destination client : clients) {
+                String name = getName(ctx, client);
+                Hash h = client.calculateHash();
+                TableRow dest = new TableRow(getActivity());
+                dest.setPadding(16, 4, 0, 4);
+
+                // Client or server
+                TextView type = new TextView(getActivity());
+                type.setTextColor(getResources().getColor(android.R.color.primary_text_light));
+                type.setTypeface(Typeface.DEFAULT_BOLD);
+                type.setGravity(Gravity.CENTER);
+                if (ctx.clientManager().shouldPublishLeaseSet(h))
+                    type.setText(R.string.char_server_tunnel);
+                else
+                    type.setText(R.string.char_client_tunnel);
+                dest.addView(type);
+
+                // Name
+                TextView destName = new TextView(getActivity());
+                destName.setPadding(16, 0, 0, 0);
+                destName.setGravity(Gravity.CENTER_VERTICAL);
+                destName.setText(name);
+                dest.addView(destName);
+
+                // Status
+                LeaseSet ls = ctx.netDb().lookupLeaseSetLocally(h);
+                if (ls != null && ctx.tunnelManager().getOutboundClientTunnelCount(h) > 0) {
+                    long timeToExpire = ls.getEarliestLeaseDate() - ctx.clock().now();
+                    if (timeToExpire < 0) {
+                        // red or yellow light
+                        type.setBackgroundResource(R.drawable.tunnel_yellow);
+                    } else {
+                        // green light
+                        type.setBackgroundResource(R.drawable.tunnel_green);
+                    }
+                } else {
+                    // yellow light
+                    type.setBackgroundResource(R.drawable.tunnel_yellow);
+                }
+
+                vTunnels.addView(dest);
+            }
+        } else {
+            TableRow empty = new TableRow(getActivity());
+            TextView emptyText = new TextView(getActivity());
+            emptyText.setText(R.string.no_tunnels_running);
+            empty.addView(emptyText);
+            vTunnels.addView(empty);
+        }
+    }
+
+    private static final String SHARED_CLIENTS = "shared clients";
+
+    /**
+     * compare translated nicknames - put "shared clients" first in the sort
+     */
+    private class AlphaComparator implements Comparator<Destination> {
+        private String xsc;
+        private RouterContext _ctx;
+
+        public AlphaComparator(RouterContext ctx) {
+            _ctx = ctx;
+            xsc = _t(ctx, SHARED_CLIENTS);
+        }
+
+        public int compare(Destination lhs, Destination rhs) {
+            String lname = getName(_ctx, lhs);
+            String rname = getName(_ctx, rhs);
+            if (lname.equals(xsc))
+                return -1;
+            if (rname.equals(xsc))
+                return 1;
+            return Collator.getInstance().compare(lname, rname);
+        }
+    }
+
+    /**
+     * translate here so collation works above
+     */
+    private String getName(RouterContext ctx, Destination d) {
+        TunnelPoolSettings in = ctx.tunnelManager().getInboundSettings(d.calculateHash());
+        String name = (in != null ? in.getDestinationNickname() : null);
+        if (name == null) {
+            TunnelPoolSettings out = ctx.tunnelManager().getOutboundSettings(d.calculateHash());
+            name = (out != null ? out.getDestinationNickname() : null);
+        }
+
+        if (name == null)
+            name = d.calculateHash().toBase64().substring(0, 6);
+        else
+            name = _t(ctx, name);
+
+        return name;
+    }
+
+    private String _t(RouterContext ctx, String s) {
+        if (SHARED_CLIENTS.equals(s))
+            return getString(R.string.shared_clients);
+        else
+            return s;
+    }
+
+    private void checkDialog() {
+        final I2PActivityBase ab = (I2PActivityBase) getActivity();
+        String language = PreferenceManager.getDefaultSharedPreferences(ab).getString(
+                getString(R.string.PREF_LANGUAGE), null
+        );
+        if (language == null) {
+            AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
+            b.setTitle(R.string.choose_language)
+                    .setItems(R.array.language_names, new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int which) {
+                            // Save the language choice
+                            String language = getResources().getStringArray(R.array.languages)[which];
+                            PreferenceManager.getDefaultSharedPreferences(getActivity())
+                                    .edit()
+                                    .putString(getString(R.string.PREF_LANGUAGE), language)
+                                    .commit();
+                            // Close the dialog
+                            dialog.dismiss();
+                            // Broadcast the change to RouterService just in case the router is running
+                            Intent intent = new Intent(RouterService.LOCAL_BROADCAST_LOCALE_CHANGED);
+                            LocalBroadcastManager.getInstance(getActivity()).sendBroadcast(intent);
+                            // Update the parent
+                            ab.notifyLocaleChanged();
+                            // Run checkDialog() again to show the next dialog
+                            // (if the change doesn't restart the Activity)
+                            checkDialog();
+                        }
+                    })
+                    .setCancelable(false)
+                    .show();
+        } else if (ab.getPref(PREF_CONFIGURE_BROWSER, true)) {
+            AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
+            b.setTitle(R.string.configure_browser_title)
+                    .setMessage(R.string.configure_browser_for_i2p)
+                    .setCancelable(false)
+                    .setPositiveButton(R.string.yes, new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int i) {
+                            dialog.dismiss();
+                            ab.setPref(PREF_CONFIGURE_BROWSER, false);
+                            Intent hi = new Intent(getActivity(), BrowserConfigActivity.class);
+                            startActivity(hi);
+                        }
+                    })
+                    .setNegativeButton(R.string.no, new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int i) {
+                            dialog.cancel();
+                            ab.setPref(PREF_CONFIGURE_BROWSER, false);
+                        }
+                    })
+                    .show();
+        }
+        /*VersionDialog dialog = new VersionDialog();
+        String oldVersion = ((I2PActivityBase) getActivity()).getPref(PREF_INSTALLED_VERSION, "??");
+        if(oldVersion.equals("??")) {
+            // TODO Don't show this dialog until it is reworked
+            Bundle args = new Bundle();
+            args.putInt(VersionDialog.DIALOG_TYPE, VersionDialog.DIALOG_NEW_INSTALL);
+            dialog.setArguments(args);
+            dialog.show(getActivity().getSupportFragmentManager(), "newinstall");
+        } else {
+            // TODO Don't show dialog on new version until we have something new to tell them
+            String currentVersion = Util.getOurVersion(getActivity());
+            if(!oldVersion.equals(currentVersion)) {
+                Bundle args = new Bundle();
+                args.putInt(VersionDialog.DIALOG_TYPE, VersionDialog.DIALOG_NEW_VERSION);
+                dialog.setArguments(args);
+                dialog.show(getActivity().getSupportFragmentManager(), "newversion");
+            }
+        }*/
+    }
+
+    private void checkFirstStart() {
+        I2PActivityBase ab = (I2PActivityBase) getActivity();
+        boolean firstStart = ab.getPref(PREF_FIRST_START, true);
+        // Check ab.isFinishing() because DialogFragment.show() will throw IllegalStateException if
+        // called after ab.onSaveInstanceState().
+        if (firstStart && !ab.isFinishing()) {
+            FirstStartDialog dialog = new FirstStartDialog();
+            dialog.show(ab.getSupportFragmentManager(), "firststart");
+            ab.setPref(PREF_FIRST_START, false);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/NewsActivity.java

@@ -0,0 +1,26 @@
+package net.i2p.android.router;
+
+import android.os.Bundle;
+import android.support.v7.widget.Toolbar;
+
+import net.i2p.android.I2PActivityBase;
+
+public class NewsActivity extends I2PActivityBase {
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_onepane);
+
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        // Start with the base view
+        if (savedInstanceState == null) {
+            NewsFragment f = new NewsFragment();
+            f.setArguments(getIntent().getExtras());
+            getSupportFragmentManager().beginTransaction()
+                    .add(R.id.main_fragment, f).commit();
+        }
+    }
+}