0.9.20

i2p.i2p revision: 747e9d409223a108623b0b38d084097335d6c195

.classpath

@@ -1,14 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<classpath>
-	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
-	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
-	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.LIBRARIES"/>
-	<classpathentry exported="true" kind="con" path="com.android.ide.eclipse.adt.DEPENDENCIES"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/i2p_sdk"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/i2p_router"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/i2ptunnel"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/BOB"/>
-	<classpathentry combineaccessrules="false" kind="src" path="/addressbook"/>
-	<classpathentry kind="output" path="bin/classes"/>
-</classpath>

.mtn-ignore

@@ -24,9 +24,29 @@ _jsp\.java$
 /classes/
 
 # Android-specific ignores
-^bin
+^routerjars/libs
-^gen
-^routerjars/bin
-^routerjars/gen
-AndroidManifest.xml
 local.properties
+signing.properties
+
+#IntelliJ IDEA
+^.idea
+.*.iml
+.*.ipr
+.*.iws
+
+#Gradle
+^.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

.project

@@ -1,33 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>I2P_Android</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ResourceManagerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.PreCompilerBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.jdt.core.javabuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>com.android.ide.eclipse.adt.ApkBuilder</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>com.android.ide.eclipse.adt.AndroidNature</nature>
-		<nature>org.eclipse.jdt.core.javanature</nature>
-	</natures>
-</projectDescription>

.tx/config

@@ -1,10 +1,17 @@
 [main]
 host = https://www.transifex.com
-lang_map = pt_BR: pt-rBR, ru_RU: ru, sv_SE: sv, tr_TR: tr, zh_CN: zh
+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
 
 [I2P.android]
-file_filter = res/values-<lang>/strings.xml
+file_filter = app/src/main/res/values-<lang>/strings.xml
-source_file = res/values/strings.xml
+source_file = app/src/main/res/values/strings.xml
+source_lang = en
+type = ANDROID
+minimum_perc = 50
+
+[I2P.android_lib_client]
+file_filter = client/src/main/res/values-<lang>/strings.xml
+source_file = client/src/main/res/values/strings.xml
 source_lang = en
 type = ANDROID
 minimum_perc = 50

AndroidManifest.xml.in

@@ -1,72 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-      package="net.i2p.android.router"
-      android.versionCode="0"
-      android.versionName="0.0.0-0_b0-API8"
-      android:installLocation="auto"
-      >
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
-
-    <uses-sdk android:minSdkVersion="8"
-              android:targetSdkVersion="19" />
-
-    <application android:label="@string/app_name"
-               android:theme="@style/Theme.AppCompat"
-               android:icon="@drawable/ic_launcher_itoopie" >
-        <service android:name=".service.RouterService"
-                  android:label="@string/app_name"
-                  android:icon="@drawable/ic_launcher_itoopie" />
-        <provider android:name=".provider.CacheProvider"
-                  android:authorities="net.i2p.android.router" />
-        <activity android:name=".activity.MainActivity"
-                  android:label="@string/app_name"
-                  android:icon="@drawable/ic_launcher_itoopie"
-                  android:launchMode="singleTop" >
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-            </intent-filter>
-        </activity>
-        <activity android:name=".activity.NewsActivity"
-                  android:label="I2P News"
-                  android:configChanges="orientation|keyboardHidden" >
-        </activity>
-        <activity android:name=".activity.TextResourceActivity"
-                  android:label="I2P Information" >
-        </activity>
-        <activity android:name=".activity.LicenseActivity"
-                  android:label="I2P License Information" >
-        </activity>
-        <activity android:name=".activity.WebActivity"
-                  android:label="I2P Web Browser"
-                  android:configChanges="orientation|keyboardHidden" >
-            <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=".activity.SettingsActivity"
-                  android:label="I2P Settings"
-                  android:launchMode="singleTop" >
-        </activity>
-        <activity android:name=".activity.AddressbookSettingsActivity"
-                  android:label="I2P Addressbook Settings"
-                  android:launchMode="singleTop" >
-        </activity>
-        <activity android:name=".activity.AddressbookActivity"
-                  android:label="Addressbook"
-                  android:launchMode="singleTop" >
-        </activity>
-        <activity android:name=".activity.LogActivity"
-                  android:label="I2P Logs" >
-        </activity>
-        <activity android:name=".activity.PeersActivity"
-                  android:label="I2P Peers and Transport Status"
-                  android:configChanges="orientation|keyboardHidden"
-                  android:launchMode="singleTop" >
-        </activity>
-    </application>
-</manifest>

CHANGELOG

@@ -0,0 +1,47 @@
+0.9.20
+ * 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

README.md

@@ -0,0 +1,151 @@
+# 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/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
+    ossrhUsername=
+    ossrhPassword=
+    ```
+
+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,116 +0,0 @@
-These instructions are for a recent Android SDK (Rev 20 or better) on Linux.
-Windows building is not currently supported.
-
-These instructions were last updated for SDK Tools Version 20 with
-SDK Platform-tools Version 12 from updates.
-
-The i2p source must be installed in ../i2p.i2p,
-or else add i2psrc=/path/to/source in the local.properties file.
-
-=====================
-
-Dependencies:
-
-- Java SDK (preferably Oracle/Sun or OpenJDK) 1.6.0 or higher
-- Apache Ant 1.8.0 or higher
-- I2P source in ../i2p.i2p
-- Android SDK (tested with Rev 22.3 and platform-tools version 19)
-
-=====================
-
-Instructions:
-
-# Download the SDK from http://developer.android.com/sdk/index.html
-# Unzip the android SDK in ../
-# So then the android tools will be in ../android-sdk-linux/tools/
-#
-# Run the GUI updater, which you must do to get an SDK Platform:
-../android-sdk-linux/tools/android &
-
-# now go to the available packages tab, check the box and click refresh,
-# and download an SDK Platform
-# Since I2P is targeted at 4.4 (API 19)
-# download at least that one. Otherwise you must change the
-# target in project.properties from android-19 to andriod-x
-# where x is the API version.
-
-# I2P is configured to run on 2.2 (API 8) or higher using the
-# Android Support Library, so download that as well
-# (it's under "Extras"). 
-
-# update the compatibility project
-../android-sdk-linux/tools/android update lib-project -p ../android-sdk-linux/extras/android/support/v7/appcompat -t android-19
-
-# To run the debugger (ddms) you also need to download the
-# "Android SDK Platform-Tools" package from the GUI updater.
-
-# create a file local.properties with the following line (without the leading # of course),
-# do NOT use a relative path
-# sdk.dir=/path/to/your/android-sdk-linux
-# Copy this file to the routerjars/ directory, it is needed in both places.
-
-# If your SDK is not in ../android-sdk-linux/ then you must
-# override the location of the Android Support Library. Add
-# the following line to local.properties
-# do NOT use an absolute path
-# android.library.reference.2=path/to/your/android-sdk-linux/extras/android/support/v7/appcompat
-# Don't add it to the local.properties in the routerjars/ directory.
-
-# DO NOT create a new project or anything. It's all set up right here for you.
-
-# 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 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
-
-# then wait a couple minutes until the emulator or device is up
-# compile and install for a release
-ant release
-ant installr
-
-# or compile and install for a debug version
-ant debug
-ant installd
-
-# then run the debugger
-../android-sdk-linux/tools/ddms &
-
-# to rebuild and reinstall to emulator or device:
-ant clean
-# then do which ever from the above compile and install choices.
-
-
-# to uninstall
-ant uninstall
-# or use your device's menu.
-
-# Other ant tagets are available, just type
-ant
-
-# 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

TODO

@@ -0,0 +1,105 @@
+# 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?
+
+# Short-term
+
+- 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
+- I2PTunnel
+  - Improve tunnel list status indicators
+  - Show all messages somewhere
+  - Icons/header images for tunnel types on details page
+- Progress feedback for addressbook subscriptions reload
+- Display release notes directly on new router version
+- Fill out help pages
+- Rewrite release notes to be release-specific
+- Fix release notes UI, either make back button use clear or add buttons
+- 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
+- Include GeoIP db for country info
+- Maybe change router-off mechanic for various pages? Enable as they become available?
+
+# Medium-term
+
+- 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
+- Improve graphs
+  - Show fixed x range, not only available data
+  - Think about pan/zoom
+  - How to persist data across restarts?
+
+# 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
+
+- 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

ant.properties

@@ -1,4 +0,0 @@
-application-package=net.i2p.router
-key.store=${user.home}/.android/${application-package}.keystore
-key.alias=${application-package}
-key.store.password=android

app/build.gradle

@@ -0,0 +1,238 @@
+apply plugin: 'com.android.application'
+apply plugin: 'witness'
+
+android {
+    compileSdkVersion Integer.parseInt(project.ANDROID_BUILD_SDK_VERSION as String)
+    buildToolsVersion project.ANDROID_BUILD_TOOLS_VERSION as String
+    defaultConfig {
+        versionCode 4745230
+        versionName '0.9.20'
+        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 false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+        debug {
+            applicationIdSuffix '.debug'
+            versionNameSuffix '-DEBUG'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_7
+        targetCompatibility JavaVersion.VERSION_1_7
+    }
+    lintOptions {
+        abortOnError false
+    }
+    packagingOptions {
+        exclude 'LICENSE.txt'
+    }
+    productFlavors {
+        free {
+            applicationId 'net.i2p.android'
+        }
+        donate {
+            applicationId 'net.i2p.android.donate'
+        }
+        legacy {
+            applicationId 'net.i2p.android.router'
+        }
+    }
+}
+
+dependencies {
+    // Local dependencies
+    compile project(':routerjars')
+    compile project(':client')
+
+    // Android Support Repository dependencies
+    compile 'com.android.support:support-v4:22.2.0'
+    compile 'com.android.support:appcompat-v7:22.2.0'
+    compile 'com.android.support:recyclerview-v7:22.2.0'
+
+    // Remote dependencies
+    compile 'net.i2p.android.ext:floatingactionbutton:1.9.0'
+    compile files('libs/androidplot-core-0.6.1.jar')
+    compile ('com.android.support:support-v4-preferencefragment:1.0.0@aar'){
+        exclude module: 'support-v4'
+    }
+    compile 'com.pnikosis:materialish-progress:1.5'
+    compile 'com.eowise:recyclerview-stickyheaders:0.5.2@aar'
+    compile ('com.mcxiaoke.viewpagerindicator:library:2.4.1') {
+        exclude group: 'com.android.support', module: 'support-v4'
+    }
+
+    // Testing-only dependencies
+    androidTestCompile 'com.android.support.test.espresso:espresso-core:2.0'
+    androidTestCompile 'com.android.support.test:testing-support-lib:0.1'
+}
+
+dependencyVerification {
+    verify = [
+            'com.android.support:support-v4:7bb6e40a18774aa2595e4d8f9fe0ae14e61670f71a1279272fb0b79b8be71180',
+            'com.android.support:appcompat-v7:2d5867698410b41f75140c91d6c1e58da74ae0f97baf6e0bdd1f7cc1017ceb2c',
+            'com.android.support:recyclerview-v7:3a8da14585fa1c81f06e7cef4d93a7641f0323d8f984ff9a7bd7a6e416b46888',
+            'net.i2p.android.ext:floatingactionbutton:b41eae5fe6be599e3fade00273521b0914f2e199d5f04c50fa34cfe935347f76',
+            'com.android.support:support-v4-preferencefragment:5470f5872514a6226fa1fc6f4e000991f38805691c534cf0bd2778911fc773ad',
+            'com.pnikosis:materialish-progress:d71d80e00717a096784482aee21001a9d299fec3833e4ebd87739ed36cf77c54',
+            'com.eowise:recyclerview-stickyheaders:7b236da49b33b840e9ba6e7e4182218d1a2d9047236fdbc3ca947352f9b0883b',
+            'com.mcxiaoke.viewpagerindicator:library:1e8aad664137f68abdfee94889f6da3dc98be652a235176a403965a07a25de62',
+    ]
+}
+
+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/src/androidTest/java/net/i2p/android/I2PActivityTest.java

@@ -0,0 +1,108 @@
+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.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), 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), hasSibling(withId(R.id.main_toolbar)))).perform(swipeLeft());
+        // TODO: test tunnels ViewPager
+        onView(allOf(withId(R.id.pager), 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,205 @@
+<?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-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/com/hlidskialf/android/preference/SeekBarPreference.java

@@ -49,8 +49,14 @@ public class SeekBarPreference extends DialogPreference implements SeekBar.OnSee
     public SeekBarPreference(Context context, AttributeSet attrs) {
         super(context, attrs);
         mContext = context;
-        mDialogMessage = attrs.getAttributeValue(androidns, "dialogMessage");
+        int dialogMessageR = attrs.getAttributeResourceValue(androidns, "dialogMessage", 0);
-        mSuffix = attrs.getAttributeValue(androidns, "text");
+        mDialogMessage = (dialogMessageR == 0)
+                ? attrs.getAttributeValue(androidns, "dialogMessage")
+                : context.getResources().getString(dialogMessageR);
+        int textR = attrs.getAttributeResourceValue(androidns, "text", 0);
+        mSuffix = (textR == 0)
+                ? attrs.getAttributeValue(androidns, "text")
+                : context.getResources().getString(textR);
         mDefault = attrs.getAttributeValue(androidns, "defaultValue");
         mMax = Integer.parseInt(attrs.getAttributeValue(androidns, "max"));
         if (attrs.getAttributeValue(androidns, "direction") != null) {
@@ -84,7 +90,7 @@ public class SeekBarPreference extends DialogPreference implements SeekBar.OnSee
         mValueText.setGravity(Gravity.CENTER_HORIZONTAL);
         mValueText.setTextSize(32);
         params = new LinearLayout.LayoutParams(
-                LinearLayout.LayoutParams.FILL_PARENT,
+                LinearLayout.LayoutParams.MATCH_PARENT,
                 LinearLayout.LayoutParams.WRAP_CONTENT);
         layout.addView(mValueText, params);
 
@@ -93,7 +99,7 @@ public class SeekBarPreference extends DialogPreference implements SeekBar.OnSee
         // Move the bar away from the changing text, so you can see it, and
         // move it away from the edges to improve usability for the end-ranges.
         mSeekBar.setPadding(6, 30, 6, 6);
-        layout.addView(mSeekBar, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.FILL_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
+        layout.addView(mSeekBar, new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, LinearLayout.LayoutParams.WRAP_CONTENT));
 
         if (shouldPersist()) {
             mValue = Integer.parseInt(getPersistedString(mDefault));
@@ -126,7 +132,7 @@ public class SeekBarPreference extends DialogPreference implements SeekBar.OnSee
         if (shouldPersist()) {
             persistString(t);
         }
-        callChangeListener(new Integer(value));
+        callChangeListener(value);
     }
 
     public void onStartTrackingTouch(SeekBar seek) {

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

@@ -0,0 +1,358 @@
+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 net.i2p.android.widget.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;
+
+        if (action.equals("net.i2p.android.router.START_I2P")) {
+            if (mViewPager.getCurrentItem() != 0)
+                mViewPager.setCurrentItem(0, false);
+            autoStart();
+        }
+    }
+
+    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

@@ -1,22 +1,23 @@
-package net.i2p.android.router.activity;
+package net.i2p.android;
 
 import android.content.Context;
 import android.content.res.Resources;
 import android.os.Build;
-import java.io.ByteArrayOutputStream;
+
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Properties;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipInputStream;
 import net.i2p.android.router.R;
 import net.i2p.android.router.util.Util;
 import net.i2p.data.DataHelper;
 import net.i2p.util.FileUtil;
-import net.i2p.util.OrderedProperties;
+
+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?
 
@@ -33,47 +34,52 @@ class InitActivities {
 
     public InitActivities(Context c) {
         ctx = c;
-        // This needs to be changed so that we can have an alternative place
+        myDir = Util.getFileDir(c);
-        myDir = c.getFilesDir().getAbsolutePath();
         _ourVersion = Util.getOurVersion(c);
     }
 
     void debugStuff() {
-        Util.i("java.io.tmpdir" + ": " + System.getProperty("java.io.tmpdir"));
+        Util.d("java.io.tmpdir" + ": " + System.getProperty("java.io.tmpdir"));
-        Util.i("java.vendor" + ": " + System.getProperty("java.vendor"));
+        Util.d("java.vendor" + ": " + System.getProperty("java.vendor"));
-        Util.i("java.version" + ": " + System.getProperty("java.version"));
+        Util.d("java.version" + ": " + System.getProperty("java.version"));
-        Util.i("os.arch" + ": " + System.getProperty("os.arch"));
+        Util.d("os.arch" + ": " + System.getProperty("os.arch"));
-        Util.i("os.name" + ": " + System.getProperty("os.name"));
+        Util.d("os.name" + ": " + System.getProperty("os.name"));
-        Util.i("os.version" + ": " + System.getProperty("os.version"));
+        Util.d("os.version" + ": " + System.getProperty("os.version"));
-        Util.i("user.dir" + ": " + System.getProperty("user.dir"));
+        Util.d("user.dir" + ": " + System.getProperty("user.dir"));
-        Util.i("user.home" + ": " + System.getProperty("user.home"));
+        Util.d("user.home" + ": " + System.getProperty("user.home"));
-        Util.i("user.name" + ": " + System.getProperty("user.name"));
+        Util.d("user.name" + ": " + System.getProperty("user.name"));
-        Util.i("getFilesDir()" + ": " + myDir);
+        Util.d("getFilesDir()" + ": " + myDir);
-        Util.i("max mem" + ": " + DataHelper.formatSize(Runtime.getRuntime().maxMemory()));
+        Util.d("max mem" + ": " + DataHelper.formatSize(Runtime.getRuntime().maxMemory()));
-        Util.i("Package" + ": " + ctx.getPackageName());
+        Util.d("Package" + ": " + ctx.getPackageName());
-        Util.i("Version" + ": " + _ourVersion);
+        Util.d("Version" + ": " + _ourVersion);
-        Util.i("MODEL" + ": " + Build.MODEL);
+        Util.d("MODEL" + ": " + Build.MODEL);
-        Util.i("DISPLAY" + ": " + Build.DISPLAY);
+        Util.d("DISPLAY" + ": " + Build.DISPLAY);
-        Util.i("VERSION" + ": " + Build.VERSION.RELEASE);
+        Util.d("VERSION" + ": " + Build.VERSION.RELEASE);
-        Util.i("SDK" + ": " + Build.VERSION.SDK);
+        Util.d("SDK" + ": " + Build.VERSION.SDK_INT);
     }
 
     void initialize() {
 
         if (checkNewVersion()) {
-            Properties props = new Properties();
+            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 definatly won't have correct time.
+            // 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", null);
+            mergeResourceToFile(R.raw.logger_config, "logger.config", lProps.get(1));
-            mergeResourceToFile(R.raw.i2ptunnel_config, "i2ptunnel.config", null);
+            // 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);
@@ -88,15 +94,23 @@ class InitActivities {
             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();
@@ -119,9 +133,8 @@ class InitActivities {
             File certificates = new File(myDir, "certificates");
             File[] allcertificates = certificates.listFiles();
             if ( allcertificates != null) {
-                for (int i = 0; i < allcertificates.length; i++) {
+                for (File f : allcertificates) {
-                    File f = allcertificates[i];
+                    Util.d("Deleting old certificate file/dir " + f);
-                    Util.i("Deleting old certificate file/dir " + f);
                     FileUtil.rmdir(f, false);
                 }
             }
@@ -137,6 +150,15 @@ class InitActivities {
         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
      */
@@ -144,7 +166,7 @@ class InitActivities {
         InputStream in = null;
         FileOutputStream out = null;
 
-        Util.i("Creating file " + f + " from resource");
+        Util.d("Creating file " + f + " from resource");
         byte buf[] = new byte[4096];
         try {
             // Context methods
@@ -163,14 +185,14 @@ class InitActivities {
         }
     }
     /**
-     *  @param f relative to base dir
+     *  @param folder relative to base dir
      */
-    private void unzipResourceToDir(int resID, String f) {
+    private void unzipResourceToDir(int resID, String folder) {
         InputStream in = null;
         FileOutputStream out = null;
         ZipInputStream zis = null;
 
-        Util.i("Creating files in '" + myDir + "/" + f + "/' from resource");
+        Util.d("Creating files in '" + myDir + "/" + folder + "/' from resource");
         try {
             // Context methods
             in = ctx.getResources().openRawResource(resID);
@@ -185,11 +207,17 @@ class InitActivities {
                     while ((count = zis.read(buffer)) != -1) {
                         baos.write(buffer, 0, count);
                     }
-                    String filename = ze.getName();
+                    String name = ze.getName();
-                    Util.i("Creating file " + myDir + "/" + f +"/" + filename + " from resource");
+                    File f = new File(myDir + "/" + folder +"/" + name);
-                    byte[] bytes = baos.toByteArray();
+                    if (ze.isDirectory()) {
-                    out = new FileOutputStream(new File(myDir + "/" + f +"/" + filename));
+                        Util.d("Creating directory " + myDir + "/" + folder +"/" + name + " from resource");
-                    out.write(bytes);
+                        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; }
@@ -206,47 +234,14 @@ class InitActivities {
 
     /**
      *  Load defaults from resource,
-     *  then add props from file,
+     *  then add props from settings,
-     *  and write back
+     *  and write back.
-     *  For now, do it backwards so we can override with new apks.
-     *  When we have user configurable stuff, switch it back.
      *
      *  @param f relative to base dir
-     *  @param props local overrides or null
+     *  @param overrides local overrides or null
      */
-    public void mergeResourceToFile(int resID, String f, Properties overrides) {
+    private void mergeResourceToFile(int resID, String f, Properties overrides) {
-        InputStream in = null;
+        Util.mergeResourceToFile(ctx, myDir, f, resID, overrides, null);
-        InputStream fin = null;
-
-        byte buf[] = new byte[4096];
-        try {
-            in = ctx.getResources().openRawResource(resID);
-            Properties props = new OrderedProperties();
-            // keep user settings
-            //DataHelper.loadProps(props,  in);
-
-            try {
-                fin = new FileInputStream(new File(myDir, f));
-                DataHelper.loadProps(props,  fin);
-                Util.i("Merging resource into file " + f);
-            } catch (IOException ioe) {
-                Util.i("Creating file " + f + " from resource");
-            }
-
-            // override user settings
-            DataHelper.loadProps(props,  in);
-
-            if (overrides != null)
-                props.putAll(overrides);
-            File path = new File(myDir, f);
-            DataHelper.storeProps(props, path);
-            Util.i("Saved " + props.size() +" properties in " + f);
-        } catch (IOException ioe) {
-        } catch (Resources.NotFoundException nfe) {
-        } finally {
-            if (in != null) try { in.close(); } catch (IOException ioe) {}
-            if (fin != null) try { fin.close(); } catch (IOException ioe) {}
-        }
     }
 
     /**
@@ -262,7 +257,7 @@ class InitActivities {
             fin = ctx.openFileInput(CONFIG_FILE);
             DataHelper.loadProps(props,  fin);
         } catch (IOException ioe) {
-            Util.i("Looks like a new install");
+            Util.d("Looks like a new install");
         } finally {
             if (fin != null) try { fin.close(); } catch (IOException ioe) {}
         }
@@ -272,12 +267,12 @@ class InitActivities {
         boolean newVersion = !_ourVersion.equals(oldVersion);
 
         if (newVersion) {
-            Util.i("New version " + _ourVersion);
+            Util.d("New version " + _ourVersion);
             props.setProperty(PROP_INSTALLED_VERSION, _ourVersion);
             try {
                 DataHelper.storeProps(props, ctx.getFileStreamPath(CONFIG_FILE));
             } catch (IOException ioe) {
-                Util.i("Failed to write " + CONFIG_FILE);
+                Util.d("Failed to write " + CONFIG_FILE);
             }
         }
         return newVersion;

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.router.util.RFC822Date;
+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 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,117 @@
+package net.i2p.android.help;
+
+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 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);
+                        mCtx.startActivity(intent);
+                    }
+                });
+                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.setHtmlFromRawResource(getActivity(), getArguments().getInt(ARG_HTML_FILE), true);
+        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,277 @@
+package net.i2p.android.i2ptunnel;
+
+import android.app.Activity;
+import android.app.Dialog;
+import android.content.ActivityNotFoundException;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.Fragment;
+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.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.util.FragmentUtils;
+import net.i2p.app.ClientAppState;
+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;
+
+    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;
+        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) {
+            // Show error
+        } else if (getArguments().containsKey(TUNNEL_ID)) {
+            int tunnelId = getArguments().getInt(TUNNEL_ID);
+            mTunnel = new TunnelEntry(getActivity(),
+                    mGroup.getControllers().get(tunnelId),
+                    tunnelId);
+        }
+    }
+
+    @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) {
+            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());
+
+            TextView details = (TextView) v.findViewById(R.id.tunnel_details);
+            details.setText(mTunnel.getDetails());
+
+            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);
+                                            startActivity(intent);
+                                        }
+                                    }
+                                })
+                                .setNegativeButton(net.i2p.android.lib.client.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 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();
+            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();
+            return true;
+        case R.id.action_edit_tunnel:
+            mCallback.onEditTunnel(mTunnel.getId());
+            return true;
+        case R.id.action_delete_tunnel:
+            DialogFragment dg = new DialogFragment() {
+                @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) {
+                                        List<String> msgs = TunnelUtil.deleteTunnel(
+                                                I2PAppContext.getGlobalContext(),
+                                                mGroup, mTunnel.getId(), null);
+                                        dialog.dismiss();
+                                        Toast.makeText(getActivity().getApplicationContext(),
+                                                msgs.get(0), Toast.LENGTH_LONG).show();
+                                        mCallback.onTunnelDeleted(mTunnel.getId(),
+                                                mGroup.getControllers().size());
+                                    }
+                                })
+                        .setNegativeButton(android.R.string.cancel, null)
+                        .create();
+                }
+            };
+            dg.show(getFragmentManager(), "delete_tunnel_dialog");
+            return true;
+        default:
+            return super.onOptionsItemSelected(item);
+        }
+    }
+}

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

@@ -0,0 +1,287 @@
+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.TunnelUtil;
+import net.i2p.android.router.R;
+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.List;
+
+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;
+
+    public static TunnelEntry createNewTunnel(
+            Context ctx,
+            TunnelControllerGroup tcg,
+            TunnelConfig cfg) {
+        int tunnelId = tcg.getControllers().size();
+        List<String> msgs = TunnelUtil.saveTunnel(
+                I2PAppContext.getGlobalContext(), tcg, -1, cfg);
+        // TODO: Do something else with the other messages.
+        Toast.makeText(ctx.getApplicationContext(),
+                msgs.get(0), Toast.LENGTH_LONG).show();
+        TunnelController cur = TunnelUtil.getController(tcg, tunnelId);
+        return new TunnelEntry(ctx, cur, tunnelId);
+    }
+
+    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 = "";
+        return details;
+    }
+
+    public Drawable getStatusIcon() {
+        switch (getStatus()) {
+        case STANDBY:
+            return mContext.getResources()
+                    .getDrawable(R.drawable.ic_schedule_black_24dp);
+        case STARTING:
+        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,174 @@
+package net.i2p.android.i2ptunnel;
+
+import android.content.Context;
+import android.os.Build;
+import android.support.v4.util.Pair;
+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) {
+        mTunnels.add(tunnel);
+        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());
+
+                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);
+                        mListener.onTunnelSelected(tunnel.getId(),
+                                Pair.create((View)tvh.name, mCtx.getString(R.string.TUNNEL_NAME)),
+                                Pair.create((View)tvh.description, mCtx.getString(R.string.TUNNEL_DESCRIPTION)));
+                    }
+                });
+                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,233 @@
+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> tunnelName,
+                              Pair<View, String> tunnelDescription);
+    }
+
+    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) {
+        if (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();
+    }
+
+    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,46 @@
+package net.i2p.android.i2ptunnel;
+
+import android.app.Activity;
+import android.app.Dialog;
+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 new DialogFragment() {
+            @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) {
+                                        Intent result = new Intent();
+                                        result.putExtra(TunnelsContainer.TUNNEL_WIZARD_DATA, mWizardModel.save());
+                                        setResult(Activity.RESULT_OK, result);
+                                        dialog.dismiss();
+                                        finish();
+                                    }
+                                })
+                        .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,289 @@
+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);
+    }
+
+    @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);
+
+        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) {
+        RouterContext rCtx = Util.getRouterContext();
+        TunnelControllerGroup tcg = TunnelControllerGroup.getInstance();
+        boolean showActions = rCtx != null && tcg != null &&
+                (tcg.getState() == ClientAppState.STARTING ||
+                        tcg.getState() == ClientAppState.RUNNING);
+
+        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);
+
+        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:
+                msgs = tcg.restartAllControllers();
+                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.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> tunnelName,
+                                       Pair<View, String> tunnelDescription) {
+        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(), tunnelName, tunnelDescription);
+            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.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceCategory;
+import android.preference.PreferenceScreen;
+import android.support.v7.app.AlertDialog;
+
+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,89 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.os.Build;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.preference.PreferenceGroup;
+import android.preference.PreferenceScreen;
+import android.support.v4.preference.PreferenceFragment;
+
+import net.i2p.I2PAppContext;
+import net.i2p.android.i2ptunnel.util.TunnelUtil;
+import net.i2p.android.router.R;
+import net.i2p.i2ptunnel.TunnelControllerGroup;
+import net.i2p.i2ptunnel.ui.TunnelConfig;
+
+public abstract class BaseTunnelPreferenceFragment extends PreferenceFragment {
+    protected static final String ARG_TUNNEL_ID = "tunnelId";
+
+    protected TunnelControllerGroup mGroup;
+    protected int mTunnelId;
+
+    @Override
+    public void onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+
+        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) {
+            // TODO Show error
+        } else if (getArguments().containsKey(ARG_TUNNEL_ID)) {
+            mTunnelId = getArguments().getInt(ARG_TUNNEL_ID, 0);
+            TunnelUtil.writeTunnelToPreferences(getActivity(), mGroup, mTunnelId);
+            // https://stackoverflow.com/questions/17880437/which-settings-file-does-preferencefragment-read-write
+            getPreferenceManager().setSharedPreferencesName(TunnelUtil.getPreferencesFilename(mTunnelId));
+            loadPreferences();
+        }
+    }
+
+    @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);
+            TunnelUtil.saveTunnel(I2PAppContext.getGlobalContext(), mGroup, mTunnelId, cfg);
+        }
+    }
+
+    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,258 @@
+package net.i2p.android.i2ptunnel.preferences;
+
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
+import android.os.AsyncTask;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.ListPreference;
+import android.preference.Preference;
+import android.preference.PreferenceCategory;
+import android.preference.PreferenceScreen;
+import android.support.v4.app.Fragment;
+import android.support.v7.app.AlertDialog;
+
+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();
+                    String[] interfaces = interfaceSet.toArray(new String[interfaceSet.size()]);
+                    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/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,60 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+import android.preference.Preference;
+import android.support.v4.app.Fragment;
+import android.support.v4.preference.PreferenceFragment;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+
+public class AdvancedPreferenceFragment extends PreferenceFragment {
+    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 onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        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,36 @@
+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 onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        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,20 @@
+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 onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        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,108 @@
+package net.i2p.android.preferences;
+
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.PreferenceCategory;
+import android.preference.PreferenceManager;
+import android.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 onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        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.support.v4.preference.PreferenceFragment;
+import android.widget.Toast;
+
+import net.i2p.I2PAppContext;
+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 class I2PreferenceFragment extends PreferenceFragment {
+    @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,54 @@
+package net.i2p.android.preferences;
+
+import android.os.Bundle;
+import android.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 onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        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,20 @@
+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 onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        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,122 @@
+package net.i2p.android.preferences;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.CheckBoxPreference;
+import android.preference.Preference;
+import android.preference.PreferenceManager;
+import android.preference.PreferenceScreen;
+import android.widget.Toast;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+import net.i2p.android.router.util.PortPreference;
+import net.i2p.android.router.util.Util;
+import net.i2p.router.RouterContext;
+
+public class TransportsPreferenceFragment extends I2PreferenceFragment {
+    @Override
+    public void onCreate(Bundle paramBundle) {
+        super.onCreate(paramBundle);
+        // 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/router/ConsoleContainer.java

@@ -0,0 +1,128 @@
+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);
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(Menu menu) {
+        setMenuVisibility();
+    }
+
+    private void setMenuVisibility() {
+        boolean advanced = PreferenceManager.getDefaultSharedPreferences(getActivity()).getBoolean(
+                "i2pandroid.main.showStats", false);
+        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);
+        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

@@ -1,15 +1,14 @@
-package net.i2p.android.router.activity;
+package net.i2p.android.router;
 
-import android.app.ListActivity;
-import android.content.Intent;
 import android.os.Bundle;
+import android.support.v4.app.ListFragment;
 import android.view.View;
-import android.widget.AdapterView;
 import android.widget.ArrayAdapter;
 import android.widget.ListView;
-import net.i2p.android.router.R;
 
-public class LicenseActivity extends ListActivity {
+import net.i2p.android.router.dialog.TextResourceDialog;
+
+public class LicenseFragment extends ListFragment {
 
     private static final String[] names = {
         "Android Application License", "Apache 2.0",
@@ -26,20 +25,19 @@ public class LicenseActivity extends ListActivity {
         R.raw.license_installcert_txt, R.raw.license_sha256_txt, R.raw.license_sntp_txt, R.raw.license_addressbook_txt};
 
     @Override
-    public void onCreate(Bundle savedInstanceState)
+    public void onActivityCreated(Bundle savedInstanceState) {
-    {
+        super.onActivityCreated(savedInstanceState);
-        super.onCreate(savedInstanceState);
 
-        setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, names));
+        setListAdapter(new ArrayAdapter<>(getActivity(), android.R.layout.simple_list_item_1, names));
-        ListView lv = getListView();
+    }
 
-        // set the callback
+    @Override
-        lv.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+    public void onListItemClick(ListView parent, View view, int pos, long id) {
-            public void onItemClick(AdapterView parent, View view, int pos, long id) {
+        TextResourceDialog dialog = new TextResourceDialog();
-                Intent intent = new Intent(view.getContext(), TextResourceActivity.class);
+        Bundle args = new Bundle();
-                intent.putExtra(TextResourceActivity.TEXT_RESOURCE_ID, files[pos]);
+        args.putString(TextResourceDialog.TEXT_DIALOG_TITLE, names[pos]);
-                startActivity(intent);
+        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,657 @@
+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.formatSize(inBw) + "Bps / " + Util.formatSize(inData) + "B");
+            ((TextView) getActivity().findViewById(R.id.console_upload_stats)).setText(
+                    Util.formatSize(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 = _(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 = _(ctx, name);
+
+        return name;
+    }
+
+    private String _(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);
+        if (firstStart) {
+            FirstStartDialog dialog = new FirstStartDialog();
+            dialog.show(getActivity().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();
+        }
+    }
+}

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

@@ -0,0 +1,95 @@
+package net.i2p.android.router;
+
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.text.Html;
+import android.text.SpannableStringBuilder;
+import android.text.method.LinkMovementMethod;
+import android.text.style.URLSpan;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import net.i2p.android.apps.NewsFetcher;
+import net.i2p.android.router.util.Util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+public class NewsFragment extends I2PFragmentBase {
+    private long _lastChanged;
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+                             Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.fragment_news, container, false);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        NewsFetcher nf = NewsFetcher.getInstance();
+        if (nf != null) {
+            // Always update the status
+            TextView tv = (TextView) getActivity().findViewById(R.id.news_status);
+            tv.setText(nf.status().replace(" ", " "));
+            tv.setVisibility(View.VISIBLE);
+        }
+
+        // Only update the content if we need to
+        File newsFile = new File(Util.getFileDir(getActivity()), "docs/news.xml");
+        boolean newsExists = newsFile.exists();
+        if (_lastChanged > 0 && ((!newsExists) || newsFile.lastModified() < _lastChanged))
+            return;
+        _lastChanged = System.currentTimeMillis();
+
+        InputStream in = null;
+        ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
+        byte buf[] = new byte[1024];
+        try {
+            if (newsExists) {
+                in = new FileInputStream(newsFile);
+            } else {
+                in = getResources().openRawResource(R.raw.initialnews_html);
+            }
+
+            int read;
+            while ( (read = in.read(buf)) != -1)
+                out.write(buf, 0, read);
+
+        } catch (IOException ioe) {
+            System.err.println("news error " + ioe);
+        } catch (Resources.NotFoundException nfe) {
+        } finally {
+            if (in != null) try { in.close(); } catch (IOException ioe) {}
+        }
+
+        String news = "";
+        try {
+            news = out.toString("UTF-8");
+        } catch (UnsupportedEncodingException uee) {
+        }
+
+        // Get SpannableStringBuilder object from HTML code
+        CharSequence sequence = Html.fromHtml(news);
+        SpannableStringBuilder strBuilder = new SpannableStringBuilder(sequence);
+
+        // Get an array of URLSpan from SpannableStringBuilder object
+        URLSpan[] urlSpans = strBuilder.getSpans(0, strBuilder.length(), URLSpan.class);
+
+        // Remove URLSpans with relative paths, which can't be clicked on
+        for (final URLSpan span : urlSpans) {
+            if (span.getURL().startsWith("/"))
+                strBuilder.removeSpan(span);
+        }
+
+        TextView tv = (TextView) getActivity().findViewById(R.id.news_content);
+        tv.setText(strBuilder);
+        tv.setMovementMethod(LinkMovementMethod.getInstance());
+    }
+}

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

@@ -0,0 +1,154 @@
+package net.i2p.android.router;
+
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.preference.Preference;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.content.LocalBroadcastManager;
+import android.support.v4.preference.PreferenceFragment;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
+
+import net.i2p.android.I2PActivity;
+import net.i2p.android.preferences.AdvancedPreferenceFragment;
+import net.i2p.android.preferences.AppearancePreferenceFragment;
+import net.i2p.android.preferences.GraphsPreferenceFragment;
+import net.i2p.android.preferences.LoggingPreferenceFragment;
+import net.i2p.android.preferences.NetworkPreferenceFragment;
+import net.i2p.android.router.addressbook.AddressbookSettingsActivity;
+import net.i2p.android.router.service.RouterService;
+import net.i2p.android.util.LocaleManager;
+
+public class SettingsActivity extends AppCompatActivity implements
+        SharedPreferences.OnSharedPreferenceChangeListener {
+    public static final String PREFERENCE_CATEGORY = "preference_category";
+    public static final String PREFERENCE_CATEGORY_NETWORK = "preference_category_network";
+    public static final String PREFERENCE_CATEGORY_GRAPHS = "preference_category_graphs";
+    public static final String PREFERENCE_CATEGORY_LOGGING = "preference_category_logging";
+    public static final String PREFERENCE_CATEGORY_ADDRESSBOOK = "preference_category_addressbook";
+    public static final String PREFERENCE_CATEGORY_APPEARANCE = "preference_category_appearance";
+    public static final String PREFERENCE_CATEGORY_ADVANCED = "preference_category_advanced";
+
+    private final LocaleManager localeManager = new LocaleManager();
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        localeManager.onCreate(this);
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_single_fragment);
+
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        Fragment fragment;
+        String category = getIntent().getStringExtra(PREFERENCE_CATEGORY);
+        if (category != null)
+            fragment = getFragmentForCategory(category);
+        else
+            fragment = new SettingsFragment();
+
+        getSupportFragmentManager().beginTransaction()
+                .replace(R.id.fragment, fragment)
+                .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, I2PActivity.class);
+            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
+            startActivity(intent);
+            finish();
+        }
+        return true;
+    }
+
+    @Override
+    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
+        if (key.equals(getResources().getString(R.string.PREF_LANGUAGE))) {
+            localeManager.onResume(this);
+            Intent intent = new Intent(RouterService.LOCAL_BROADCAST_LOCALE_CHANGED);
+            LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
+        }
+    }
+
+    public static class SettingsFragment extends PreferenceFragment {
+        @Override
+        public void onCreate(Bundle paramBundle) {
+            super.onCreate(paramBundle);
+            addPreferencesFromResource(R.xml.settings);
+
+            this.findPreference(PREFERENCE_CATEGORY_NETWORK)
+                    .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_NETWORK));
+            this.findPreference(PREFERENCE_CATEGORY_GRAPHS)
+                    .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_GRAPHS));
+            this.findPreference(PREFERENCE_CATEGORY_LOGGING)
+                    .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_LOGGING));
+            this.findPreference(PREFERENCE_CATEGORY_ADDRESSBOOK)
+                    .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_ADDRESSBOOK));
+            this.findPreference(PREFERENCE_CATEGORY_APPEARANCE)
+                    .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_APPEARANCE));
+            this.findPreference(PREFERENCE_CATEGORY_ADVANCED)
+                    .setOnPreferenceClickListener(new CategoryClickListener(PREFERENCE_CATEGORY_ADVANCED));
+        }
+
+        @Override
+        public void onResume() {
+            super.onResume();
+            ((SettingsActivity) getActivity()).getSupportActionBar().setTitle(R.string.menu_settings);
+        }
+
+        private class CategoryClickListener implements Preference.OnPreferenceClickListener {
+            private String category;
+
+            public CategoryClickListener(String category) {
+                this.category = category;
+            }
+
+            @Override
+            public boolean onPreferenceClick(Preference preference) {
+                if (PREFERENCE_CATEGORY_ADDRESSBOOK.equals(category)) {
+                    Intent i = new Intent(getActivity(), AddressbookSettingsActivity.class);
+                    startActivity(i);
+                    return true;
+                }
+
+                Fragment fragment = getFragmentForCategory(category);
+                getActivity().getSupportFragmentManager().beginTransaction()
+                        .replace(R.id.fragment, fragment)
+                        .addToBackStack(null)
+                        .commit();
+                return true;
+            }
+        }
+    }
+
+    private static Fragment getFragmentForCategory(String category) {
+        switch (category) {
+            case PREFERENCE_CATEGORY_NETWORK:
+                return new NetworkPreferenceFragment();
+            case PREFERENCE_CATEGORY_GRAPHS:
+                return new GraphsPreferenceFragment();
+            case PREFERENCE_CATEGORY_LOGGING:
+                return new LoggingPreferenceFragment();
+            case PREFERENCE_CATEGORY_APPEARANCE:
+                return new AppearancePreferenceFragment();
+            case PREFERENCE_CATEGORY_ADVANCED:
+                return new AdvancedPreferenceFragment();
+            default:
+                throw new AssertionError();
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressEntry.java

@@ -0,0 +1,31 @@
+package net.i2p.android.router.addressbook;
+
+import net.i2p.data.Destination;
+
+public class AddressEntry {
+    private final String mHostName;
+    private final Destination mDest;
+
+    public AddressEntry(String hostName, Destination dest) {
+        mHostName = hostName;
+        mDest = dest;
+    }
+
+    public String getHostName() {
+        return mHostName;
+    }
+
+    public Destination getDestination() {
+        return mDest;
+    }
+
+    /**
+     * See item 8 from Josh Bloch's "Effective Java".
+     *
+     * @return the hashcode of this AddressEntry
+     */
+    @Override
+    public int hashCode() {
+        return 37 * mHostName.hashCode() + mDest.hashCode();
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressEntryAdapter.java

@@ -0,0 +1,144 @@
+package net.i2p.android.router.addressbook;
+
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.support.v7.widget.RecyclerView;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import net.i2p.android.router.R;
+import net.i2p.android.util.AlphanumericHeaderAdapter;
+
+import java.util.List;
+
+public class AddressEntryAdapter extends RecyclerView.Adapter<RecyclerView.ViewHolder> implements
+        AlphanumericHeaderAdapter.SortedAdapter {
+    private Context mCtx;
+    private AddressbookFragment.OnAddressSelectedListener mListener;
+    private List<AddressEntry> mAddresses;
+
+    public static class SimpleViewHolder extends RecyclerView.ViewHolder {
+        public SimpleViewHolder(View itemView) {
+            super(itemView);
+        }
+    }
+
+    public static class AddressViewHolder extends RecyclerView.ViewHolder {
+        public TextView hostName;
+
+        public AddressViewHolder(View itemView) {
+            super(itemView);
+
+            hostName = (TextView) itemView.findViewById(R.id.host_name);
+        }
+    }
+
+    public AddressEntryAdapter(Context context,
+                               AddressbookFragment.OnAddressSelectedListener listener) {
+        super();
+        mCtx = context;
+        mListener = listener;
+        setHasStableIds(true);
+    }
+
+    public void setAddresses(List<AddressEntry> addresses) {
+        mAddresses = addresses;
+        notifyDataSetChanged();
+    }
+
+    public AddressEntry getAddress(int position) {
+        if (mAddresses == null || mAddresses.isEmpty() ||
+                position < 0 || position >= mAddresses.size())
+            return null;
+
+        return mAddresses.get(position);
+    }
+
+    @NonNull
+    @Override
+    public String getSortString(int position) {
+        AddressEntry address = getAddress(position);
+        if (address == null)
+            return "";
+
+        return address.getHostName();
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        if (mAddresses == null)
+            return R.string.router_not_running;
+        else if (mAddresses.isEmpty())
+            return R.layout.listitem_empty;
+        else
+            return R.layout.listitem_address;
+    }
+
+    // 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_address:
+                return new AddressViewHolder(v);
+            default:
+                return new SimpleViewHolder(v);
+        }
+    }
+
+    // Replace the contents of a view (invoked by the layout manager)
+    @Override
+    public void onBindViewHolder(RecyclerView.ViewHolder holder, 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(
+                        mCtx.getString(R.string.addressbook_is_empty));
+                break;
+
+            case R.layout.listitem_address:
+                final AddressEntry address = getAddress(position);
+                AddressViewHolder avh = (AddressViewHolder) holder;
+                avh.hostName.setText(address.getHostName());
+
+                avh.itemView.setOnClickListener(new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        mListener.onAddressSelected(address.getHostName());
+                    }
+                });
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    // Return the size of the dataset (invoked by the layout manager)
+    @Override
+    public int getItemCount() {
+        if (mAddresses == null || mAddresses.isEmpty())
+            return 1;
+
+        return mAddresses.size();
+    }
+
+    public long getItemId(int position) {
+        AddressEntry address = getAddress(position);
+        if (address == null)
+            return Integer.MAX_VALUE;
+
+        return address.hashCode();
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressEntryLoader.java

@@ -0,0 +1,173 @@
+package net.i2p.android.router.addressbook;
+
+import android.content.Context;
+import android.support.v4.content.AsyncTaskLoader;
+
+import net.i2p.android.router.util.NamingServiceUtil;
+import net.i2p.android.router.util.Util;
+import net.i2p.client.naming.NamingService;
+import net.i2p.client.naming.NamingServiceListener;
+import net.i2p.data.Destination;
+import net.i2p.router.RouterContext;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+
+public class AddressEntryLoader extends AsyncTaskLoader<List<AddressEntry>> implements
+        NamingServiceListener {
+    private String mBook;
+    private String mFilter;
+    private List<AddressEntry> mData;
+
+    public AddressEntryLoader(Context context, String book, String filter) {
+        super(context);
+        mBook = book;
+        mFilter = filter;
+    }
+
+    @Override
+    public List<AddressEntry> loadInBackground() {
+        RouterContext routerContext = Util.getRouterContext();
+        if (routerContext == null)
+            return null;
+
+        // get the names
+        NamingService ns = NamingServiceUtil.getNamingService(routerContext, mBook);
+        Util.d("NamingService: " + ns.getName());
+        // After router shutdown we get nothing... why?
+        List<AddressEntry> ret = new ArrayList<>();
+        Map<String, Destination> names = new TreeMap<>();
+
+        Properties searchProps = new Properties();
+        // Needed for HostsTxtNamingService
+        searchProps.setProperty("file", mBook);
+        if (mFilter != null && mFilter.length() > 0)
+            searchProps.setProperty("search", mFilter);
+
+        names.putAll(ns.getEntries(searchProps));
+        for (String hostName : names.keySet())
+            ret.add(new AddressEntry(hostName, names.get(hostName)));
+        return ret;
+    }
+
+    @Override
+    public void deliverResult(List<AddressEntry> 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<AddressEntry> 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.
+        RouterContext routerContext = Util.getRouterContext();
+        if (routerContext != null) {
+            NamingService ns = NamingServiceUtil.getNamingService(routerContext, mBook);
+            ns.registerListener(this);
+        }
+
+        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.
+        RouterContext routerContext = Util.getRouterContext();
+        if (routerContext != null) {
+            NamingService ns = NamingServiceUtil.getNamingService(routerContext, mBook);
+            ns.unregisterListener(this);
+        }
+    }
+
+    @Override
+    public void onCanceled(List<AddressEntry> 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<AddressEntry> 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.
+    }
+
+    // NamingServiceListener
+
+    @Override
+    public void configurationChanged(NamingService ns) {
+        onContentChanged();
+    }
+
+    @Override
+    public void entryAdded(NamingService ns, String hostname, Destination dest, Properties options) {
+        onContentChanged();
+    }
+
+    @Override
+    public void entryChanged(NamingService ns, String hostname, Destination dest, Properties options) {
+        onContentChanged();
+    }
+
+    @Override
+    public void entryRemoved(NamingService ns, String hostname) {
+        onContentChanged();
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressbookAddWizardActivity.java

@@ -0,0 +1,45 @@
+package net.i2p.android.router.addressbook;
+
+import android.app.Activity;
+import android.app.Dialog;
+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.wizard.model.AbstractWizardModel;
+import net.i2p.android.wizard.ui.AbstractWizardActivity;
+
+public class AddressbookAddWizardActivity extends AbstractWizardActivity {
+    @Override
+    protected AbstractWizardModel onCreateModel() {
+        return new AddressbookAddWizardModel(this);
+    }
+
+    @Override
+    protected DialogFragment onGetFinishWizardDialog() {
+        return new DialogFragment() {
+            @NonNull
+            @Override
+            public Dialog onCreateDialog(Bundle savedInstanceState) {
+                return new AlertDialog.Builder(getActivity())
+                        .setMessage("Add to private addressbook?")
+                        .setPositiveButton("Add",
+                                new DialogInterface.OnClickListener() {
+
+                                    public void onClick(DialogInterface dialog, int which) {
+                                        Intent result = new Intent();
+                                        setResult(Activity.RESULT_OK, result);
+                                        result.putExtra(AddressbookContainer.ADD_WIZARD_DATA, mWizardModel.save());
+                                        dialog.dismiss();
+                                        finish();
+                                    }
+                                })
+                        .setNegativeButton(android.R.string.cancel, null)
+                        .create();
+            }
+        };
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressbookAddWizardModel.java

@@ -0,0 +1,31 @@
+package net.i2p.android.router.addressbook;
+
+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.I2PB64DestinationPage;
+import net.i2p.android.wizard.model.PageList;
+import net.i2p.android.wizard.model.SingleTextFieldPage;
+
+public class AddressbookAddWizardModel extends AbstractWizardModel {
+    public AddressbookAddWizardModel(Context context) {
+        super(context);
+    }
+
+    @Override
+    protected PageList onNewRootPageList() {
+        Resources res = mContext.getResources();
+
+        return new PageList(
+            new SingleTextFieldPage(this, res.getString(R.string.addressbook_add_wizard_k_name))
+                .setDescription(res.getString(R.string.addressbook_add_wizard_desc_name))
+                .setRequired(true),
+
+            new I2PB64DestinationPage(this, res.getString(R.string.addressbook_add_wizard_k_destination))
+                .setDescription(res.getString(R.string.addressbook_add_wizard_desc_destination))
+                .setRequired(true)
+            );
+    }
+
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressbookContainer.java

@@ -0,0 +1,250 @@
+package net.i2p.android.router.addressbook;
+
+import android.app.Activity;
+import android.app.SearchManager;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentPagerAdapter;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v4.view.MenuItemCompat;
+import android.support.v4.view.ViewPager;
+import android.support.v7.widget.SearchView;
+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 com.viewpagerindicator.TitlePageIndicator;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.NamingServiceUtil;
+import net.i2p.android.router.util.Util;
+import net.i2p.client.naming.NamingService;
+
+public class AddressbookContainer extends Fragment
+        implements AddressbookFragment.OnAddressSelectedListener,
+        SearchView.OnQueryTextListener {
+    public static final int ADD_WIZARD_REQUEST = 1;
+    public static final String ADD_WIZARD_DATA = "add_wizard_data";
+
+    /**
+     * Whether or not the container is in two-pane mode, i.e. running on a tablet
+     * device.
+     */
+    private boolean mTwoPane;
+
+    ViewPager mViewPager;
+    FragmentPagerAdapter mFragPagerAdapter;
+
+    private static final String FRAGMENT_ROUTER = "router_fragment";
+    private static final String FRAGMENT_PRIVATE = "private_fragment";
+    private static final int FRAGMENT_ID_ROUTER = 0;
+    private static final int FRAGMENT_ID_PRIVATE = 1;
+    AddressbookFragment mRouterFrag;
+    AddressbookFragment mPrivateFrag;
+
+    @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_addressbook, container, false);
+
+        if (v.findViewById(R.id.right_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) {
+            mRouterFrag = (AddressbookFragment) getChildFragmentManager().getFragment(
+                    savedInstanceState, FRAGMENT_ROUTER);
+            mPrivateFrag = (AddressbookFragment) getChildFragmentManager().getFragment(
+                    savedInstanceState, FRAGMENT_PRIVATE);
+        } else if (mTwoPane) {
+            // TODO if these were instantiated in the background, wouldn't savedInstanceState != null?
+            mRouterFrag = (AddressbookFragment) getChildFragmentManager().findFragmentById(R.id.left_fragment);
+            mPrivateFrag = (AddressbookFragment) getChildFragmentManager().findFragmentById(R.id.right_fragment);
+
+            // Set up the two pages
+            FragmentTransaction ft = getChildFragmentManager().beginTransaction();
+            if (mRouterFrag == null) {
+                mRouterFrag = AddressbookFragment.newInstance(AddressbookFragment.ROUTER_BOOK);
+                ft.add(R.id.left_fragment, mRouterFrag);
+            }
+            if (mPrivateFrag == null) {
+                mPrivateFrag = AddressbookFragment.newInstance(AddressbookFragment.PRIVATE_BOOK);
+                ft.add(R.id.right_fragment, mPrivateFrag);
+            }
+            ft.commit();
+        }
+
+        if (!mTwoPane) {
+            mViewPager = (ViewPager) v.findViewById(R.id.pager);
+            TitlePageIndicator pageIndicator = (TitlePageIndicator) v.findViewById(R.id.page_indicator);
+            mFragPagerAdapter = new AddressbookPagerAdapter(getActivity(), getChildFragmentManager());
+            mViewPager.setAdapter(mFragPagerAdapter);
+            pageIndicator.setViewPager(mViewPager);
+        }
+
+        return v;
+    }
+
+    public class AddressbookPagerAdapter extends FragmentPagerAdapter {
+        private static final int NUM_ITEMS = 2;
+
+        private Context mContext;
+
+        public AddressbookPagerAdapter(Context context, FragmentManager fm) {
+            super(fm);
+            mContext = context;
+        }
+
+        @Override
+        public int getCount() {
+            return NUM_ITEMS;
+        }
+
+        @Override
+        public Fragment getItem(int position) {
+            switch (position) {
+                case FRAGMENT_ID_ROUTER:
+                    return (mRouterFrag = AddressbookFragment.newInstance(AddressbookFragment.ROUTER_BOOK));
+                case FRAGMENT_ID_PRIVATE:
+                    return (mPrivateFrag = AddressbookFragment.newInstance(AddressbookFragment.PRIVATE_BOOK));
+                default:
+                    return null;
+            }
+        }
+
+        @Override
+        public CharSequence getPageTitle(int position) {
+            switch (position) {
+                case FRAGMENT_ID_ROUTER:
+                    return mContext.getString(R.string.label_router);
+                case FRAGMENT_ID_PRIVATE:
+                    return mContext.getString(R.string.label_private);
+                default:
+                    return null;
+            }
+        }
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.container_addressbook_actions, menu);
+        SearchManager searchManager = (SearchManager) getActivity().getSystemService(Context.SEARCH_SERVICE);
+        MenuItem searchItem = menu.findItem(R.id.action_search_addressbook);
+        SearchView searchView = (SearchView) MenuItemCompat.getActionView(searchItem);
+        searchView.setSearchableInfo(searchManager.getSearchableInfo(getActivity().getComponentName()));
+        searchView.setOnQueryTextListener(this);
+    }
+
+    @Override
+    public void setMenuVisibility(boolean menuVisible) {
+        super.setMenuVisibility(menuVisible);
+
+        setChildMenuVisibility(mRouterFrag, FRAGMENT_ID_ROUTER, menuVisible);
+        setChildMenuVisibility(mPrivateFrag, FRAGMENT_ID_PRIVATE, menuVisible);
+    }
+
+    private void setChildMenuVisibility(Fragment fragment, int itemNumber, boolean menuVisible) {
+        if (fragment != null) {
+            if (mViewPager != null)
+                menuVisible = menuVisible && mViewPager.getCurrentItem() == itemNumber;
+            fragment.setMenuVisibility(menuVisible);
+        }
+    }
+
+    @Override
+    public void setUserVisibleHint(boolean isVisibleToUser) {
+        super.setUserVisibleHint(isVisibleToUser);
+
+        setChildUserVisibleHint(mRouterFrag, FRAGMENT_ID_ROUTER, isVisibleToUser);
+        setChildUserVisibleHint(mPrivateFrag, FRAGMENT_ID_PRIVATE, isVisibleToUser);
+    }
+
+    private void setChildUserVisibleHint(Fragment fragment, int itemNumber, boolean isVisibleToUser) {
+        if (fragment != null) {
+            if (mViewPager != null)
+                isVisibleToUser = isVisibleToUser && mViewPager.getCurrentItem() == itemNumber;
+            fragment.setUserVisibleHint(isVisibleToUser);
+        }
+    }
+
+    @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 (mRouterFrag != null)
+            getChildFragmentManager().putFragment(outState, FRAGMENT_ROUTER, mRouterFrag);
+        if (mPrivateFrag != null)
+            getChildFragmentManager().putFragment(outState, FRAGMENT_PRIVATE, mPrivateFrag);
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        if (requestCode == ADD_WIZARD_REQUEST &&
+                resultCode == Activity.RESULT_OK) {
+            // Save the new entry
+            Bundle entryData = data.getExtras().getBundle(ADD_WIZARD_DATA);
+            NamingService ns = NamingServiceUtil.getNamingService(Util.getRouterContext(),
+                    AddressbookFragment.PRIVATE_BOOK);
+            NamingServiceUtil.addFromWizard(getActivity(), ns, entryData, false);
+            // The loader will be notified by the NamingService
+        }
+    }
+
+    // AddressbookFragment.OnAddressSelectedListener
+
+    public void onAddressSelected(CharSequence host) {
+        if (Intent.ACTION_PICK.equals(getActivity().getIntent().getAction())) {
+            Intent result = new Intent();
+            result.setData(Uri.parse("http://" + host));
+            getActivity().setResult(Activity.RESULT_OK, result);
+            getActivity().finish();
+        } else {
+            Intent i = new Intent(Intent.ACTION_VIEW);
+            i.setData(Uri.parse("http://" + host));
+            startActivity(i);
+        }
+    }
+
+    // SearchView.OnQueryTextListener
+
+    public boolean onQueryTextChange(String newText) {
+        filterAddresses(newText);
+        return true;
+    }
+
+    public boolean onQueryTextSubmit(String query) {
+        filterAddresses(query);
+        return true;
+    }
+
+    private void filterAddresses(String query) {
+        if (mRouterFrag != null)
+            mRouterFrag.filterAddresses(query);
+        if (mPrivateFrag != null)
+            mPrivateFrag.filterAddresses(query);
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressbookFragment.java

@@ -0,0 +1,267 @@
+package net.i2p.android.router.addressbook;
+
+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.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.text.TextUtils;
+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.eowise.recyclerview.stickyheaders.StickyHeadersBuilder;
+import com.eowise.recyclerview.stickyheaders.StickyHeadersItemDecoration;
+import com.pnikosis.materialishprogress.ProgressWheel;
+
+import net.i2p.addressbook.Daemon;
+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.AlphanumericHeaderAdapter;
+import net.i2p.android.util.FragmentUtils;
+import net.i2p.android.widget.DividerItemDecoration;
+import net.i2p.android.widget.LoadingRecyclerView;
+import net.i2p.router.RouterContext;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class AddressbookFragment extends Fragment implements
+        LoaderManager.LoaderCallbacks<List<AddressEntry>> {
+    public static final String BOOK_NAME = "book_name";
+    public static final String ROUTER_BOOK = "hosts.txt";
+    public static final String PRIVATE_BOOK = "privatehosts.txt";
+
+    private static final int ROUTER_LOADER_ID = 1;
+    private static final int PRIVATE_LOADER_ID = 2;
+
+    private OnAddressSelectedListener mCallback;
+
+    private LoadingRecyclerView mRecyclerView;
+    private AddressEntryAdapter mAdapter;
+    private String mBook;
+    private String mCurFilter;
+
+    private ImageButton mAddToAddressbook;
+
+    // Container Activity must implement this interface
+    public interface OnAddressSelectedListener {
+        void onAddressSelected(CharSequence host);
+    }
+
+    public static AddressbookFragment newInstance(String book) {
+        AddressbookFragment f = new AddressbookFragment();
+        Bundle args = new Bundle();
+        args.putString(AddressbookFragment.BOOK_NAME, book);
+        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, OnAddressSelectedListener.class);
+        if (mCallback == null)
+            throw new ClassCastException("Parent must implement OnAddressSelectedListener");
+
+    }
+
+    @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.fragment_list_with_add, 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);
+
+        mAddToAddressbook = (ImageButton) v.findViewById(R.id.promoted_action);
+        mAddToAddressbook.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                Intent wi = new Intent(getActivity(), AddressbookAddWizardActivity.class);
+                getParentFragment().startActivityForResult(wi, AddressbookContainer.ADD_WIZARD_REQUEST);
+            }
+        });
+
+        return v;
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        mBook = getArguments().getString(BOOK_NAME);
+
+        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 AddressEntryAdapter(getActivity(), mCallback);
+        mRecyclerView.setAdapter(mAdapter);
+
+        // Build item decoration and add it to the RecyclerView
+        StickyHeadersItemDecoration decoration = new StickyHeadersBuilder()
+                .setAdapter(mAdapter)
+                .setRecyclerView(mRecyclerView)
+                .setStickyHeadersAdapter(new AlphanumericHeaderAdapter(mAdapter))
+                .build();
+        mRecyclerView.addItemDecoration(decoration);
+
+        // Initialize the adapter in case the RouterService has not been created
+        if (Util.getRouterContext() == null)
+            mAdapter.setAddresses(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) {
+        int loaderId = PRIVATE_BOOK.equals(mBook) ?
+                PRIVATE_LOADER_ID : ROUTER_LOADER_ID;
+
+        if (state == State.STOPPING || state == State.STOPPED ||
+                state == State.MANUAL_STOPPING ||
+                state == State.MANUAL_STOPPED ||
+                state == State.MANUAL_QUITTING ||
+                state == State.MANUAL_QUITTED)
+            getLoaderManager().destroyLoader(loaderId);
+        else {
+            mRecyclerView.setLoading(true);
+            getLoaderManager().initLoader(loaderId, 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 onStop() {
+        super.onStop();
+
+        LocalBroadcastManager.getInstance(getActivity()).unregisterReceiver(onStateChange);
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.fragment_addressbook_actions, menu);
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(Menu menu) {
+        RouterContext rCtx = Util.getRouterContext();
+
+        if (mAddToAddressbook != null)
+            mAddToAddressbook.setVisibility(rCtx == null ? View.GONE : View.VISIBLE);
+
+        // Only show "Reload subscriptions" for router addressbook
+        menu.findItem(R.id.action_reload_subscriptions).setVisible(
+                rCtx != null && !PRIVATE_BOOK.equals(mBook));
+
+        // Only allow adding to private book 
+        if (!PRIVATE_BOOK.equals(mBook) && mAddToAddressbook != null) {
+            mAddToAddressbook.setVisibility(View.GONE);
+            mAddToAddressbook = null;
+        }
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle presses on the action bar items
+
+        switch (item.getItemId()) {
+            case R.id.action_reload_subscriptions:
+                Daemon.wakeup();
+                Toast.makeText(getActivity(), "Reloading subscriptions...",
+                        Toast.LENGTH_SHORT).show();
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    public void filterAddresses(String query) {
+        mCurFilter = !TextUtils.isEmpty(query) ? query : null;
+        if (Util.getRouterContext() != null && mAdapter != null) {
+            mRecyclerView.setLoading(true);
+            getLoaderManager().restartLoader(PRIVATE_BOOK.equals(mBook) ?
+                    PRIVATE_LOADER_ID : ROUTER_LOADER_ID, null, this);
+        }
+    }
+
+    // LoaderManager.LoaderCallbacks<List<AddressEntry>>
+
+    public Loader<List<AddressEntry>> onCreateLoader(int id, Bundle args) {
+        return new AddressEntryLoader(getActivity(), mBook, mCurFilter);
+    }
+
+    public void onLoadFinished(Loader<List<AddressEntry>> loader,
+                               List<AddressEntry> data) {
+        if (loader.getId() == (PRIVATE_BOOK.equals(mBook) ?
+                PRIVATE_LOADER_ID : ROUTER_LOADER_ID)) {
+            mAdapter.setAddresses(data);
+        }
+    }
+
+    public void onLoaderReset(Loader<List<AddressEntry>> loader) {
+        if (loader.getId() == (PRIVATE_BOOK.equals(mBook) ?
+                PRIVATE_LOADER_ID : ROUTER_LOADER_ID)) {
+            if (Util.getRouterContext() == null)
+                mAdapter.setAddresses(null);
+            else
+                mAdapter.setAddresses(new ArrayList<AddressEntry>());
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/addressbook/AddressbookSettingsActivity.java

@@ -1,30 +1,42 @@
-package net.i2p.android.router.activity;
+package net.i2p.android.router.addressbook;
 
-import android.app.Activity;
 import android.content.Context;
 import android.os.Bundle;
-import android.view.Menu;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.Toolbar;
 import android.view.View;
 import android.widget.Button;
 import android.widget.EditText;
 import android.widget.Toast;
+
+import net.i2p.android.router.R;
+import net.i2p.android.util.LocaleManager;
+import net.i2p.util.FileUtil;
+
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import net.i2p.android.router.R;
-import net.i2p.util.FileUtil;
 
-public class AddressbookSettingsActivity extends Activity {
+public class AddressbookSettingsActivity extends AppCompatActivity {
 
-    protected EditText text_content_subscriptions;
+    private EditText text_content_subscriptions;
-    protected Button btn_save_subscriptions;
+    private Button btn_save_subscriptions;
     private String filename = "/addressbook/subscriptions.txt";
     private File i2pDir;
 
+    private final LocaleManager localeManager = new LocaleManager();
+
     @Override
     public void onCreate(Bundle savedInstanceState) {
+        localeManager.onCreate(this);
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_addressbook_settings);
+
+        // Set the action bar
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
         text_content_subscriptions = (EditText) findViewById(R.id.subscriptions_content);
         btn_save_subscriptions = (Button) findViewById(R.id.button_save_subscriptions);
         init_actions();
@@ -32,12 +44,6 @@ public class AddressbookSettingsActivity extends Activity {
         load();
     }
 
-    @Override
-    public boolean onCreateOptionsMenu(Menu menu) {
-        getMenuInflater().inflate(R.menu.activity_addressbook_settings, menu);
-        return true;
-    }
-
     private void init_actions() {
         btn_save_subscriptions.setOnClickListener(new View.OnClickListener() {
             public void onClick(View view) {
@@ -65,7 +71,6 @@ public class AddressbookSettingsActivity extends Activity {
         return false;
     }
 
-    @SuppressWarnings("CallToThreadDumpStack")
     private boolean save() {
         //
         String content = text_content_subscriptions.getText().toString();
@@ -83,4 +88,10 @@ public class AddressbookSettingsActivity extends Activity {
         	if (out != null) try {out.close(); } catch (IOException ioe) {}
         }
     }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+        localeManager.onResume(this);
+    }
 }

app/src/main/java/net/i2p/android/router/dialog/AboutDialog.java

@@ -0,0 +1,58 @@
+package net.i2p.android.router.dialog;
+
+import android.app.Dialog;
+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 android.text.util.Linkify;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.TextView;
+
+import net.i2p.android.router.LicenseActivity;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.I2Patterns;
+import net.i2p.android.router.util.Util;
+
+public class AboutDialog extends DialogFragment {
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle SavedInstanceState) {
+        LayoutInflater li = LayoutInflater.from(getActivity());
+        View view = li.inflate(R.layout.fragment_dialog_about, null);
+
+        final String currentVersion = Util.getOurVersion(getActivity());
+        TextView tv = (TextView)view.findViewById(R.id.about_version);
+        tv.setText(currentVersion);
+
+        tv = (TextView)view.findViewById(R.id.url_project);
+        Linkify.addLinks(tv, I2Patterns.I2P_WEB_URL, "http://");
+        tv = (TextView)view.findViewById(R.id.url_android_bugs);
+        Linkify.addLinks(tv, I2Patterns.I2P_WEB_URL, "http://");
+        tv = (TextView)view.findViewById(R.id.url_android_volunteer);
+        Linkify.addLinks(tv, I2Patterns.I2P_WEB_URL, "http://");
+        tv = (TextView)view.findViewById(R.id.url_donate);
+        Linkify.addLinks(tv, I2Patterns.I2P_WEB_URL, "http://");
+
+        AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
+        b.setTitle(R.string.menu_about)
+                .setView(view)
+                .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+                    @Override
+                    public void onClick(DialogInterface dialog, int i) {
+                        dialog.dismiss();
+                    }
+                })
+                .setNeutralButton(R.string.label_licenses, new DialogInterface.OnClickListener() {
+                    @Override
+                    public void onClick(DialogInterface dialogInterface, int i) {
+                        Intent lic = new Intent(getActivity(), LicenseActivity.class);
+                        startActivity(lic);
+                    }
+                });
+        return b.create();
+    }
+}

app/src/main/java/net/i2p/android/router/dialog/FirstStartDialog.java

@@ -0,0 +1,40 @@
+package net.i2p.android.router.dialog;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v7.app.AlertDialog;
+import android.text.util.Linkify;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.TextView;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.I2Patterns;
+
+public class FirstStartDialog extends DialogFragment {
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        LayoutInflater li = LayoutInflater.from(getActivity());
+        View view = li.inflate(R.layout.fragment_dialog_first_start, null);
+
+        TextView tv = (TextView)view.findViewById(R.id.url_faq);
+        Linkify.addLinks(tv, I2Patterns.I2P_WEB_URL, "http://");
+        tv = (TextView)view.findViewById(R.id.url_irc_i2p);
+        Linkify.addLinks(tv, I2Patterns.IRC_URL, "irc://");
+
+        AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
+        b.setTitle(R.string.first_start_title)
+                .setView(view)
+                .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+                    @Override
+                    public void onClick(DialogInterface dialog, int i) {
+                        dialog.dismiss();
+                    }
+                });
+        return b.create();
+    }
+}

app/src/main/java/net/i2p/android/router/dialog/TextResourceDialog.java

@@ -0,0 +1,82 @@
+package net.i2p.android.router.dialog;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v7.app.AlertDialog;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.TextView;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UnsupportedEncodingException;
+
+/**
+ * Display a raw text resource.
+ * The resource ID must be passed as an extra in the intent.
+ */
+public class TextResourceDialog extends DialogFragment {
+    public static final String TEXT_DIALOG_TITLE = "text_title";
+    public final static String TEXT_RESOURCE_ID = "text_resource_id";
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
+        LayoutInflater inflater = LayoutInflater.from(getActivity());
+        View v = inflater.inflate(R.layout.fragment_dialog_text_resource, null, false);
+        TextView tv = (TextView) v.findViewById(R.id.text_resource_text);
+        String title = getArguments().getString(TEXT_DIALOG_TITLE);
+        if (title != null)
+            b.setTitle(title);
+        int id = getArguments().getInt(TEXT_RESOURCE_ID, R.raw.releasenotes_txt);
+        if (id == R.raw.releasenotes_txt)
+            tv.setText("Release Notes for Release " + Util.getOurVersion(getActivity()) + "\n\n" +
+                    getResourceAsString(id));
+        else
+            tv.setText(getResourceAsString(id));
+        b.setView(v)
+                .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+                    @Override
+                    public void onClick(DialogInterface dialogInterface, int i) {
+                        dialogInterface.dismiss();
+                    }
+                });
+
+        return b.create();
+    }
+
+    private String getResourceAsString(int id) {
+        InputStream in = null;
+        ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
+        byte buf[] = new byte[1024];
+        try {
+            in = getResources().openRawResource(id);
+
+            int read;
+            while ((read = in.read(buf)) != -1)
+                out.write(buf, 0, read);
+
+        } catch (IOException | Resources.NotFoundException re) {
+            System.err.println("resource error " + re);
+        } finally {
+            if (in != null) try {
+                in.close();
+            } catch (IOException ioe) {
+            }
+        }
+        try {
+            return out.toString("UTF-8");
+        } catch (UnsupportedEncodingException uee) {
+        }
+        return "";
+    }
+}

app/src/main/java/net/i2p/android/router/dialog/VersionDialog.java

@@ -0,0 +1,93 @@
+package net.i2p.android.router.dialog;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+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.I2PActivityBase;
+import net.i2p.android.router.MainFragment;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+
+public class VersionDialog extends DialogFragment {
+    public static final String DIALOG_TYPE = "dialog_type";
+    public static final int DIALOG_NEW_INSTALL = 0;
+    public static final int DIALOG_NEW_VERSION = 1;
+
+    @NonNull
+    @Override
+    public Dialog onCreateDialog(Bundle SavedInstanceState) {
+        final String currentVersion = Util.getOurVersion(getActivity());
+        Dialog rv;
+        AlertDialog.Builder b = new AlertDialog.Builder(getActivity());
+        int id = getArguments().getInt(DIALOG_TYPE);
+        switch(id) {
+            case DIALOG_NEW_INSTALL:
+                b.setMessage(R.string.welcome_new_install)
+                 .setCancelable(false)
+                 .setPositiveButton("Dismiss", new DialogInterface.OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int id) {
+                        I2PActivityBase ab = (I2PActivityBase) getActivity();
+                        ab.setPref(MainFragment.PREF_INSTALLED_VERSION, currentVersion);
+                        dialog.dismiss();
+                    }
+                }).setNegativeButton(R.string.label_release_notes, new DialogInterface.OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int id) {
+                        I2PActivityBase ab = (I2PActivityBase) getActivity();
+                        ab.setPref(MainFragment.PREF_INSTALLED_VERSION, currentVersion);
+                        dialog.dismiss();
+                        TextResourceDialog f = new TextResourceDialog();
+                        Bundle args = new Bundle();
+                        args.putInt(TextResourceDialog.TEXT_RESOURCE_ID, R.raw.releasenotes_txt);
+                        f.setArguments(args);
+                        getActivity().getSupportFragmentManager()
+                                     .beginTransaction()
+                                     .replace(R.id.main_fragment, f)
+                                     .addToBackStack(null)
+                                     .commit();
+                    }
+                });
+                rv = b.create();
+                break;
+
+            case DIALOG_NEW_VERSION:
+            default:
+                b.setMessage(getResources().getString(R.string.welcome_new_version) +
+                             " " + currentVersion)
+                 .setCancelable(true)
+                 .setPositiveButton("Dismiss", new DialogInterface.OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int id) {
+                        I2PActivityBase ab = (I2PActivityBase) getActivity();
+                        ab.setPref(MainFragment.PREF_INSTALLED_VERSION, currentVersion);
+                        dialog.dismiss();
+                    }
+                }).setNegativeButton(R.string.label_release_notes, new DialogInterface.OnClickListener() {
+
+                    public void onClick(DialogInterface dialog, int id) {
+                        I2PActivityBase ab = (I2PActivityBase) getActivity();
+                        ab.setPref(MainFragment.PREF_INSTALLED_VERSION, currentVersion);
+                        dialog.dismiss();
+                        TextResourceDialog f = new TextResourceDialog();
+                        Bundle args = new Bundle();
+                        args.putInt(TextResourceDialog.TEXT_RESOURCE_ID, R.raw.releasenotes_txt);
+                        f.setArguments(args);
+                        getActivity().getSupportFragmentManager()
+                                     .beginTransaction()
+                                     .replace(R.id.main_fragment, f)
+                                     .addToBackStack(null)
+                                     .commit();
+                    }
+                });
+
+                rv = b.create();
+                break;
+        }
+        return rv;
+    }
+}

app/src/main/java/net/i2p/android/router/log/LogActivity.java

@@ -0,0 +1,141 @@
+package net.i2p.android.router.log;
+
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v7.widget.Toolbar;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Spinner;
+
+import net.i2p.android.I2PActivityBase;
+import net.i2p.android.router.R;
+import net.i2p.android.router.SettingsActivity;
+
+public class LogActivity extends I2PActivityBase implements
+        LogFragment.OnEntrySelectedListener {
+    /**
+     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
+     * device.
+     */
+    private boolean mTwoPane;
+
+    private static final String SELECTED_LEVEL = "selected_level";
+
+    private String[] mLevels;
+    private Spinner mSpinner;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_multipane);
+
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        mLevels = getResources().getStringArray(R.array.log_level_list);
+
+        mSpinner = (Spinner) findViewById(R.id.main_spinner);
+        mSpinner.setVisibility(View.VISIBLE);
+
+
+        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;
+        }
+
+        mSpinner.setAdapter(ArrayAdapter.createFromResource(this,
+                R.array.log_level_list, android.R.layout.simple_spinner_dropdown_item));
+
+        mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
+            @Override
+            public void onItemSelected(AdapterView<?> adapterView, View view, int i, long l) {
+                selectLevel(i);
+            }
+
+            @Override
+            public void onNothingSelected(AdapterView<?> adapterView) {
+            }
+        });
+
+        if (savedInstanceState != null) {
+            int selected = savedInstanceState.getInt(SELECTED_LEVEL);
+            mSpinner.setSelection(selected);
+        } else
+            selectLevel(0);
+    }
+
+    private void selectLevel(int i) {
+        String level = mLevels[i];
+        LogFragment f = LogFragment.newInstance(level);
+        // In two-pane mode, list items should be given the
+        // 'activated' state when touched.
+        if (mTwoPane)
+            f.setActivateOnItemClick(true);
+        getSupportFragmentManager().beginTransaction()
+                .replace(R.id.main_fragment, f, level).commit();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        MenuInflater inflater = getMenuInflater();
+        inflater.inflate(R.menu.activity_base_actions, menu);
+        // Help menu not needed (yet), hide
+        // TODO: Unhide when Help finished
+        //menu.findItem(R.id.menu_help).setVisible(false);
+        return super.onCreateOptionsMenu(menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+        case R.id.menu_settings:
+            Intent intent = new Intent(LogActivity.this, SettingsActivity.class);
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
+                intent.setAction("net.i2p.android.router.PREFS_LOGGING");
+            } else { // TODO: Test if this works, fix if not
+                Bundle args = new Bundle();
+                args.putString("settings", "logging");
+                intent.putExtras(args);
+            }
+            startActivity(intent);
+            return true;
+
+        default:
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putInt(SELECTED_LEVEL, mSpinner.getSelectedItemPosition());
+    }
+
+    // LogFragment.OnEntrySelectedListener
+
+    public void onEntrySelected(String entry) {
+        if (mTwoPane) {
+            // In two-pane mode, show the detail view in this activity by
+            // adding or replacing the detail fragment using a
+            // fragment transaction.
+            LogDetailFragment detailFrag = LogDetailFragment.newInstance(entry);
+            getSupportFragmentManager().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(this, LogDetailActivity.class);
+            detailIntent.putExtra(LogDetailFragment.LOG_ENTRY, entry);
+            startActivity(detailIntent);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/log/LogAdapter.java

@@ -0,0 +1,24 @@
+package net.i2p.android.router.log;
+
+import java.util.List;
+
+import net.i2p.android.router.R;
+
+import android.content.Context;
+import android.widget.ArrayAdapter;
+
+public class LogAdapter extends ArrayAdapter<String> {
+
+    public LogAdapter(Context context) {
+        super(context, R.layout.listitem_logs);
+    }
+
+    public void setData(List<String> entries) {
+        clear();
+        if (entries != null) {
+            for (String entry : entries) {
+                add(entry);
+            }
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/log/LogDetailActivity.java

@@ -0,0 +1,28 @@
+package net.i2p.android.router.log;
+
+import android.os.Bundle;
+import android.support.v7.widget.Toolbar;
+
+import net.i2p.android.I2PActivityBase;
+import net.i2p.android.router.R;
+
+public class LogDetailActivity extends I2PActivityBase {
+    LogDetailFragment mDetailFrag;
+
+    @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);
+
+        if (savedInstanceState == null) {
+            String entry = getIntent().getStringExtra(LogDetailFragment.LOG_ENTRY);
+            mDetailFrag = LogDetailFragment.newInstance(entry);
+            getSupportFragmentManager().beginTransaction()
+                .add(R.id.main_fragment, mDetailFrag).commit();
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/log/LogDetailFragment.java

@@ -0,0 +1,86 @@
+package net.i2p.android.router.log;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.text.method.ScrollingMovementMethod;
+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.TextView;
+import android.widget.Toast;
+
+import net.i2p.android.router.I2PFragmentBase;
+import net.i2p.android.router.R;
+
+public class LogDetailFragment extends I2PFragmentBase {
+    public static final String LOG_ENTRY = "log_entry";
+
+    private String mEntry;
+
+    public static LogDetailFragment newInstance(String entry) {
+        LogDetailFragment f = new LogDetailFragment();
+        Bundle args = new Bundle();
+        args.putString(LOG_ENTRY, entry);
+        f.setArguments(args);
+        return f;
+    }
+
+    @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.fragment_log_entry, container, false);
+
+        mEntry = getArguments().getString(LOG_ENTRY);
+        TextView tv = (TextView) v.findViewById(R.id.log_entry);
+        tv.setMovementMethod(new ScrollingMovementMethod());
+        tv.setText(mEntry);
+
+        return v;
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.fragment_log_actions, menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle presses on the action bar items
+        switch (item.getItemId()) {
+            case R.id.action_copy_logs:
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB)
+                    copyToClipbardLegacy();
+                else
+                    copyToClipboardHoneycomb();
+
+                Toast.makeText(getActivity(), R.string.logs_copied_to_clipboard, Toast.LENGTH_SHORT).show();
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    private void copyToClipbardLegacy() {
+        android.text.ClipboardManager clipboard = (android.text.ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+        clipboard.setText(mEntry);
+    }
+
+    @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(
+                getString(R.string.i2p_android_logs), mEntry);
+        clipboard.setPrimaryClip(clip);
+    }
+}

app/src/main/java/net/i2p/android/router/log/LogFragment.java

@@ -0,0 +1,250 @@
+package net.i2p.android.router.log;
+
+import android.app.Activity;
+import android.content.Context;
+import android.os.Build;
+import android.os.Bundle;
+import android.support.v4.app.ListFragment;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.ListView;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import net.i2p.I2PAppContext;
+import net.i2p.android.router.R;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class LogFragment extends ListFragment implements
+        LoaderManager.LoaderCallbacks<List<String>> {
+    public static final String LOG_LEVEL = "log_level";
+    public static final String LOG_LEVEL_ERROR = "ERROR";
+    /**
+     * 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";
+
+    private static final int LEVEL_ERROR = 1;
+    private static final int LEVEL_ALL = 2;
+
+    OnEntrySelectedListener mEntrySelectedCallback;
+    private final List<String> mLogEntries = new ArrayList<>();
+    private LogAdapter mAdapter;
+    private TextView mHeaderView;
+    private String mLogLevel;
+    /**
+     * The current activated item position. Only used on tablets.
+     */
+    private int mActivatedPosition = ListView.INVALID_POSITION;
+    private boolean mActivateOnItemClick = false;
+
+    private MenuItem mCopyLogs;
+
+    // Container Activity must implement this interface
+    public interface OnEntrySelectedListener {
+        void onEntrySelected(String entry);
+    }
+
+    public static LogFragment newInstance(String level) {
+        LogFragment f = new LogFragment();
+        Bundle args = new Bundle();
+        args.putString(LOG_LEVEL, level);
+        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
+        try {
+            mEntrySelectedCallback = (OnEntrySelectedListener) activity;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement OnEntrySelectedListener");
+        }
+
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        // Restore the previously serialized activated item position.
+        if (savedInstanceState != null
+                && savedInstanceState.containsKey(STATE_ACTIVATED_POSITION)) {
+            setActivatedPosition(savedInstanceState
+                    .getInt(STATE_ACTIVATED_POSITION));
+        }
+
+        // When setting CHOICE_MODE_SINGLE, ListView will automatically
+        // give items the 'activated' state when touched.
+        getListView().setChoiceMode(
+                mActivateOnItemClick ? ListView.CHOICE_MODE_SINGLE
+                        : ListView.CHOICE_MODE_NONE);
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState)
+    {
+        super.onActivityCreated(savedInstanceState);
+        mAdapter = new LogAdapter(getActivity());
+        mLogLevel = getArguments().getString(LOG_LEVEL);
+
+        // set the header
+        mHeaderView = (TextView) getActivity().getLayoutInflater().inflate(R.layout.logs_header, null);
+        getListView().addHeaderView(mHeaderView, "", false);
+
+        setListAdapter(mAdapter);
+
+        I2PAppContext ctx = I2PAppContext.getCurrentContext();
+        if (ctx != null) {
+            setEmptyText(getString(LOG_LEVEL_ERROR.equals(mLogLevel) ?
+                    R.string.no_error_messages : R.string.no_messages));
+
+            setListShown(false);
+            getLoaderManager().initLoader(LOG_LEVEL_ERROR.equals(mLogLevel) ?
+                    LEVEL_ERROR : LEVEL_ALL, null, this);
+        } else
+            setEmptyText(getResources().getString(
+                    R.string.router_not_running));
+    }
+
+    @Override
+    public void onListItemClick(ListView parent, View view, int pos, long id) {
+        super.onListItemClick(parent, view, pos, id);
+        String entry = mAdapter.getItem(pos - 1);
+        mEntrySelectedCallback.onEntrySelected(entry);
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        if (mActivatedPosition != ListView.INVALID_POSITION) {
+            // Serialize and persist the activated item position.
+            outState.putInt(STATE_ACTIVATED_POSITION, mActivatedPosition);
+        }
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.fragment_log_actions, menu);
+        mCopyLogs = menu.findItem(R.id.action_copy_logs);
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(Menu menu) {
+        mCopyLogs.setVisible(I2PAppContext.getCurrentContext() != null);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle presses on the action bar items
+        switch (item.getItemId()) {
+            case R.id.action_copy_logs:
+                String logText = "";
+                synchronized (mLogEntries) {
+                    for (String logEntry : mLogEntries) {
+                        logText += logEntry;
+                    }
+                }
+
+                boolean isError = LOG_LEVEL_ERROR.equals(mLogLevel);
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
+                    android.text.ClipboardManager clipboard = (android.text.ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+                    clipboard.setText(logText);
+                } else {
+                    android.content.ClipboardManager clipboard = (android.content.ClipboardManager) getActivity().getSystemService(Context.CLIPBOARD_SERVICE);
+                    android.content.ClipData clip = android.content.ClipData.newPlainText(
+                            isError ? getString(R.string.i2p_android_error_logs) : getString(R.string.i2p_android_logs),
+                            logText);
+                    clipboard.setPrimaryClip(clip);
+                }
+
+                int textId;
+                if (isError)
+                    textId = R.string.error_logs_copied_to_clipboard;
+                else
+                    textId = R.string.logs_copied_to_clipboard;
+                Toast.makeText(getActivity(), textId, Toast.LENGTH_SHORT).show();
+                return true;
+            default:
+                return super.onOptionsItemSelected(item);
+        }
+    }
+
+    /**
+     * Turns on activate-on-click mode. When this mode is on, list items will be
+     * given the 'activated' state when touched.
+     */
+    public void setActivateOnItemClick(boolean activateOnItemClick) {
+        mActivateOnItemClick = activateOnItemClick;
+    }
+
+    private void setActivatedPosition(int position) {
+        if (position == ListView.INVALID_POSITION) {
+            getListView().setItemChecked(mActivatedPosition, false);
+        } else {
+            getListView().setItemChecked(position, true);
+        }
+
+        mActivatedPosition = position;
+    }
+
+    private static String getHeader(Context ctx, int sz, boolean errorsOnly) {
+        if (sz > 0)
+            return ctx.getResources().getQuantityString(errorsOnly ?
+                    R.plurals.log_error_messages : R.plurals.log_messages, sz, sz);
+        else
+            return ctx.getString(errorsOnly ? R.string.no_error_messages : R.string.no_messages);
+    }
+
+    // LoaderManager.LoaderCallbacks<List<String>>
+
+    public Loader<List<String>> onCreateLoader(int id, Bundle args) {
+        return new LogLoader(getActivity(),
+                I2PAppContext.getCurrentContext(), mLogLevel);
+    }
+
+    public void onLoadFinished(Loader<List<String>> loader,
+            List<String> data) {
+        if (loader.getId() == (LOG_LEVEL_ERROR.equals(mLogLevel) ?
+                LEVEL_ERROR : LEVEL_ALL)) {
+            synchronized (mLogEntries) {
+                mLogEntries.clear();
+                mLogEntries.addAll(data);
+            }
+            mAdapter.setData(data);
+            String header = getHeader(getActivity(), data.size(), (LOG_LEVEL_ERROR.equals(mLogLevel)));
+            mHeaderView.setText(header);
+
+            if (isResumed()) {
+                setListShown(true);
+            } else {
+                setListShownNoAnimation(true);
+            }
+        }
+    }
+
+    public void onLoaderReset(Loader<List<String>> loader) {
+        if (loader.getId() == (LOG_LEVEL_ERROR.equals(mLogLevel) ?
+                LEVEL_ERROR : LEVEL_ALL)) {
+            mAdapter.setData(null);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/log/LogLoader.java

@@ -0,0 +1,132 @@
+package net.i2p.android.router.log;
+
+import android.content.Context;
+import android.support.v4.content.AsyncTaskLoader;
+
+import net.i2p.I2PAppContext;
+
+import java.util.Collections;
+import java.util.List;
+
+public class LogLoader extends AsyncTaskLoader<List<String>> {
+    private I2PAppContext mCtx;
+    private String mLogLevel;
+    private List<String> mData;
+
+    private static final int MAX_LOG_LENGTH = 250;
+
+    public LogLoader(Context context, I2PAppContext ctx, String logLevel) {
+        super(context);
+        mCtx = ctx;
+        mLogLevel = logLevel;
+    }
+
+    @Override
+    public List<String> loadInBackground() {
+        List<String> msgs;
+        if (LogFragment.LOG_LEVEL_ERROR.equals(mLogLevel)) {
+            msgs = mCtx.logManager().getBuffer().getMostRecentCriticalMessages();
+        } else {
+            msgs = mCtx.logManager().getBuffer().getMostRecentMessages();
+        }
+        int sz = msgs.size();
+        if (sz > 1)
+            Collections.reverse(msgs);
+        if (sz > 0 && mData != null) {
+            String oldNewest = mData.size() > 0 ? mData.get(0) : null;
+            for (int i = 0; i < sz; i++) {
+                String newItem = msgs.get(i);
+                if (newItem.equals(oldNewest))
+                    break;
+                mData.add(i, newItem);
+            }
+            int newSz = mData.size();
+            for (int i = newSz - 1; i > MAX_LOG_LENGTH; i--) {
+                mData.remove(i);
+            }
+        }
+        return msgs;
+    }
+
+    @Override
+    public void deliverResult(List<String> 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<String> 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);
+        }
+
+        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;
+        }
+    }
+
+    @Override
+    public void onCanceled(List<String> 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<String> 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.
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbActivity.java

@@ -0,0 +1,121 @@
+package net.i2p.android.router.netdb;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v7.widget.Toolbar;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Spinner;
+
+import net.i2p.android.I2PActivityBase;
+import net.i2p.android.router.R;
+import net.i2p.data.Hash;
+
+public class NetDbActivity extends I2PActivityBase implements
+        NetDbListFragment.OnEntrySelectedListener {
+    /**
+     * Whether or not the activity is in two-pane mode, i.e. running on a tablet
+     * device.
+     */
+    private boolean mTwoPane;
+
+    private static final String SELECTED_PAGE = "selected_page";
+    private static final int PAGE_STATS = 0;
+    private static final int PAGE_ROUTERS = 1;
+
+    private Spinner mSpinner;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_multipane);
+
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+        getSupportActionBar().setDisplayHomeAsUpEnabled(true);
+
+        mSpinner = (Spinner) findViewById(R.id.main_spinner);
+        mSpinner.setVisibility(View.VISIBLE);
+
+        mSpinner.setAdapter(ArrayAdapter.createFromResource(this,
+                R.array.netdb_pages, android.R.layout.simple_spinner_dropdown_item));
+
+        mSpinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
+            @Override
+            public void onItemSelected(AdapterView<?> adapterView, View view, int i, long l) {
+                selectPage(i);
+            }
+
+            @Override
+            public void onNothingSelected(AdapterView<?> adapterView) {
+            }
+        });
+
+        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) {
+            int selected = savedInstanceState.getInt(SELECTED_PAGE);
+            mSpinner.setSelection(selected);
+        } else
+            selectPage(PAGE_STATS);
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        outState.putInt(SELECTED_PAGE, mSpinner.getSelectedItemPosition());
+    }
+
+    private void selectPage(int page) {
+        Fragment f;
+        if (page == PAGE_STATS)
+            f = new NetDbSummaryPagerFragment();
+        else {
+            f = new NetDbListFragment();
+            Bundle args = new Bundle();
+            args.putBoolean(NetDbListFragment.SHOW_ROUTERS, page == PAGE_ROUTERS);
+            f.setArguments(args);
+            // In two-pane mode, list items should be given the
+            // 'activated' state when touched.
+            if (mTwoPane)
+                ((NetDbListFragment) f).setActivateOnItemClick(true);
+        }
+        getSupportFragmentManager().beginTransaction()
+                .replace(R.id.main_fragment, f).commit();
+    }
+
+    // NetDbListFragment.OnEntrySelectedListener
+
+    public void onEntrySelected(boolean isRouterInfo, Hash entryHash) {
+        if (mTwoPane) {
+            // In two-pane mode, show the detail view in this activity by
+            // adding or replacing the detail fragment using a
+            // fragment transaction.
+            NetDbDetailFragment detailFrag = NetDbDetailFragment.newInstance(
+                    isRouterInfo, entryHash);
+            getSupportFragmentManager().beginTransaction()
+                    .replace(R.id.detail_fragment, detailFrag).commit();
+
+            // If we are coming from a LS to a RI, change the tab
+            int currentTab = mSpinner.getSelectedItemPosition();
+            if (isRouterInfo && currentTab != PAGE_ROUTERS)
+                selectPage(PAGE_ROUTERS);
+        } else {
+            // In single-pane mode, simply start the detail activity
+            // for the selected item ID.
+            Intent detailIntent = new Intent(this, NetDbDetailActivity.class);
+            detailIntent.putExtra(NetDbDetailFragment.IS_RI, isRouterInfo);
+            detailIntent.putExtra(NetDbDetailFragment.ENTRY_HASH,
+                    entryHash.toBase64());
+            startActivity(detailIntent);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbDetailActivity.java

@@ -0,0 +1,49 @@
+package net.i2p.android.router.netdb;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v7.widget.Toolbar;
+
+import net.i2p.android.I2PActivityBase;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.data.DataFormatException;
+import net.i2p.data.Hash;
+
+public class NetDbDetailActivity extends I2PActivityBase implements
+        NetDbListFragment.OnEntrySelectedListener {
+    NetDbDetailFragment mDetailFrag;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_onepane);
+
+        Toolbar toolbar = (Toolbar) findViewById(R.id.main_toolbar);
+        setSupportActionBar(toolbar);
+
+        if (savedInstanceState == null) {
+            boolean isRI = getIntent().getBooleanExtra(NetDbDetailFragment.IS_RI, true);
+            Hash hash = new Hash();
+            try {
+                hash.fromBase64(getIntent().getStringExtra(NetDbDetailFragment.ENTRY_HASH));
+                mDetailFrag = NetDbDetailFragment.newInstance(isRI, hash);
+                getSupportFragmentManager().beginTransaction()
+                    .add(R.id.main_fragment, mDetailFrag).commit();
+            } catch (DataFormatException e) {
+                Util.e(e.toString());
+            }
+        }
+    }
+
+    // NetDbListFragment.OnEntrySelectedListener
+
+    public void onEntrySelected(boolean isRouterInfo, Hash entryHash) {
+        // Start the detail activity for the selected item ID.
+        Intent detailIntent = new Intent(this, NetDbDetailActivity.class);
+        detailIntent.putExtra(NetDbDetailFragment.IS_RI, isRouterInfo);
+        detailIntent.putExtra(NetDbDetailFragment.ENTRY_HASH,
+                entryHash.toBase64());
+        startActivity(detailIntent);
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbDetailFragment.java

@@ -0,0 +1,246 @@
+package net.i2p.android.router.netdb;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnClickListener;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.LinearLayout;
+import android.widget.TableLayout;
+import android.widget.TableRow;
+import android.widget.TextView;
+
+import net.i2p.android.router.I2PFragmentBase;
+import net.i2p.android.router.R;
+import net.i2p.android.router.netdb.NetDbListFragment.OnEntrySelectedListener;
+import net.i2p.android.router.util.Util;
+import net.i2p.data.DataFormatException;
+import net.i2p.data.DataHelper;
+import net.i2p.data.Hash;
+import net.i2p.data.Lease;
+import net.i2p.data.LeaseSet;
+import net.i2p.data.router.RouterAddress;
+import net.i2p.data.router.RouterInfo;
+
+import java.util.Map;
+
+public class NetDbDetailFragment extends I2PFragmentBase {
+    public static final String IS_RI = "is_routerinfo";
+    public static final String ENTRY_HASH = "entry_hash";
+
+    OnEntrySelectedListener mEntrySelectedCallback;
+    private NetDbEntry mEntry;
+
+    public static NetDbDetailFragment newInstance(boolean isRI, Hash hash) {
+        NetDbDetailFragment f = new NetDbDetailFragment();
+        Bundle args = new Bundle();
+        args.putBoolean(IS_RI, isRI);
+        args.putString(ENTRY_HASH, hash.toBase64());
+        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
+        try {
+            mEntrySelectedCallback = (OnEntrySelectedListener) activity;
+        } catch (ClassCastException e) {
+            throw new ClassCastException(activity.toString()
+                    + " must implement OnEntrySelectedListener");
+        }
+
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        View v;
+        if (getArguments().getBoolean(IS_RI)) {
+            v = inflater.inflate(R.layout.fragment_netdb_router_detail, container, false);
+        } else {
+            v = inflater.inflate(R.layout.fragment_netdb_leaseset_detail, container, false);
+        }
+        return v;
+    }
+
+    @Override
+    public void onRouterConnectionReady() {
+        if (getRouterContext() != null && mEntry == null)
+            loadEntry();
+    }
+
+    private void loadEntry() {
+        if (getNetDb().isInitialized()) {
+            Hash hash = new Hash();
+            try {
+                hash.fromBase64(getArguments().getString(ENTRY_HASH));
+                if (getArguments().getBoolean(IS_RI)) {
+                    // Load RouterInfo
+                    RouterInfo ri = getNetDb().lookupRouterInfoLocally(hash);
+                    if (ri != null)
+                        loadRouterInfo(ri);
+                    // TODO: Handle null case in UI
+                } else {
+                    // Load LeaseSet
+                    LeaseSet ls = getNetDb().lookupLeaseSetLocally(hash);
+                    if (ls != null)
+                        loadLeaseSet(ls);
+                    // TODO: Handle null case in UI
+                }
+            } catch (DataFormatException e) {
+                Util.e(e.toString());
+            }
+        }
+    }
+
+    private void loadRouterInfo(RouterInfo ri) {
+        mEntry = NetDbEntry.fromRouterInfo(getRouterContext(), ri);
+
+        if (mEntry.isUs())
+            getActivity().setTitle("Our info");
+        else
+            getActivity().setTitle("Peer info");
+
+        TextView entryHash = (TextView) getView().findViewById(R.id.dbentry_hash);
+        entryHash.setText(mEntry.getHash().toBase64());
+
+        if (mEntry.isUs() && getRouter().isHidden()) {
+            TextView pubLabel = (TextView) getView().findViewById(R.id.label_ri_published);
+            pubLabel.setText("Hidden, Updated:");
+        }
+
+        TextView published = (TextView) getView().findViewById(R.id.ri_published);
+        long age = getRouterContext().clock().now() - ri.getPublished();
+        if (age > 0) {
+            published.setText(DataHelper.formatDuration(age) + " ago");
+        } else {
+            // shouldn't happen
+            published.setText(DataHelper.formatDuration(0-age) + " ago???");
+        }
+
+        LinearLayout addresses = (LinearLayout) getView().findViewById(R.id.ri_addresses);
+        for (RouterAddress addr : ri.getAddresses()) {
+            addAddress(addresses, addr);
+        }
+
+        TableLayout stats = (TableLayout) getView().findViewById(R.id.ri_stats);
+        Map<Object, Object> p = ri.getOptionsMap();
+        for (Map.Entry<Object,Object> e : p.entrySet()) {
+            String key = (String)e.getKey();
+            String val = (String)e.getValue();
+            addTableRow(stats, DataHelper.stripHTML(key), DataHelper.stripHTML(val));
+        }
+    }
+
+    private void addAddress(LinearLayout addresses, RouterAddress addr) {
+        TableLayout table = new TableLayout(getActivity());
+
+        String style = addr.getTransportStyle();
+        addTableRow(table, "Style", style);
+
+        int cost = addr.getCost();
+        if (!((style.equals("SSU") && cost == 5) || (style.equals("NTCP") && cost == 10)))
+            addTableRow(table, "cost", ""+cost);
+
+        Map<Object, Object> p = addr.getOptionsMap();
+        for (Map.Entry<Object,Object> e : p.entrySet()) {
+            String key = (String)e.getKey();
+            String val = (String)e.getValue();
+            addTableRow(table, DataHelper.stripHTML(key), DataHelper.stripHTML(val));
+        }
+
+        addresses.addView(table);
+    }
+
+    private void loadLeaseSet(LeaseSet ls) {
+        mEntry = NetDbEntry.fromLeaseSet(getRouterContext(), ls);
+
+        getActivity().setTitle("LeaseSet");
+
+        TextView nickname = (TextView) getView().findViewById(R.id.ls_nickname);
+        nickname.setText(mEntry.getNickname());
+
+        TextView type = (TextView) getView().findViewById(R.id.ls_type);
+        if (mEntry.isLocal()) {
+            if (mEntry.isUnpublished())
+                type.setText("Local Unpublished Destination");
+            else
+                type.setText("Local Destination");
+        }
+
+        TextView entryHash = (TextView) getView().findViewById(R.id.dbentry_hash);
+        entryHash.setText(mEntry.getHash().toBase64());
+
+        TextView expiry = (TextView) getView().findViewById(R.id.ls_expiry);
+        long exp = ls.getLatestLeaseDate() - getRouterContext().clock().now();
+        if (exp > 0) {
+            expiry.setText(DataHelper.formatDuration(exp));
+        } else {
+            TextView expiryLabel = (TextView) getView().findViewById(R.id.label_ls_expiry);
+            expiryLabel.setText("Expired:");
+            expiry.setText(DataHelper.formatDuration(exp) + " ago");
+        }
+
+        LinearLayout leases = (LinearLayout) getView().findViewById(R.id.ls_leases);
+        for (int i = 0; i < ls.getLeaseCount(); i++) {
+            Lease lease = ls.getLease(i);
+            addLease(leases, lease, i);
+        }
+    }
+
+    private void addLease(LinearLayout leases, Lease lease, int i) {
+        TableLayout table = new TableLayout(getActivity());
+
+        addTableRow(table, "Lease", ""+(i+1));
+
+        TableRow gateway = new TableRow(getActivity());
+        gateway.setPadding(10, 0, 0, 0);
+
+        TextView gatewayLabel = new TextView(getActivity());
+        gatewayLabel.setText("Gateway");
+
+        Button gatewayButton = new Button(getActivity());
+        gatewayButton.setText(lease.getGateway().toBase64().substring(0, 4));
+        final Hash gatewayHash = lease.getGateway();
+        gatewayButton.setOnClickListener(new OnClickListener() {
+            public void onClick(View view) {
+                mEntrySelectedCallback.onEntrySelected(
+                        true, gatewayHash);
+            }
+        });
+
+        gateway.addView(gatewayLabel);
+        gateway.addView(gatewayButton);
+
+        table.addView(gateway);
+
+        addTableRow(table, "Tunnel", ""+lease.getTunnelId().getTunnelId());
+
+        leases.addView(table);
+    }
+
+    private void addTableRow(TableLayout table, String key, String val) {
+        TableRow row;
+        TextView tl1, tl2;
+
+        row = new TableRow(getActivity());
+        row.setPadding(10, 0, 0, 0);
+
+        tl1 = new TextView(getActivity());
+        tl2 = new TextView(getActivity());
+
+        tl1.setText(key);
+        tl2.setText(val);
+
+        row.addView(tl1);
+        row.addView(tl2);
+
+        table.addView(row);
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbEntry.java

@@ -0,0 +1,124 @@
+package net.i2p.android.router.netdb;
+
+import java.lang.reflect.Field;
+
+import net.i2p.android.router.R;
+import net.i2p.data.DatabaseEntry;
+import net.i2p.data.Destination;
+import net.i2p.data.Hash;
+import net.i2p.data.LeaseSet;
+import net.i2p.data.router.RouterInfo;
+import net.i2p.router.RouterContext;
+import net.i2p.router.TunnelPoolSettings;
+
+public class NetDbEntry {
+    private final boolean mIsRI;
+    private final DatabaseEntry mEntry;
+
+    private final boolean mIsUs;
+    private final String mCountry;
+
+    private final String mNick;
+    private final boolean mLocal;
+    private final boolean mUnpublished;
+
+    public static NetDbEntry fromRouterInfo(RouterContext ctx, RouterInfo ri) {
+        Hash us = ctx.routerHash();
+        boolean isUs = ri.getHash().equals(us);
+        // XXX Disabled, no GeoIP file
+        String country = "";//ctx.commSystem().getCountry(ri.getIdentity().getHash());
+        return new NetDbEntry(ri, isUs, country);
+    }
+
+    public static NetDbEntry fromLeaseSet(RouterContext ctx, LeaseSet ls) {
+        String nick;
+        boolean local = false;
+        boolean unpublished = false;
+        Destination dest = ls.getDestination();
+        Hash key = dest.calculateHash();
+        if (ctx.clientManager().isLocal(dest)) {
+            local = true;
+            if (! ctx.clientManager().shouldPublishLeaseSet(key))
+                unpublished = true;
+            TunnelPoolSettings in = ctx.tunnelManager().getInboundSettings(key);
+            if (in != null && in.getDestinationNickname() != null)
+                nick = in.getDestinationNickname();
+            else
+                nick = dest.toBase64().substring(0, 6);
+        } else {
+            String host = ctx.namingService().reverseLookup(dest);
+            if (host != null)
+                nick = host;
+            else
+                nick = dest.toBase64().substring(0, 6);
+        }
+        return new NetDbEntry(ls, nick, local, unpublished);
+    }
+
+    private NetDbEntry(RouterInfo ri,
+                       boolean isUs, String country) {
+        mIsRI = true;
+        mEntry = ri;
+
+        mIsUs = isUs;
+        mCountry = country;
+
+        mNick = "";
+        mLocal = mUnpublished = false;
+    }
+
+    private NetDbEntry(LeaseSet ls,
+                       String nick, boolean local, boolean unpublished) {
+        mIsRI = false;
+        mEntry = ls;
+
+        mNick = nick;
+        mLocal = local;
+        mUnpublished = unpublished;
+
+        mIsUs = false;
+        mCountry = "";
+    }
+
+    public boolean isRouterInfo() {
+        return mIsRI;
+    }
+
+    // General methods
+
+    public Hash getHash() {
+        return mEntry.getHash();
+    }
+
+    // RouterInfo-specific methods
+
+    public boolean isUs() {
+        return mIsUs;
+    }
+
+    public int getCountryIcon() {
+        // http://daniel-codes.blogspot.com/2009/12/dynamically-retrieving-resources-in.html
+        try {
+            Class<R.drawable> res = R.drawable.class;
+            Field field = res.getField("flag_" + mCountry);
+            return field.getInt(null);
+        }
+        catch (Exception e) {
+            return 0;
+        }
+    }
+
+    // LeaseSet-specific methods
+
+    public String getNickname() {
+        return mNick;
+    }
+
+    public boolean isLocal() {
+        return mLocal;
+    }
+
+    public boolean isUnpublished() {
+        return mUnpublished;
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbEntryAdapter.java

@@ -0,0 +1,57 @@
+package net.i2p.android.router.netdb;
+
+import java.util.List;
+
+import net.i2p.android.router.R;
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ArrayAdapter;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+public class NetDbEntryAdapter extends ArrayAdapter<NetDbEntry> {
+    private final LayoutInflater mInflater;
+
+    public NetDbEntryAdapter(Context context) {
+        super(context, android.R.layout.simple_list_item_2);
+        mInflater = (LayoutInflater) context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+    }
+
+    public void setData(List<NetDbEntry> entries) {
+        clear();
+        if (entries != null) {
+            for (NetDbEntry entry : entries) {
+                add(entry);
+            }
+        }
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        View v;
+        NetDbEntry entry = getItem(position);
+
+        if (entry.isRouterInfo()) {
+            v = mInflater.inflate(R.layout.listitem_routerinfo, parent, false);
+
+            int countryIcon = entry.getCountryIcon();
+            if (countryIcon > 0) {
+                ImageView country = (ImageView) v.findViewById(R.id.ri_country);
+                country.setImageDrawable(getContext().getResources()
+                        .getDrawable(countryIcon));
+            }
+        } else {
+            v = mInflater.inflate(R.layout.listitem_leaseset, parent, false);
+
+            TextView nickname = (TextView) v.findViewById(R.id.ls_nickname);
+            nickname.setText(entry.getNickname());
+        }
+
+        TextView hash = (TextView) v.findViewById(R.id.dbentry_hash);
+        hash.setText(entry.getHash().toBase64());
+
+        return v;
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbEntryLoader.java

@@ -0,0 +1,157 @@
+package net.i2p.android.router.netdb;
+
+import android.content.Context;
+import android.support.v4.content.AsyncTaskLoader;
+
+import net.i2p.android.router.util.Util;
+import net.i2p.data.Destination;
+import net.i2p.data.LeaseSet;
+import net.i2p.data.router.RouterInfo;
+import net.i2p.router.RouterContext;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class NetDbEntryLoader extends AsyncTaskLoader<List<NetDbEntry>> {
+    private boolean mRouters;
+    private List<NetDbEntry> mData;
+
+    public NetDbEntryLoader(Context context, boolean routers) {
+        super(context);
+        mRouters = routers;
+    }
+
+    private static class RouterInfoComparator implements Comparator<RouterInfo> {
+        public int compare(RouterInfo l, RouterInfo r) {
+            return l.getIdentity().getHash().toBase64().compareTo(r.getIdentity().getHash().toBase64());
+        }
+    }
+
+    private class LeaseSetComparator implements Comparator<LeaseSet> {
+        private RouterContext mRContext;
+
+        public LeaseSetComparator(RouterContext rContext) {
+            super();
+            mRContext = rContext;
+        }
+
+        public int compare(LeaseSet l, LeaseSet r) {
+            Destination dl = l.getDestination();
+            Destination dr = r.getDestination();
+            boolean locall = mRContext.clientManager().isLocal(dl);
+            boolean localr = mRContext.clientManager().isLocal(dr);
+            if (locall && !localr) return -1;
+            if (localr && !locall) return 1;
+            return dl.calculateHash().toBase64().compareTo(dr.calculateHash().toBase64());
+        }
+    }
+
+    @Override
+    public List<NetDbEntry> loadInBackground() {
+        List<NetDbEntry> ret = new ArrayList<>();
+        RouterContext routerContext = Util.getRouterContext();
+        if (routerContext != null && routerContext.netDb().isInitialized()) {
+            if (mRouters) {
+                Set<RouterInfo> routers = new TreeSet<>(new RouterInfoComparator());
+                routers.addAll(routerContext.netDb().getRouters());
+                for (RouterInfo ri : routers) {
+                    NetDbEntry entry = NetDbEntry.fromRouterInfo(routerContext, ri);
+                    ret.add(entry);
+                }
+            } else {
+                Set<LeaseSet> leases = new TreeSet<>(new LeaseSetComparator(routerContext));
+                leases.addAll(routerContext.netDb().getLeases());
+                for (LeaseSet ls : leases) {
+                    NetDbEntry entry = NetDbEntry.fromLeaseSet(routerContext, ls);
+                    ret.add(entry);
+                }
+            }
+        }
+        return ret;
+    }
+
+    @Override
+    public void deliverResult(List<NetDbEntry> 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<NetDbEntry> 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);
+        }
+
+        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;
+        }
+    }
+
+    @Override
+    public void onCanceled(List<NetDbEntry> 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<NetDbEntry> 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.
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbListFragment.java

@@ -0,0 +1,189 @@
+package net.i2p.android.router.netdb;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.support.v4.app.ListFragment;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.ListView;
+
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.data.Hash;
+
+import java.util.List;
+
+public class NetDbListFragment extends ListFragment implements
+        LoaderManager.LoaderCallbacks<List<NetDbEntry>> {
+    public static final String SHOW_ROUTERS = "show_routers";
+
+    private static final int ROUTER_LOADER_ID = 1;
+    private static final int LEASESET_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";
+
+    private OnEntrySelectedListener mEntrySelectedCallback;
+    private NetDbEntryAdapter mAdapter;
+    private boolean mRouters;
+    /**
+     * The current activated item position. Only used on tablets.
+     */
+    private int mActivatedPosition = ListView.INVALID_POSITION;
+    private boolean mActivateOnItemClick = false;
+
+    // Container Activity must implement this interface
+    public interface OnEntrySelectedListener {
+        void onEntrySelected(boolean isRouterInfo, Hash entryHash);
+    }
+
+    @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 onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        // Restore the previously serialized activated item position.
+        if (savedInstanceState != null
+                && savedInstanceState.containsKey(STATE_ACTIVATED_POSITION)) {
+            setActivatedPosition(savedInstanceState
+                    .getInt(STATE_ACTIVATED_POSITION));
+        }
+
+        // When setting CHOICE_MODE_SINGLE, ListView will automatically
+        // give items the 'activated' state when touched.
+        getListView().setChoiceMode(
+                mActivateOnItemClick ? ListView.CHOICE_MODE_SINGLE
+                        : ListView.CHOICE_MODE_NONE);
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        mAdapter = new NetDbEntryAdapter(getActivity());
+        mRouters = getArguments().getBoolean(SHOW_ROUTERS);
+
+        setListAdapter(mAdapter);
+
+        if (Util.getRouterContext() == null)
+            setEmptyText(getResources().getString(
+                    R.string.router_not_running));
+        else {
+            setEmptyText(getResources().getString((mRouters ?
+                    R.string.netdb_routers_empty :
+                    R.string.netdb_leases_empty)));
+
+            setListShown(false);
+            getLoaderManager().initLoader(mRouters ? ROUTER_LOADER_ID
+                    : LEASESET_LOADER_ID, null, this);
+        }
+    }
+
+    @Override
+    public void onListItemClick(ListView parent, View view, int pos, long id) {
+        super.onListItemClick(parent, view, pos, id);
+        NetDbEntry entry = mAdapter.getItem(pos);
+        mEntrySelectedCallback.onEntrySelected(
+                entry.isRouterInfo(), entry.getHash());
+    }
+
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        super.onSaveInstanceState(outState);
+        if (mActivatedPosition != ListView.INVALID_POSITION) {
+            // Serialize and persist the activated item position.
+            outState.putInt(STATE_ACTIVATED_POSITION, mActivatedPosition);
+        }
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.fragment_netdb_list_actions, menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle presses on the action bar items
+        switch (item.getItemId()) {
+        case R.id.action_refresh:
+            if (Util.getRouterContext() != null) {
+                setListShown(false);
+                getLoaderManager().restartLoader(mRouters ? ROUTER_LOADER_ID
+                        : LEASESET_LOADER_ID, null, this);
+            }
+            return true;
+        default:
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    /**
+     * Turns on activate-on-click mode. When this mode is on, list items will be
+     * given the 'activated' state when touched.
+     */
+    public void setActivateOnItemClick(boolean activateOnItemClick) {
+        mActivateOnItemClick = activateOnItemClick;
+    }
+
+    private void setActivatedPosition(int position) {
+        if (position == ListView.INVALID_POSITION) {
+            getListView().setItemChecked(mActivatedPosition, false);
+        } else {
+            getListView().setItemChecked(position, true);
+        }
+
+        mActivatedPosition = position;
+    }
+
+    // LoaderManager.LoaderCallbacks<List<NetDbEntry>>
+
+    public Loader<List<NetDbEntry>> onCreateLoader(int id, Bundle args) {
+        return new NetDbEntryLoader(getActivity(), mRouters);
+    }
+
+    public void onLoadFinished(Loader<List<NetDbEntry>> loader,
+            List<NetDbEntry> data) {
+        if (loader.getId() == (mRouters ?
+                ROUTER_LOADER_ID : LEASESET_LOADER_ID)) {
+            mAdapter.setData(data);
+
+            if (isResumed()) {
+                setListShown(true);
+            } else {
+                setListShownNoAnimation(true);
+            }
+        }
+    }
+
+    public void onLoaderReset(Loader<List<NetDbEntry>> loader) {
+        if (loader.getId() == (mRouters ?
+                ROUTER_LOADER_ID : LEASESET_LOADER_ID)) {
+            mAdapter.setData(null);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbStatsLoader.java

@@ -0,0 +1,195 @@
+package net.i2p.android.router.netdb;
+
+import android.content.Context;
+import android.support.v4.content.AsyncTaskLoader;
+
+import net.i2p.android.router.R;
+import net.i2p.data.Hash;
+import net.i2p.data.router.RouterAddress;
+import net.i2p.data.router.RouterInfo;
+import net.i2p.router.RouterContext;
+import net.i2p.util.ObjectCounter;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+public class NetDbStatsLoader extends AsyncTaskLoader<List<ObjectCounter<String>>> {
+    private RouterContext mRContext;
+    private List<ObjectCounter<String>> mData;
+
+    public NetDbStatsLoader(Context context, RouterContext rContext) {
+        super(context);
+        mRContext = rContext;
+    }
+
+    private static class RouterInfoComparator implements Comparator<RouterInfo> {
+        public int compare(RouterInfo l, RouterInfo r) {
+            return l.getHash().toBase64().compareTo(r.getHash().toBase64());
+        }
+    }
+
+    @Override
+    public List<ObjectCounter<String>> loadInBackground() {
+        List<ObjectCounter<String>> ret = new ArrayList<>();
+
+        ObjectCounter<String> versions = new ObjectCounter<>();
+        ObjectCounter<String> countries = new ObjectCounter<>();
+        ObjectCounter<String> transports = new ObjectCounter<>();
+
+        if (mRContext != null && mRContext.netDb() != null && mRContext.netDb().isInitialized()) {
+            Hash us = mRContext.routerHash();
+
+            Set<RouterInfo> routers = new TreeSet<>(new RouterInfoComparator());
+            routers.addAll(mRContext.netDb().getRouters());
+            for (RouterInfo ri : routers) {
+                Hash key = ri.getHash();
+                if (!key.equals(us)) {
+                    String routerVersion = ri.getOption("router.version");
+                    if (routerVersion != null)
+                        versions.increment(routerVersion);
+                    // XXX Disabled, no GeoIP file
+                    String country = null;//mRContext.commSystem().getCountry(key);
+                    if(country != null)
+                        countries.increment(country);
+                    transports.increment(classifyTransports(ri));
+                }
+            }
+        }
+
+        ret.add(versions);
+        //ret.add(countries);
+        ret.add(transports);
+
+        return ret;
+    }
+
+    private static final int SSU = 1;
+    private static final int SSUI = 2;
+    private static final int NTCP = 4;
+    private static final int IPV6 = 8;
+    private static final int[] TNAMES = {
+            R.string.tname_0,
+            R.string.tname_1,
+            R.string.tname_2,
+            0,
+            R.string.tname_4,
+            R.string.tname_5,
+            R.string.tname_6,
+            0,
+            0,
+            R.string.tname_9,
+            R.string.tname_10,
+            R.string.tname_11,
+            R.string.tname_12,
+            R.string.tname_13,
+            R.string.tname_14,
+            R.string.tname_15,
+    };
+    /**
+     *  what transport types
+     */
+    private String classifyTransports(RouterInfo info) {
+        int rv = 0;
+        for (RouterAddress addr : info.getAddresses()) {
+            String style = addr.getTransportStyle();
+            if (style.equals("NTCP")) {
+                rv |= NTCP;
+            } else if (style.equals("SSU")) {
+                if (addr.getOption("iport0") != null)
+                    rv |= SSUI;
+                else
+                    rv |= SSU;
+            }
+            String host = addr.getHost();
+            if (host != null && host.contains(":"))
+                rv |= IPV6;
+
+        }
+        return getContext().getString(TNAMES[rv]);
+    }
+
+    @Override
+    public void deliverResult(List<ObjectCounter<String>> 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<ObjectCounter<String>> 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);
+        }
+
+        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;
+        }
+    }
+
+    @Override
+    public void onCanceled(List<ObjectCounter<String>> 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<ObjectCounter<String>> 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.
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbSummaryPagerFragment.java

@@ -0,0 +1,146 @@
+package net.i2p.android.router.netdb;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentStatePagerAdapter;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.Loader;
+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 net.i2p.android.router.I2PFragmentBase;
+import net.i2p.android.router.R;
+import net.i2p.android.router.util.Util;
+import net.i2p.util.ObjectCounter;
+
+import java.util.List;
+
+public class NetDbSummaryPagerFragment extends I2PFragmentBase implements
+        LoaderManager.LoaderCallbacks<List<ObjectCounter<String>>> {
+    private NetDbPagerAdapter mNetDbPagerAdapter;
+    ViewPager mViewPager;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setHasOptionsMenu(true);
+    }
+
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.parentfragment_viewpager, container, false);
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+
+        // Set up NetDbPagerAdapter containing the categories
+        mNetDbPagerAdapter = new NetDbPagerAdapter(getChildFragmentManager());
+
+        // Set up ViewPager for swiping between categories
+        mViewPager = (ViewPager) getActivity().findViewById(R.id.pager);
+        mViewPager.setAdapter(mNetDbPagerAdapter);
+        mViewPager.setOnPageChangeListener(
+                new ViewPager.SimpleOnPageChangeListener() {
+                    @Override
+                    public void onPageSelected(int position) {
+                        mViewPager.setCurrentItem(position);
+                    }
+                });
+    }
+
+    @Override
+    public void onRouterConnectionReady() {
+        getLoaderManager().initLoader(0, null, this);
+    }
+
+    @Override
+    public void onRouterConnectionNotReady() {
+        Util.d("Router not running or not bound to NetDbSummaryPagerFragment");
+    }
+
+    @Override
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        inflater.inflate(R.menu.fragment_netdb_list_actions, menu);
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        // Handle presses on the action bar items
+        switch (item.getItemId()) {
+        case R.id.action_refresh:
+            if (getRouterContext() != null) {
+                Util.d("Refresh called, restarting Loader");
+                mNetDbPagerAdapter.setData(null);
+                mViewPager.invalidate();
+                getLoaderManager().restartLoader(0, null, this);
+            }
+            return true;
+        default:
+            return super.onOptionsItemSelected(item);
+        }
+    }
+
+    public class NetDbPagerAdapter extends FragmentStatePagerAdapter {
+        private List<ObjectCounter<String>> mData;
+
+        public NetDbPagerAdapter(FragmentManager fm) {
+            super(fm);
+        }
+
+        public void setData(List<ObjectCounter<String>> data) {
+            mData = data;
+            notifyDataSetChanged();
+        }
+
+        @Override
+        public Fragment getItem(int i) {
+            if (mData == null)
+                return null;
+
+            return NetDbSummaryTableFragment.newInstance(i, mData.get(i));
+        }
+
+        @Override
+        public int getCount() {
+            if (mData == null)
+                return 0;
+            else
+                return 2;
+        }
+
+        @Override
+        public CharSequence getPageTitle(int i) {
+            switch (i) {
+            case 1:
+            //    return getString(R.string.countries);
+            //case 2:
+                return getString(R.string.settings_label_transports);
+            default:
+                return getString(R.string.versions);
+            } 
+        }
+    }
+
+    // LoaderManager.LoaderCallbacks<List<ObjectCounter<String>>>
+
+    public Loader<List<ObjectCounter<String>>> onCreateLoader(int id, Bundle args) {
+        return new NetDbStatsLoader(getActivity(), getRouterContext());
+    }
+
+    public void onLoadFinished(Loader<List<ObjectCounter<String>>> loader,
+            List<ObjectCounter<String>> data) {
+        mNetDbPagerAdapter.setData(data);
+    }
+
+    public void onLoaderReset(Loader<List<ObjectCounter<String>>> loader) {
+        mNetDbPagerAdapter.setData(null);
+    }
+}

app/src/main/java/net/i2p/android/router/netdb/NetDbSummaryTableFragment.java

@@ -0,0 +1,121 @@
+package net.i2p.android.router.netdb;
+
+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.TableLayout;
+import android.widget.TableRow;
+import android.widget.TextView;
+
+import net.i2p.android.router.R;
+import net.i2p.util.ObjectCounter;
+import net.i2p.util.VersionComparator;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class NetDbSummaryTableFragment extends Fragment {
+    private static final String CATEGORY = "category";
+    private static final String COUNTS = "counts";
+
+    private int mCategory;
+    private ObjectCounter<String> mCounts;
+    private TableLayout mTable;
+
+    public static NetDbSummaryTableFragment newInstance(int category,
+            ObjectCounter<String> counts) {
+        NetDbSummaryTableFragment f = new NetDbSummaryTableFragment();
+        Bundle args = new Bundle();
+        args.putInt(CATEGORY, category);
+        args.putSerializable(COUNTS, counts);
+        f.setArguments(args);
+        return f;
+    }
+
+    @SuppressWarnings("unchecked")
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        View v = inflater.inflate(R.layout.fragment_table, container, false);
+
+        mCategory = getArguments().getInt(CATEGORY);
+        mCounts = (ObjectCounter<String>) getArguments().getSerializable(COUNTS);
+
+        mTable = (TableLayout) v.findViewById(R.id.table);
+
+        List<String> objects = new ArrayList<>(mCounts.objects());
+        if (!objects.isEmpty()) {
+            createTableTitle();
+
+            switch (mCategory) {
+            case 1:
+            //case 2:
+                Collections.sort(objects);
+                break;
+            default:
+                Collections.sort(objects,
+                        Collections.reverseOrder(new VersionComparator()));
+                break;
+            }
+
+            for (String object : objects) {
+                int num = mCounts.count(object);
+                addTableRow(object, ""+num);
+            }
+        }
+
+        return v;
+    }
+
+    private void createTableTitle() {
+        TableRow titleRow;
+        TextView tl1, tl2;
+
+        titleRow = new TableRow(getActivity());
+        titleRow.setPadding(10, 0, 0, 0);
+
+        tl1 = new TextView(getActivity());
+        tl1.setTextSize(20);
+        tl2 = new TextView(getActivity());
+        tl2.setTextSize(20);
+
+        switch (mCategory) {
+        case 1:
+        //    tl1.setText(R.string.country);
+        //    break;
+        //case 2:
+            tl1.setText(R.string.transport);
+            break;
+        default:
+            tl1.setText(R.string.version);
+            break;
+        }
+        tl2.setText(R.string.count);
+
+        titleRow.addView(tl1);
+        titleRow.addView(tl2);
+
+        mTable.addView(titleRow);
+    }
+
+    private void addTableRow(String name, String count) {
+        TableRow row;
+        TextView tl1, tl2;
+
+        row = new TableRow(getActivity());
+        row.setPadding(10, 0, 0, 0);
+
+        tl1 = new TextView(getActivity());
+        tl2 = new TextView(getActivity());
+
+        tl1.setText(name);
+        tl2.setText(count);
+
+        row.addView(tl1);
+        row.addView(tl2);
+
+        mTable.addView(row);
+    }
+}

app/src/main/java/net/i2p/android/router/provider/CacheProvider.java

@@ -6,6 +6,12 @@ import android.content.SharedPreferences;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.ParcelFileDescriptor;
+
+import net.i2p.android.apps.EepGetFetcher;
+import net.i2p.android.router.BuildConfig;
+import net.i2p.android.router.util.AppCache;
+import net.i2p.android.router.util.Util;
+
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -13,9 +19,6 @@ import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
-import net.i2p.android.apps.EepGetFetcher;
-import net.i2p.android.router.util.AppCache;
-import net.i2p.android.router.util.Util;
 
 /**
  *  Usage:  content://net.i2p.android.router/NONCE/ENCODED-SCHEME/ENCODED-AUTHORITY/ENCODED_PATH + QUERY_MARKER + ENCODED-QUERY
@@ -45,7 +48,7 @@ public class CacheProvider extends ContentProvider {
     //private static final String NONCE = Integer.toString(Math.abs((new java.util.Random()).nextInt()));
     private static final String NONCE = "0";
     private static final String SCHEME = "content";
-    public static final String AUTHORITY = "net.i2p.android.router";
+    public static final String AUTHORITY = BuildConfig.APPLICATION_ID + ".provider";
     /** includes the nonce */
     public static final Uri CONTENT_URI = Uri.parse(SCHEME + "://" + AUTHORITY + '/' + NONCE);
 
@@ -140,7 +143,7 @@ public class CacheProvider extends ContentProvider {
      *
      *  @param uri must contain a scheme, authority and path with nonce etc. as defined above
      *  @return non-null
-     *  @throws FNFE on error
+     *  @throws java.io.FileNotFoundException on error
      */
     public static Uri getI2PUri(Uri uri) throws FileNotFoundException {
         String resPath = uri.getEncodedPath();
@@ -242,8 +245,7 @@ public class CacheProvider extends ContentProvider {
             if (file.length() > 0) {
                 // this call will insert it back to us (don't set as current base)
                 Uri content = cache.addCacheFile(uri, false);
-                ParcelFileDescriptor parcel = ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
+                return ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY);
-                return parcel;
             } else {
                  Util.d("CacheProvider Sucess but no data " + uri);
             }
@@ -275,7 +277,7 @@ public class CacheProvider extends ContentProvider {
             put(uri, fileURI);
         }
         Boolean setAsCurrentBase = values.getAsBoolean(CURRENT_BASE);
-        if (setAsCurrentBase != null && setAsCurrentBase.booleanValue()) {
+        if (setAsCurrentBase != null && setAsCurrentBase) {
             Util.d("CacheProvider set current base " + uri);
             setCurrentBase(uri);
         }
@@ -302,7 +304,7 @@ public class CacheProvider extends ContentProvider {
 
     private void cleanup() {
         String pfx = CONTENT_URI.toString();
-        List<String> toDelete = new ArrayList<String>();
+        List<String> toDelete = new ArrayList<>();
         Map<String, ?> map = _sharedPrefs.getAll();
         for (Map.Entry<String, ?> e : map.entrySet()) {
             String path = (String) e.getValue();

app/src/main/java/net/i2p/android/router/receiver/I2PReceiver.java

@@ -9,8 +9,9 @@ import android.content.ServiceConnection;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.os.IBinder;
-import net.i2p.android.router.binder.RouterBinder;
+import net.i2p.android.router.service.RouterBinder;
 import net.i2p.android.router.service.RouterService;
+import net.i2p.android.router.util.Connectivity;
 import net.i2p.android.router.util.Util;
 
 public class I2PReceiver extends BroadcastReceiver {
@@ -33,7 +34,7 @@ public class I2PReceiver extends BroadcastReceiver {
         intents.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
         @SuppressWarnings("LeakingThisInConstructor")
         Intent registerReceiver = context.registerReceiver(this, intents);
-        _wasConnected = Util.isConnected(context);
+        _wasConnected = Connectivity.isConnected(context);
     }
 
     public void onReceive(Context context, Intent intent) {
@@ -57,7 +58,7 @@ public class I2PReceiver extends BroadcastReceiver {
 
         if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION) ||
             action.equals(Intent.ACTION_TIME_TICK)) {
-            boolean connected = Util.isConnected(context);
+            boolean connected = Connectivity.isConnected(context);
             if (_wasConnected && !connected) {
                 // notify + 2 timer ticks
                 if (++_unconnectedCount >= 3) {

app/src/main/java/net/i2p/android/router/receiver/OnBootReceiver.java

@@ -0,0 +1,25 @@
+package net.i2p.android.router.receiver;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+
+import net.i2p.android.router.I2PConstants;
+import net.i2p.android.router.service.RouterService;
+
+public class OnBootReceiver extends BroadcastReceiver implements I2PConstants {
+    public static final String PREF_START_ON_BOOT = ANDROID_PREF_PREFIX + "startOnBoot";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+        boolean startOnBoot = prefs.getBoolean(PREF_START_ON_BOOT, false);
+
+        if (startOnBoot) {
+            Intent routerService = new Intent(context, RouterService.class);
+            context.startService(routerService);
+        }
+    }
+}

app/src/main/java/net/i2p/android/router/service/Init.java

@@ -1,20 +1,18 @@
 package net.i2p.android.router.service;
 
 import android.content.Context;
-import java.io.File;
+
 import net.i2p.android.router.util.Util;
 import net.i2p.util.FileUtil;
 
+import java.io.File;
+
 class Init {
 
-    private final Context ctx;
     private final String myDir;
-    private final String _ourVersion;
 
     public Init(Context c) {
-        ctx = c;
         myDir = c.getFilesDir().getAbsolutePath();
-        _ourVersion = Util.getOurVersion(c);
     }
 
     void initialize() {
@@ -32,9 +30,8 @@ class Init {
         File tmp = new File(myDir, "tmp");
         File[] files = tmp.listFiles();
         if (files != null) {
-            for (int i = 0; i < files.length; i++) {
+            for (File f : files) {
-                File f = files[i];
+                Util.d("Deleting old file/dir " + f);
-                Util.i("Deleting old file/dir " + f);
                 FileUtil.rmdir(f, false);
             }
         }

app/src/main/java/net/i2p/android/router/service/LoadClientsJob.java

@@ -1,8 +1,12 @@
 package net.i2p.android.router.service;
 
+import android.content.Context;
+
 import net.i2p.BOB.BOB;
+import net.i2p.I2PAppContext;
 import net.i2p.addressbook.DaemonThread;
 import net.i2p.android.apps.NewsFetcher;
+import net.i2p.android.router.util.Notifications;
 import net.i2p.android.router.util.Util;
 import net.i2p.i2ptunnel.TunnelControllerGroup;
 import net.i2p.router.Job;
@@ -10,6 +14,8 @@ import net.i2p.router.JobImpl;
 import net.i2p.router.RouterContext;
 import net.i2p.util.I2PAppThread;
 
+import java.io.IOException;
+
 /**
  * Load the clients we want.
  *
@@ -31,28 +37,35 @@ import net.i2p.util.I2PAppThread;
  */
 class LoadClientsJob extends JobImpl {
 
-    private Thread _fetcherThread;
+    private Context mCtx;
+    private Notifications _notif;
     private DaemonThread _addressbook;
-    private Thread _BOB;
+    private BOB _bob;
 
     /** this is the delay to load (and start) the clients. */
     private static final long LOAD_DELAY = 90*1000;
 
 
-    public LoadClientsJob(RouterContext ctx) {
+    public LoadClientsJob(Context ctx, RouterContext rCtx, Notifications notif) {
-        super(ctx);
+        super(rCtx);
+        mCtx = ctx;
+        _notif = notif;
         getTiming().setStartAfter(getContext().clock().now() + LOAD_DELAY);
     }
 
-    public String getName() { return "Start Clients"; };
+    public String getName() { return "Start Clients"; }
 
     public void runJob() {
         Job j = new RunI2PTunnel(getContext());
         getContext().jobQueue().addJob(j);
 
-        NewsFetcher fetcher = NewsFetcher.getInstance(getContext());
+        Thread t = new I2PAppThread(new StatSummarizer(), "StatSummarizer", true);
-        _fetcherThread = new I2PAppThread(fetcher, "NewsFetcher", true);
+        t.setPriority(Thread.NORM_PRIORITY - 1);
-        _fetcherThread.start();
+        t.start();
+
+        NewsFetcher fetcher = NewsFetcher.getInstance(mCtx, getContext(), _notif);
+        t = new I2PAppThread(fetcher, "NewsFetcher", true);
+        t.start();
 
         _addressbook = new DaemonThread(new String[] {"addressbook"});
         _addressbook.setName("Addressbook");
@@ -60,19 +73,12 @@ class LoadClientsJob extends JobImpl {
         _addressbook.start();
 
         // add other clients here
-        Run_BOB bob = new Run_BOB();
+        _bob = new BOB(I2PAppContext.getGlobalContext(), null, new String[0]);
-        _BOB = new I2PAppThread(bob, "BOB", true);
+        try {
-        _BOB.start();
+            _bob.startup();
-        getContext().addShutdownTask(new ClientShutdownHook());
+        } catch (IOException ioe) {}
-    }
 
-    private class Run_BOB implements Runnable {
+        getContext().addShutdownTask(new ClientShutdownHook());
-        public void run() {
-            Util.i("BOB starting...");
-            BOB.main(null);
-            Util.i("BOB Stopped.");
-            _BOB = null;
-        }
     }
 
     private class RunI2PTunnel extends JobImpl {
@@ -81,25 +87,30 @@ class LoadClientsJob extends JobImpl {
             super(ctx);
         }
 
-        public String getName() { return "Start I2P Tunnel"; };
+        public String getName() { return "Start I2P Tunnel"; }
 
         public void runJob() {
-            Util.i("Starting i2ptunnel");
+            Util.d("Starting i2ptunnel");
             TunnelControllerGroup tcg = TunnelControllerGroup.getInstance();
-            int sz = tcg.getControllers().size();
+            try {
-            Util.i("i2ptunnel started " + sz + " clients");
+                tcg.startup();
+                int sz = tcg.getControllers().size();
+                Util.d("i2ptunnel started " + sz + " clients");
+            } catch (IllegalArgumentException iae) {
+                Util.e("i2ptunnel failed to start", iae);
+            }
 
         }
     }
 
     private class ClientShutdownHook implements Runnable {
         public void run() {
-            Util.i("client shutdown hook");
+            Util.d("client shutdown hook");
             // i2ptunnel registers its own hook
-            if (_BOB != null)
+            // StatSummarizer registers its own hook
-                BOB.stop();
+            // NewsFetcher registers its own hook
-            if (_fetcherThread != null)
+            if (_bob != null)
-                _fetcherThread.interrupt();
+                _bob.shutdown(null);
             if (_addressbook != null)
                 _addressbook.halt();
         }

app/src/main/java/net/i2p/android/router/service/RouterBinder.java

@@ -1,7 +1,6 @@
-package net.i2p.android.router.binder;
+package net.i2p.android.router.service;
 
 import android.os.Binder;
-import net.i2p.android.router.service.RouterService;
 
 public class RouterBinder extends Binder {
 

app/src/main/java/net/i2p/android/router/service/RouterService.java

@@ -1,51 +1,67 @@
 package net.i2p.android.router.service;
 
 import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
 import android.content.Intent;
+import android.content.IntentFilter;
 import android.content.SharedPreferences;
 import android.os.Handler;
 import android.os.IBinder;
-import java.io.File;
+import android.os.Message;
-import java.io.FileInputStream;
+import android.os.RemoteCallbackList;
-import java.io.IOException;
+import android.os.RemoteException;
-import java.io.InputStream;
+import android.support.v4.content.LocalBroadcastManager;
-import java.text.DecimalFormat;
+
-import java.util.List;
+import net.i2p.android.router.R;
-import java.util.Properties;
-import java.util.Random;
-import net.i2p.android.router.binder.RouterBinder;
 import net.i2p.android.router.receiver.I2PReceiver;
+import net.i2p.android.router.util.Connectivity;
+import net.i2p.android.router.util.Notifications;
 import net.i2p.android.router.util.Util;
+import net.i2p.android.util.LocaleManager;
 import net.i2p.data.DataHelper;
 import net.i2p.router.Job;
 import net.i2p.router.Router;
 import net.i2p.router.RouterContext;
 import net.i2p.router.RouterLaunch;
-import net.i2p.util.OrderedProperties;
+
+import java.lang.ref.WeakReference;
+import java.text.DecimalFormat;
 
 /**
  * Runs the router
  */
 public class RouterService extends Service {
 
-    // These states persist even if we died... Yuck, it causes issues.
+    /**
-    public enum State {
+     * A request to this service for the current router state. Broadcasting
-        INIT, WAITING, STARTING, RUNNING,
+     * this will trigger a state notification.
-        // unplanned (router stopped itself), next: killSelf()
+     */
-        STOPPING, STOPPED,
+    public static final String LOCAL_BROADCAST_REQUEST_STATE = "net.i2p.android.LOCAL_BROADCAST_REQUEST_STATE";
-        // button, don't kill service when stopped, stay in MANUAL_STOPPED
+    /**
-        MANUAL_STOPPING, MANUAL_STOPPED,
+     * A notification of the current state. This is informational; the state
-        // button, DO kill service when stopped, next: killSelf()
+     * has not changed.
-        MANUAL_QUITTING, MANUAL_QUITTED,
+     */
-        // Stopped by listener (no network), next: WAITING (spin waiting for network)
+    public static final String LOCAL_BROADCAST_STATE_NOTIFICATION = "net.i2p.android.LOCAL_BROADCAST_STATE_NOTIFICATION";
-        NETWORK_STOPPING, NETWORK_STOPPED
+    /**
-    }
+     * The state has just changed.
+     */
+    public static final String LOCAL_BROADCAST_STATE_CHANGED = "net.i2p.android.LOCAL_BROADCAST_STATE_CHANGED";
+    public static final String LOCAL_BROADCAST_EXTRA_STATE = "net.i2p.android.STATE";
+    /**
+     * The locale has just changed.
+     */
+    public static final String LOCAL_BROADCAST_LOCALE_CHANGED = "net.i2p.android.LOCAL_BROADCAST_LOCALE_CHANGED";
+
+    private LocaleManager localeManager = new LocaleManager();
+
     private RouterContext _context;
     private String _myDir;
     //private String _apkPath;
     private State _state = State.INIT;
     private Thread _starterThread;
     private StatusBar _statusBar;
+    private Notifications _notif;
     private I2PReceiver _receiver;
     private IBinder _binder;
     private final Object _stateLock = new Object();
@@ -56,11 +72,19 @@ public class RouterService extends Service {
     private static final String EXTRA_RESTART = "restart";
     private static final String MARKER = "**************************************  ";
 
+    /**
+     * This is a list of callbacks that have been registered with the
+     * service.  Note that this is package scoped (instead of private) so
+     * that it can be accessed more efficiently from inner classes.
+     */
+    final RemoteCallbackList<IRouterStateCallback> mStateCallbacks
+            = new RemoteCallbackList<>();
+
     @Override
     public void onCreate() {
         State lastState = getSavedState();
         setState(State.INIT);
-        Util.i(this + " onCreate called"
+        Util.d(this + " onCreate called"
                 + " Saved state is: " + lastState
                 + " Current state is: " + _state);
 
@@ -73,14 +97,18 @@ public class RouterService extends Service {
         _statusBar = new StatusBar(this);
         // Remove stale notification icon.
         _statusBar.remove();
+        _notif = new Notifications(this);
         _binder = new RouterBinder(this);
         _handler = new Handler();
         _updater = new Updater();
-        if(lastState == State.RUNNING) {
+        LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(this);
+        lbm.registerReceiver(onStateRequested, new IntentFilter(LOCAL_BROADCAST_REQUEST_STATE));
+        lbm.registerReceiver(onLocaleChanged, new IntentFilter(LOCAL_BROADCAST_LOCALE_CHANGED));
+        if(lastState == State.RUNNING || lastState == State.ACTIVE) {
             Intent intent = new Intent(this, RouterService.class);
             intent.putExtra(EXTRA_RESTART, true);
             onStartCommand(intent, 12345, 67890);
-        } else if(lastState == State.MANUAL_QUITTING) {
+        } else if(lastState == State.MANUAL_QUITTING || lastState == State.GRACEFUL_SHUTDOWN) {
             synchronized(_stateLock) {
                 setState(State.MANUAL_QUITTED);
                 stopSelf(); // Die.
@@ -88,19 +116,36 @@ public class RouterService extends Service {
         }
     }
 
+    private BroadcastReceiver onStateRequested = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            // Broadcast the current state within this app.
+            Intent ni = new Intent(LOCAL_BROADCAST_STATE_NOTIFICATION);
+            ni.putExtra(LOCAL_BROADCAST_EXTRA_STATE, (android.os.Parcelable) _state);
+            LocalBroadcastManager.getInstance(RouterService.this).sendBroadcast(ni);
+        }
+    };
+
+    private BroadcastReceiver onLocaleChanged = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            localeManager.updateServiceLocale(RouterService.this);
+        }
+    };
+
     /**
      * NOT called by system if it restarts us after a crash
      */
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
-        Util.i(this + " onStart called"
+        Util.d(this + " onStart called"
                 + " Intent is: " + intent
                 + " Flags is: " + flags
                 + " ID is: " + startId
                 + " Current state is: " + _state);
         boolean restart = intent != null && intent.getBooleanExtra(EXTRA_RESTART, false);
         if(restart) {
-            Util.i(this + " RESTARTING");
+            Util.d(this + " RESTARTING");
         }
         synchronized(_stateLock) {
             if(_state != State.INIT) //return START_STICKY;
@@ -108,17 +153,17 @@ public class RouterService extends Service {
                 return START_NOT_STICKY;
             }
             _receiver = new I2PReceiver(this);
-            if(Util.isConnected(this)) {
+            if(Connectivity.isConnected(this)) {
                 if(restart) {
-                    _statusBar.replace(StatusBar.ICON1, "I2P is restarting");
+                    _statusBar.replace(StatusBar.ICON_STARTING, R.string.notification_status_restarting);
                 } else {
-                    _statusBar.replace(StatusBar.ICON1, "I2P is starting up");
+                    _statusBar.replace(StatusBar.ICON_STARTING, R.string.notification_status_starting);
                 }
                 setState(State.STARTING);
                 _starterThread = new Thread(new Starter());
                 _starterThread.start();
             } else {
-                _statusBar.replace(StatusBar.ICON6, "I2P is waiting for a network connection");
+                _statusBar.replace(StatusBar.ICON_WAITING_NETWORK, R.string.notification_status_waiting);
                 setState(State.WAITING);
                 _handler.postDelayed(new Waiter(), 10 * 1000);
             }
@@ -139,15 +184,15 @@ public class RouterService extends Service {
     private class Waiter implements Runnable {
 
         public void run() {
-            Util.i(MARKER + this + " waiter handler"
+            Util.d(MARKER + this + " waiter handler"
                     + " Current state is: " + _state);
             if(_state == State.WAITING) {
-                if(Util.isConnected(RouterService.this)) {
+                if(Connectivity.isConnected(RouterService.this)) {
                     synchronized(_stateLock) {
                         if(_state != State.WAITING) {
                             return;
                         }
-                        _statusBar.replace(StatusBar.ICON1, "Network connected, I2P is starting up");
+                        _statusBar.replace(StatusBar.ICON_STARTING, R.string.notification_status_starting_after_waiting);
                         setState(State.STARTING);
                         _starterThread = new Thread(new Starter());
                         _starterThread.start();
@@ -162,173 +207,32 @@ public class RouterService extends Service {
     private class Starter implements Runnable {
 
         public void run() {
-            Util.i(MARKER + this + " starter thread"
+            Util.d(MARKER + this + " starter thread"
                     + " Current state is: " + _state);
-            //Util.i(MARKER + this + " JBigI speed test started");
+            //Util.d(MARKER + this + " JBigI speed test started");
             //NativeBigInteger.main(null);
-            //Util.i(MARKER + this + " JBigI speed test finished, launching router");
+            //Util.d(MARKER + this + " JBigI speed test finished, launching router");
 
-
+            // Launch the router!
-            // Before we launch, fix up any settings that need to be fixed here.
-            // This should be done in the core, but as of this writing it isn't!
-
-            // Step one. Load the propertites.
-            Properties props = new OrderedProperties();
-            Properties oldprops = new OrderedProperties();
-            String wrapName = _myDir + "/router.config";
-            try {
-                InputStream fin = new FileInputStream(new File(wrapName));
-                DataHelper.loadProps(props, fin);
-            } catch(IOException ioe) {
-                // shouldn't happen...
-            }
-            oldprops.putAll(props);
-            // Step two, check for any port settings, and copy for those that are missing.
-            int UDPinbound;
-            int UDPinlocal;
-            int TCPinbound;
-            int TCPinlocal;
-            UDPinbound = Integer.parseInt(props.getProperty("i2np.udp.port", "-1"));
-            UDPinlocal = Integer.parseInt(props.getProperty("i2np.udp.internalPort", "-1"));
-            TCPinbound = Integer.parseInt(props.getProperty("i2np.ntcp.port", "-1"));
-            TCPinlocal = Integer.parseInt(props.getProperty("i2np.ntcp.internalPort", "-1"));
-            boolean hasUDPinbound = UDPinbound != -1;
-            boolean hasUDPinlocal = UDPinlocal != -1;
-            boolean hasTCPinbound = TCPinbound != -1;
-            boolean hasTCPinlocal = TCPinlocal != -1;
-
-            // check and clear values based on these:
-            boolean udp = Boolean.parseBoolean(props.getProperty("i2np.udp.enable", "false"));
-            boolean tcp = Boolean.parseBoolean(props.getProperty("i2np.ntcp.enable", "false"));
-
-            // Fix if both are false.
-            if(!(udp || tcp)) {
-                // If both are not on, turn them both on.
-                props.setProperty("i2np.udp.enable", "true");
-                props.setProperty("i2np.ntcp.enable", "true");
-            }
-
-            // Fix if we have local but no inbound
-            if(!hasUDPinbound && hasUDPinlocal) {
-                // if we got a local port and no external port, set it
-                hasUDPinbound = true;
-                UDPinbound = UDPinlocal;
-            }
-            if(!hasTCPinbound && hasTCPinlocal) {
-                // if we got a local port and no external port, set it
-                hasTCPinbound = true;
-                TCPinbound = TCPinlocal;
-            }
-
-            boolean anyUDP = hasUDPinbound || hasUDPinlocal;
-            boolean anyTCP = hasTCPinbound || hasTCPinlocal;
-            boolean anyport = anyUDP || anyTCP;
-
-            if(!anyport) {
-                // generate one for UDPinbound, and fall thru.
-                // FIX ME: Possibly not the best but should be OK.
-                Random generator = new Random(System.currentTimeMillis());
-                UDPinbound = generator.nextInt(55500) + 10000;
-                anyUDP = true;
-            }
-
-            // Copy missing port numbers
-            if(anyUDP && !anyTCP) {
-                TCPinbound = UDPinbound;
-                TCPinlocal = UDPinlocal;
-            }
-            if(anyTCP && !anyUDP) {
-                UDPinbound = TCPinbound;
-                UDPinlocal = TCPinlocal;
-            }
-            // reset for a retest.
-            hasUDPinbound = UDPinbound != -1;
-            hasUDPinlocal = UDPinlocal != -1;
-            hasTCPinbound = TCPinbound != -1;
-            hasTCPinlocal = TCPinlocal != -1;
-            anyUDP = hasUDPinbound || hasUDPinlocal;
-            anyTCP = hasTCPinbound || hasTCPinlocal;
-            boolean checkAnyUDP = anyUDP && udp;
-            boolean checkAnyTCP = anyTCP && tcp;
-
-            // Enable things that need to be enabled.
-            // Disable anything that needs to be disabled.
-            if(!checkAnyUDP && !checkAnyTCP) {
-                // enable the one(s) with values.
-                if(anyUDP) {
-                    udp = true;
-                }
-                if(anyTCP) {
-                    tcp = true;
-                }
-            }
-
-            if(!udp) {
-                props.setProperty("i2np.udp.enable", "false");
-                props.remove("i2np.udp.port");
-                props.remove("i2np.udp.internalPort");
-            } else {
-                props.setProperty("i2np.udp.enable", "true");
-                if(hasUDPinbound) {
-                    props.setProperty("i2np.udp.port", Integer.toString(UDPinbound));
-                } else {
-                    props.remove("i2np.udp.port");
-                }
-                if(hasUDPinlocal) {
-                    props.setProperty("i2np.udp.internalPort", Integer.toString(UDPinlocal));
-                } else {
-                    props.remove("i2np.udp.internalPort");
-                }
-            }
-
-            if(!tcp) {
-                props.setProperty("i2np.ntcp.enable", "false");
-                props.remove("i2np.ntcp.port");
-                props.remove("i2np.ntcp.internalPort");
-            } else {
-                props.setProperty("i2np.ntcp.enable", "true");
-                if(hasTCPinbound) {
-                    props.setProperty("i2np.ntcp.port", Integer.toString(TCPinbound));
-                } else {
-                    props.remove("i2np.ntcp.port");
-                }
-                if(hasTCPinlocal) {
-                    props.setProperty("i2np.ntcp.internalPort", Integer.toString(TCPinlocal));
-                } else {
-                    props.remove("i2np.ntcp.internalPort");
-                }
-            }
-            // WHEW! Now test for any changes.
-            if(!props.equals(oldprops)) {
-                // save fixed properties.
-                try {
-                    DataHelper.storeProps(props, new File(wrapName));
-                } catch(IOException ioe) {
-                    // shouldn't happen...
-                }
-            }
-
-            // _NOW_ launch the router!
             RouterLaunch.main(null);
             synchronized(_stateLock) {
                 if(_state != State.STARTING) {
                     return;
                 }
                 setState(State.RUNNING);
-                List<?> contexts = RouterContext.listContexts();
+                _statusBar.replace(StatusBar.ICON_RUNNING, R.string.notification_status_running);
-                if((contexts == null) || (contexts.isEmpty())) {
+                _context = Util.getRouterContext();
+                if (_context == null) {
                     throw new IllegalStateException("No contexts. This is usually because the router is either starting up or shutting down.");
                 }
-                _statusBar.replace(StatusBar.ICON2, "I2P is running");
-                _context = (RouterContext) contexts.get(0);
                 _context.router().setKillVMOnEnd(false);
-                Job loadJob = new LoadClientsJob(_context);
+                Job loadJob = new LoadClientsJob(RouterService.this, _context, _notif);
                 _context.jobQueue().addJob(loadJob);
                 _context.addShutdownTask(new ShutdownHook());
                 _context.addFinalShutdownTask(new FinalShutdownHook());
                 _starterThread = null;
             }
-            Util.i("Router.main finished");
+            Util.d("Router.main finished");
         }
     }
 
@@ -336,7 +240,7 @@ public class RouterService extends Service {
 
         public void run() {
             RouterContext ctx = _context;
-            if(ctx != null && _state == State.RUNNING) {
+            if(ctx != null && (_state == State.RUNNING || _state == State.ACTIVE || _state == State.GRACEFUL_SHUTDOWN)) {
                 Router router = ctx.router();
                 if(router.isAlive()) {
                     updateStatus(ctx);
@@ -345,6 +249,7 @@ public class RouterService extends Service {
             _handler.postDelayed(this, 15 * 1000);
         }
     }
+    private String _currTitle;
     private boolean _hadTunnels;
 
     private void updateStatus(RouterContext ctx) {
@@ -367,34 +272,92 @@ public class RouterService extends Service {
             fmt = new DecimalFormat("#0.00");
         }
 
-        String status =
+        String text =
-                "I2P "
+                getResources().getString(R.string.notification_status_text,
-                + active + '/' + known + " peers connected";
+                        Util.formatSize(inBW), Util.formatSize(outBW));
 
-        String details =
+        // TODO change string resource after 0.9.20 to use Util.formatSize()
-                fmt.format(inBW) + '/' + fmt.format(outBW) + " KBps"
+        String bigText =
-                + "; Expl " + inEx + '/' + outEx
+                getResources().getString(R.string.notification_status_bw,
-                + "; Client " + inCl + '/' + outCl;
+                        fmt.format(inBW), fmt.format(outBW)) + '\n'
+                + getResources().getString(R.string.notification_status_peers,
+                        active, known) + '\n'
+                + getResources().getString(R.string.notification_status_expl,
+                        inEx, outEx) + '\n'
+                + getResources().getString(R.string.notification_status_client,
+                        inCl, outCl);
 
         boolean haveTunnels = inCl > 0 && outCl > 0;
-        if(haveTunnels != _hadTunnels) {
+        if (isGracefulShutdownInProgress()) {
-            if(haveTunnels) {
+            long ms = ctx.router().getShutdownTimeRemaining();
-                _statusBar.replace(StatusBar.ICON3, "Client tunnels are ready");
+            if (ms > 1000) {
+                _currTitle = getString(R.string.notification_status_graceful, DataHelper.formatDuration(ms));
             } else {
-                _statusBar.replace(StatusBar.ICON2, "Client tunnels are down");
+                _currTitle = getString(R.string.notification_status_stopping);
+            }
+        } else if (haveTunnels != _hadTunnels) {
+            if(haveTunnels) {
+                _currTitle = getString(R.string.notification_status_client_ready);
+                setState(State.ACTIVE);
+                _statusBar.replace(StatusBar.ICON_ACTIVE, _currTitle);
+            } else {
+                _currTitle = getString(R.string.notification_status_client_down);
+                setState(State.RUNNING);
+                _statusBar.replace(StatusBar.ICON_RUNNING, _currTitle);
             }
             _hadTunnels = haveTunnels;
-        }
+        } else if (_currTitle == null || _currTitle.equals(""))
-        _statusBar.update(status, details);
+            _currTitle = getString(R.string.notification_status_running);
+        _statusBar.update(_currTitle, text, bigText);
     }
 
     @Override
     public IBinder onBind(Intent intent) {
-        Util.i(this + "onBind called"
+        Util.d(this + "onBind called"
                 + " Current state is: " + _state);
-        return _binder;
+        Util.d("Intent action: " + intent.getAction());
+        // Select the interface to return.
+        if (RouterBinder.class.getName().equals(intent.getAction())) {
+            // Local Activity wanting access to the RouterContext
+            Util.d("Returning RouterContext binder");
+            return _binder;
+        }
+        if (IRouterState.class.getName().equals(intent.getAction())) {
+            // Someone wants to monitor the router state.
+            Util.d("Returning state binder");
+            return mStatusBinder;
+        }
+        Util.d("Unknown binder request, returning null");
+        return null;
     }
 
+    /**
+     * IRouterState is defined through IDL
+     */
+    private final IRouterState.Stub mStatusBinder = new IRouterState.Stub() {
+
+        public void registerCallback(IRouterStateCallback cb)
+                throws RemoteException {
+            if (cb != null) mStateCallbacks.register(cb);
+        }
+
+        public void unregisterCallback(IRouterStateCallback cb)
+                throws RemoteException {
+            if (cb != null) mStateCallbacks.unregister(cb);
+        }
+
+        public boolean isStarted() throws RemoteException {
+            return _state != State.INIT &&
+                    _state != State.STOPPED &&
+                    _state != State.MANUAL_STOPPED &&
+                    _state != State.MANUAL_QUITTED;
+        }
+
+        public State getState() throws RemoteException {
+            return _state;
+        }
+    };
+
     @Override
     public boolean onUnbind(Intent intent) {
         return super.onUnbind(intent);
@@ -402,7 +365,7 @@ public class RouterService extends Service {
 
     // ******** following methods may be accessed from Activities and Receivers ************
     /**
-     * @returns null if router is not running
+     * @return null if router is not running
      */
     public RouterContext getRouterContext() {
         RouterContext rv = _context;
@@ -413,10 +376,12 @@ public class RouterService extends Service {
             return null;
         }
         if(_state != State.RUNNING
+                && _state != State.ACTIVE
                 && _state != State.STOPPING
                 && _state != State.MANUAL_STOPPING
                 && _state != State.MANUAL_QUITTING
-                && _state != State.NETWORK_STOPPING) {
+                && _state != State.NETWORK_STOPPING
+                && _state != State.GRACEFUL_SHUTDOWN) {
             return null;
         }
         return rv;
@@ -430,14 +395,18 @@ public class RouterService extends Service {
     }
 
     public boolean canManualStop() {
-        return _state == State.WAITING || _state == State.STARTING || _state == State.RUNNING;
+        return _state == State.WAITING ||
+               _state == State.RUNNING || _state == State.ACTIVE ||
+               _state == State.GRACEFUL_SHUTDOWN;
     }
 
     /**
      * Stop and don't restart the router, but keep the service
+     *
+     * Apparently unused - see manualQuit()
      */
     public void manualStop() {
-        Util.i("manualStop called"
+        Util.d("manualStop called"
                 + " Current state is: " + _state);
         synchronized(_stateLock) {
             if(!canManualStop()) {
@@ -446,8 +415,9 @@ public class RouterService extends Service {
             if(_state == State.STARTING) {
                 _starterThread.interrupt();
             }
-            if(_state == State.STARTING || _state == State.RUNNING) {
+            if(_state == State.STARTING || _state == State.RUNNING ||
-                _statusBar.replace(StatusBar.ICON4, "Stopping I2P");
+               _state == State.ACTIVE || _state == State.GRACEFUL_SHUTDOWN) {
+                _statusBar.replace(StatusBar.ICON_STOPPING, R.string.notification_status_stopping);
                 Thread stopperThread = new Thread(new Stopper(State.MANUAL_STOPPING, State.MANUAL_STOPPED));
                 stopperThread.start();
             }
@@ -458,7 +428,7 @@ public class RouterService extends Service {
      * Stop the router and kill the service
      */
     public void manualQuit() {
-        Util.i("manualQuit called"
+        Util.d("manualQuit called"
                 + " Current state is: " + _state);
         synchronized(_stateLock) {
             if(!canManualStop()) {
@@ -467,8 +437,9 @@ public class RouterService extends Service {
             if(_state == State.STARTING) {
                 _starterThread.interrupt();
             }
-            if(_state == State.STARTING || _state == State.RUNNING) {
+            if(_state == State.STARTING || _state == State.RUNNING ||
-                _statusBar.replace(StatusBar.ICON4, "Stopping I2P");
+               _state == State.ACTIVE || _state == State.GRACEFUL_SHUTDOWN) {
+                _statusBar.replace(StatusBar.ICON_STOPPING, R.string.notification_status_stopping);
                 Thread stopperThread = new Thread(new Stopper(State.MANUAL_QUITTING, State.MANUAL_QUITTED));
                 stopperThread.start();
             } else if(_state == State.WAITING) {
@@ -482,14 +453,15 @@ public class RouterService extends Service {
      * Stop and then spin waiting for a network connection, then restart
      */
     public void networkStop() {
-        Util.i("networkStop called"
+        Util.d("networkStop called"
                 + " Current state is: " + _state);
         synchronized(_stateLock) {
             if(_state == State.STARTING) {
                 _starterThread.interrupt();
             }
-            if(_state == State.STARTING || _state == State.RUNNING) {
+            if(_state == State.STARTING || _state == State.RUNNING ||
-                _statusBar.replace(StatusBar.ICON4, "Network disconnected, stopping I2P");
+               _state == State.ACTIVE || _state == State.GRACEFUL_SHUTDOWN) {
+                _statusBar.replace(StatusBar.ICON_STOPPING, R.string.notification_status_stopping_after_net);
                 // don't change state, let the shutdown hook do it
                 Thread stopperThread = new Thread(new Stopper(State.NETWORK_STOPPING, State.NETWORK_STOPPING));
                 stopperThread.start();
@@ -503,32 +475,160 @@ public class RouterService extends Service {
     }
 
     public void manualStart() {
-        Util.i("restart called"
+        Util.d("restart called"
                 + " Current state is: " + _state);
         synchronized(_stateLock) {
             if(!canManualStart()) {
                 return;
             }
-            _statusBar.replace(StatusBar.ICON1, "I2P is starting up");
+            _statusBar.replace(StatusBar.ICON_STARTING, R.string.notification_status_starting);
             setState(State.STARTING);
             _starterThread = new Thread(new Starter());
             _starterThread.start();
         }
     }
 
+    /**
+     * Graceful Shutdown
+     *
+     * @since 0.9.19
+     */
+    public boolean isGracefulShutdownInProgress() {
+        if (_state == State.GRACEFUL_SHUTDOWN) {
+            RouterContext ctx = _context;
+            return ctx != null && ctx.router().gracefulShutdownInProgress();
+        }
+        return false;
+    }
+
+    private String _oldTitle;
+    /**
+     * Graceful Shutdown
+     *
+     * @since 0.9.19
+     */
+    public void gracefulShutdown() {
+        Util.d("gracefulShutdown called"
+                + " Current state is: " + _state);
+        synchronized(_stateLock) {
+            if(!canManualStop()) {
+                return;
+            }
+            if(_state == State.STARTING || _state == State.WAITING) {
+                manualQuit();
+                return;
+            }
+            if(_state == State.RUNNING || _state == State.ACTIVE) {
+                RouterContext ctx = _context;
+                if(ctx != null && ctx.router().isAlive()) {
+                    int part = ctx.tunnelManager().getParticipatingCount();
+                    if(part <= 0) {
+                        manualQuit();
+                    } else {
+                        ctx.router().shutdownGracefully();
+                        _oldTitle = _currTitle;
+                        long ms = ctx.router().getShutdownTimeRemaining();
+                        if (ms > 1000) {
+                            _statusBar.replace(
+                                    StatusBar.ICON_STOPPING,
+                                    getString(R.string.notification_status_graceful, DataHelper.formatDuration(ms))
+                                    );
+                        } else {
+                            _statusBar.replace(StatusBar.ICON_STOPPING, R.string.notification_status_stopping);
+                        }
+                        setState(State.GRACEFUL_SHUTDOWN);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Cancel Graceful Shutdown
+     *
+     * @since 0.9.19
+     */
+    public void cancelGracefulShutdown() {
+        Util.d("cancelGracefulShutdown called"
+                + " Current state is: " + _state);
+        synchronized(_stateLock) {
+            if(_state != State.GRACEFUL_SHUTDOWN) {
+                return;
+            }
+            RouterContext ctx = _context;
+            if(ctx != null && ctx.router().isAlive()) {
+                ctx.router().cancelGracefulShutdown();
+                _currTitle = _oldTitle;
+                if (_hadTunnels) {
+                    setState(State.ACTIVE);
+                    _statusBar.replace(StatusBar.ICON_ACTIVE, R.string.notification_status_shutdown_cancelled);
+                } else {
+                    setState(State.RUNNING);
+                    _statusBar.replace(StatusBar.ICON_RUNNING, R.string.notification_status_shutdown_cancelled);
+                }
+            }
+        }
+    }
+
+
+
     // ******** end methods accessed from Activities and Receivers ************
+
+    private static final int STATE_MSG = 1;
+
+    /**
+     * Our Handler used to execute operations on the main thread.
+     */
+    private final Handler mHandler = new StateHandler(new WeakReference<>(this));
+    private static class StateHandler extends Handler {
+        WeakReference<RouterService> mReference;
+
+        public StateHandler(WeakReference<RouterService> reference) {
+            mReference = reference;
+        }
+
+        @Override
+        public void handleMessage(Message msg) {
+            RouterService parent = mReference.get();
+            if (parent == null)
+                return;
+
+            switch (msg.what) {
+            case STATE_MSG:
+                final State state = parent._state;
+                // Broadcast to all clients the new state.
+                final int N = parent.mStateCallbacks.beginBroadcast();
+                for (int i = 0; i < N; i++) {
+                    try {
+                        parent.mStateCallbacks.getBroadcastItem(i).stateChanged(state);
+                    } catch (RemoteException e) {
+                        // The RemoteCallbackList will take care of removing
+                        // the dead object for us.
+                    }
+                }
+                parent.mStateCallbacks.finishBroadcast();
+                break;
+            default:
+                super.handleMessage(msg);
+            }
+        }
+    }
+
     /**
      * Turn off the status bar. Unregister the receiver. If we were running,
      * fire up the Stopper thread.
      */
     @Override
     public void onDestroy() {
-        Util.i("onDestroy called"
+        Util.d("onDestroy called"
                 + " Current state is: " + _state);
 
         _handler.removeCallbacks(_updater);
         _statusBar.remove();
 
+        LocalBroadcastManager.getInstance(this).unregisterReceiver(onStateRequested);
+        LocalBroadcastManager.getInstance(this).unregisterReceiver(onLocaleChanged);
+
         I2PReceiver rcvr = _receiver;
         if(rcvr != null) {
             synchronized(rcvr) {
@@ -545,9 +645,10 @@ public class RouterService extends Service {
             if(_state == State.STARTING) {
                 _starterThread.interrupt();
             }
-            if(_state == State.STARTING || _state == State.RUNNING) {
+            if(_state == State.STARTING || _state == State.RUNNING ||
+               _state == State.ACTIVE || _state == State.GRACEFUL_SHUTDOWN) {
                 // should this be in a thread?
-                _statusBar.replace(StatusBar.ICON5, "I2P is shutting down");
+                _statusBar.replace(StatusBar.ICON_SHUTTING_DOWN, R.string.notification_status_shutting_down);
                 Thread stopperThread = new Thread(new Stopper(State.STOPPING, State.STOPPED));
                 stopperThread.start();
             }
@@ -574,14 +675,14 @@ public class RouterService extends Service {
 
         public void run() {
             try {
-                Util.i(MARKER + this + " stopper thread"
+                Util.d(MARKER + this + " stopper thread"
                         + " Current state is: " + _state);
                 RouterContext ctx = _context;
                 if(ctx != null) {
                     ctx.router().shutdown(Router.EXIT_HARD);
                 }
                 _statusBar.remove();
-                Util.i("********** Router shutdown complete");
+                Util.d("********** Router shutdown complete");
                 synchronized(_stateLock) {
                     if(_state == nextState) {
                         setState(stopState);
@@ -600,9 +701,9 @@ public class RouterService extends Service {
     private class ShutdownHook implements Runnable {
 
         public void run() {
-            Util.i(this + " shutdown hook"
+            Util.d(this + " shutdown hook"
                     + " Current state is: " + _state);
-            _statusBar.replace(StatusBar.ICON5, "I2P is shutting down");
+            _statusBar.replace(StatusBar.ICON_SHUTTING_DOWN, R.string.notification_status_shutting_down);
             I2PReceiver rcvr = _receiver;
             if(rcvr != null) {
                 synchronized(rcvr) {
@@ -622,7 +723,8 @@ public class RouterService extends Service {
                     _starterThread.interrupt();
                 }
                 if(_state == State.WAITING || _state == State.STARTING
-                        || _state == State.RUNNING) {
+                        || _state == State.RUNNING || _state == State.ACTIVE
+                        || _state == State.GRACEFUL_SHUTDOWN) {
                     setState(State.STOPPING);
                 }
             }
@@ -639,7 +741,7 @@ public class RouterService extends Service {
 
         public void run() {
             try {
-                Util.i(this + " final shutdown hook"
+                Util.d(this + " final shutdown hook"
                         + " Current state is: " + _state);
                 //I2PReceiver rcvr = _receiver;
 
@@ -657,13 +759,17 @@ public class RouterService extends Service {
                         setState(State.WAITING);
                         _handler.postDelayed(new Waiter(), 10 * 1000);
                     } else if(_state == State.STARTING || _state == State.RUNNING
-                            || _state == State.STOPPING) {
+                            || _state == State.ACTIVE || _state == State.STOPPING) {
-                        Util.i(this + " died of unknown causes");
+                        Util.w(this + " died of unknown causes");
                         setState(State.STOPPED);
+                        // Unregister all callbacks.
+                        mStateCallbacks.kill();
                         stopForeground(true);
                         stopSelf();
-                    } else if(_state == State.MANUAL_QUITTING) {
+                    } else if(_state == State.MANUAL_QUITTING || _state == State.GRACEFUL_SHUTDOWN) {
                         setState(State.MANUAL_QUITTED);
+                        // Unregister all callbacks.
+                        mStateCallbacks.kill();
                         stopForeground(true);
                         stopSelf();
                     }
@@ -677,17 +783,24 @@ public class RouterService extends Service {
     private State getSavedState() {
         SharedPreferences prefs = getSharedPreferences(SHARED_PREFS, 0);
         String stateString = prefs.getString(LAST_STATE, State.INIT.toString());
-        for(State s : State.values()) {
+        try {
-            if(s.toString().equals(stateString)) {
+            return State.valueOf(stateString);
-                return s;
+        } catch (IllegalArgumentException e) {
-            }
+            return State.INIT;
         }
-        return State.INIT;
     }
 
     private void setState(State s) {
         _state = s;
         saveState();
+
+        // Broadcast the new state within this app.
+        Intent intent = new Intent(LOCAL_BROADCAST_STATE_CHANGED);
+        intent.putExtra(LOCAL_BROADCAST_EXTRA_STATE, (android.os.Parcelable) _state);
+        LocalBroadcastManager.getInstance(this).sendBroadcast(intent);
+
+        // Notify other apps that the state has changed
+        mHandler.sendEmptyMessage(STATE_MSG);
     }
 
     /**