Merge remote-tracking branch 'origin/master' into canonicalize

Conflicts:
	.gitmodules
	OpenKeychain/build.gradle
	OpenKeychain/src/main/AndroidManifest.xml
	OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java
	OpenKeychain/src/main/res/values/strings.xml
	settings.gradle

.gitmodules

@@ -28,3 +28,6 @@
 [submodule "extern/SuperToasts"]
 	path = extern/SuperToasts
 	url = https://github.com/open-keychain/SuperToasts.git
+[submodule "extern/dnsjava"]
+	path = extern/dnsjava
+	url = https://github.com/open-keychain/dnsjava.git

.travis.yml

@@ -4,13 +4,13 @@ before_install:
     # Install base Android SDK
     - sudo apt-get update -qq
     - if [ `uname -m` = x86_64 ]; then sudo apt-get install -qq --force-yes libgd2-xpm lib32z1 lib32stdc++6; fi
-    - wget http://dl.google.com/android/android-sdk_r22.3-linux.tgz
+    - wget http://dl.google.com/android/android-sdk_r22.6.2-linux.tgz
-    - tar xzf android-sdk_r22.3-linux.tgz
+    - tar xzf android-sdk_r22.6.2-linux.tgz
     - export ANDROID_HOME=$PWD/android-sdk-linux
     - export PATH=${PATH}:${ANDROID_HOME}/tools:${ANDROID_HOME}/platform-tools
 
     # Install required Android components.
-    - echo "y" | android update sdk -a --filter build-tools-19.0.3,android-19,platform-tools,extra-android-support,extra-android-m2repository --no-ui --force
+    - echo "y" | android update sdk -a --filter build-tools-19.1.0,android-19,platform-tools,extra-android-support,extra-android-m2repository --no-ui --force
 install: echo "Installation done"
 script: gradle assemble -S -q
 

OpenKeychain/build.gradle

@@ -1,12 +1,12 @@
 apply plugin: 'android'
-apply plugin: 'android-test'
+//apply plugin: 'android-test'
 
 sourceSets {
-    androidTest {
+    //androidTest {
-        java.srcDir file('src/test/java')
+        //java.srcDir file('src/test/java')
         // configure the set of classes for JUnit tests
         // include '**/*Test.class'
-    }
+    //}
 }
 
 dependencies {
@@ -27,6 +27,7 @@ dependencies {
     compile project(':extern:spongycastle:prov')
     compile project(':extern:AppMsg:library')
     compile project(':extern:SuperToasts:supertoasts')
+    compile project(':extern:dnsjava')
 
     // Dependencies for the `instrumentTest` task, make sure to list all your global dependencies here as well
     androidTestCompile 'junit:junit:4.10'
@@ -53,7 +54,7 @@ dependencies {
 
 android {
     compileSdkVersion 19
-    buildToolsVersion "19.0.3"
+    buildToolsVersion "19.1"
 
     defaultConfig {
         minSdkVersion 9

OpenKeychain/src/main/AndroidManifest.xml

@@ -53,6 +53,12 @@
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
     <uses-permission android:name="android.permission.NFC" />
     <uses-permission android:name="android.permission.GET_ACCOUNTS" />
+    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS"/>
+    <uses-permission android:name="android.permission.MANAGE_ACCOUNTS"/>
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS"/>
+    <uses-permission android:name="android.permission.READ_CONTACTS" />
+    <uses-permission android:name="android.permission.WRITE_CONTACTS" />
 
     <!-- android:allowBackup="false": Don't allow backup over adb backup or other apps! -->
     <application
@@ -86,6 +92,11 @@
             <meta-data
                 android:name="android.support.PARENT_ACTIVITY"
                 android:value=".ui.KeyListActivity" />
+            <intent-filter>
+                <action android:name="android.intent.action.VIEW" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:mimeType="vnd.android.cursor.item/vnd.org.sufficientlysecure.keychain.key" />
+            </intent-filter>
         </activity>
         <activity
             android:name=".ui.ViewCertActivity"
@@ -440,6 +451,28 @@
             android:label="@string/title_log_display"
             android:exported="false" />
 
+        <service android:name=".service.DummyAccountService">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator"/>
+            </intent-filter>
+            <meta-data
+                    android:name="android.accounts.AccountAuthenticator"
+                    android:resource="@xml/account_desc"/>
+        </service>
+
+        <service android:name=".service.ContactSyncAdapterService">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter"/>
+            </intent-filter>
+
+            <meta-data
+                    android:name="android.content.SyncAdapter"
+                    android:resource="@xml/sync_adapter_desc"/>
+            <meta-data
+                    android:name="android.provider.CONTACTS_STRUCTURE"
+                    android:resource="@xml/custom_pgp_contacts_structure"/>
+        </service>
+
     </application>
 
 </manifest>

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/Constants.java

@@ -46,6 +46,8 @@ public final class Constants {
 
     public static final String INTENT_PREFIX = PACKAGE_NAME + ".action.";
 
+    public static final String CUSTOM_CONTACT_DATA_MIME_TYPE = "vnd.android.cursor.item/vnd.org.sufficientlysecure.keychain.key";
+
     public static final class Path {
         public static final String APP_DIR = Environment.getExternalStorageDirectory()
                 + "/OpenKeychain";

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/KeychainApplication.java

@@ -17,6 +17,8 @@
 
 package org.sufficientlysecure.keychain;
 
+import android.accounts.Account;
+import android.accounts.AccountManager;
 import android.app.Application;
 import android.content.Context;
 import android.graphics.PorterDuff;
@@ -24,6 +26,7 @@ import android.graphics.drawable.Drawable;
 import android.os.Environment;
 
 import org.spongycastle.jce.provider.BouncyCastleProvider;
+import org.sufficientlysecure.keychain.helper.ContactHelper;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.PRNGFixes;
 
@@ -76,6 +79,17 @@ public class KeychainApplication extends Application {
 
         brandGlowEffect(getApplicationContext(),
                 getApplicationContext().getResources().getColor(R.color.emphasis));
+
+        setupAccountAsNeeded(this);
+    }
+
+    public static void setupAccountAsNeeded(Context context) {
+        AccountManager manager = AccountManager.get(context);
+        Account[] accounts = manager.getAccountsByType(Constants.PACKAGE_NAME);
+        if (accounts == null || accounts.length == 0) {
+            Account dummy = new Account(context.getString(R.string.app_name), Constants.PACKAGE_NAME);
+            manager.addAccountExplicitly(dummy, null, null);
+        }
     }
 
     static void brandGlowEffect(Context context, int brandColor) {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/helper/ContactHelper.java

@@ -19,8 +19,18 @@ package org.sufficientlysecure.keychain.helper;
 
 import android.accounts.Account;
 import android.accounts.AccountManager;
-import android.content.Context;
+import android.content.*;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.RemoteException;
+import android.provider.ContactsContract;
 import android.util.Patterns;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
+import org.sufficientlysecure.keychain.provider.KeychainContract;
+import org.sufficientlysecure.keychain.util.Log;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -29,6 +39,15 @@ import java.util.Set;
 
 public class ContactHelper {
 
+    public static final String[] KEYS_TO_CONTACT_PROJECTION = new String[]{
+            KeychainContract.KeyRings.USER_ID,
+            KeychainContract.KeyRings.FINGERPRINT,
+            KeychainContract.KeyRings.KEY_ID,
+            KeychainContract.KeyRings.MASTER_KEY_ID};
+    public static final String[] RAW_CONTACT_ID_PROJECTION = new String[]{ContactsContract.RawContacts._ID};
+    public static final String FIND_RAW_CONTACT_SELECTION =
+            ContactsContract.RawContacts.ACCOUNT_TYPE + "=? AND " + ContactsContract.RawContacts.SOURCE_ID + "=?";
+
     public static final List<String> getMailAccounts(Context context) {
         final Account[] accounts = AccountManager.get(context).getAccounts();
         final Set<String> emailSet = new HashSet<String>();
@@ -39,4 +58,92 @@ public class ContactHelper {
         }
         return new ArrayList<String>(emailSet);
     }
+
+    public static List<String> getContactMails(Context context) {
+        ContentResolver resolver = context.getContentResolver();
+        Cursor mailCursor = resolver.query(ContactsContract.CommonDataKinds.Email.CONTENT_URI,
+                new String[]{ContactsContract.CommonDataKinds.Email.DATA},
+                null, null, null);
+        if (mailCursor == null) return null;
+
+        Set<String> mails = new HashSet<String>();
+        while (mailCursor.moveToNext()) {
+            String email = mailCursor.getString(0);
+            if (email != null) {
+                mails.add(email);
+            }
+        }
+        mailCursor.close();
+        return new ArrayList<String>(mails);
+    }
+
+    public static Uri dataUriFromContactUri(Context context, Uri contactUri) {
+        Cursor contactMasterKey = context.getContentResolver().query(contactUri, new String[]{ContactsContract.Data.DATA2}, null, null, null, null);
+        if (contactMasterKey != null) {
+            if (contactMasterKey.moveToNext()) {
+                return KeychainContract.KeyRings.buildGenericKeyRingUri(contactMasterKey.getLong(0));
+            }
+            contactMasterKey.close();
+        }
+        return null;
+    }
+
+    public static void writeKeysToContacts(Context context) {
+        ContentResolver resolver = context.getContentResolver();
+        Cursor cursor = resolver.query(KeychainContract.KeyRings.buildUnifiedKeyRingsUri(), KEYS_TO_CONTACT_PROJECTION,
+                null, null, null);
+        if (cursor != null) {
+            while (cursor.moveToNext()) {
+                String[] userId = KeyRing.splitUserId(cursor.getString(0));
+                String fingerprint = PgpKeyHelper.convertFingerprintToHex(cursor.getBlob(1));
+                String keyIdShort = PgpKeyHelper.convertKeyIdToHexShort(cursor.getLong(2));
+                long masterKeyId = cursor.getLong(3);
+                int rawContactId = -1;
+                Cursor raw = resolver.query(ContactsContract.RawContacts.CONTENT_URI, RAW_CONTACT_ID_PROJECTION,
+                        FIND_RAW_CONTACT_SELECTION, new String[]{Constants.PACKAGE_NAME, fingerprint}, null, null);
+                if (raw != null) {
+                    if (raw.moveToNext()) {
+                        rawContactId = raw.getInt(0);
+                    }
+                    raw.close();
+                }
+                ArrayList<ContentProviderOperation> ops = new ArrayList<ContentProviderOperation>();
+                if (rawContactId == -1) {
+                    ops.add(ContentProviderOperation.newInsert(ContactsContract.RawContacts.CONTENT_URI)
+                            .withValue(ContactsContract.RawContacts.ACCOUNT_NAME, context.getString(R.string.app_name))
+                            .withValue(ContactsContract.RawContacts.ACCOUNT_TYPE, Constants.PACKAGE_NAME)
+                            .withValue(ContactsContract.RawContacts.SOURCE_ID, fingerprint)
+                            .build());
+                    if (userId[0] != null) {
+                        ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
+                                .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
+                                .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE)
+                                .withValue(ContactsContract.CommonDataKinds.StructuredName.DISPLAY_NAME, userId[0])
+                                .build());
+                    }
+                    if (userId[1] != null) {
+                        ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
+                                .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
+                                .withValue(ContactsContract.Data.MIMETYPE, ContactsContract.CommonDataKinds.Email.CONTENT_ITEM_TYPE)
+                                .withValue(ContactsContract.CommonDataKinds.Email.DATA, userId[1])
+                                .build());
+                    }
+                    ops.add(ContentProviderOperation.newInsert(ContactsContract.Data.CONTENT_URI)
+                            .withValueBackReference(ContactsContract.Data.RAW_CONTACT_ID, 0)
+                            .withValue(ContactsContract.Data.MIMETYPE, Constants.CUSTOM_CONTACT_DATA_MIME_TYPE)
+                            .withValue(ContactsContract.Data.DATA1, String.format(context.getString(R.string.contact_show_key), keyIdShort))
+                            .withValue(ContactsContract.Data.DATA2, masterKeyId)
+                            .build());
+                }
+                try {
+                    resolver.applyBatch(ContactsContract.AUTHORITY, ops);
+                } catch (RemoteException e) {
+                    e.printStackTrace();
+                } catch (OperationApplicationException e) {
+                    e.printStackTrace();
+                }
+            }
+            cursor.close();
+        }
+    }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/helper/EmailKeyHelper.java

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2014 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.helper;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Messenger;
+import org.sufficientlysecure.keychain.keyimport.HkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
+import org.sufficientlysecure.keychain.keyimport.Keyserver;
+import org.sufficientlysecure.keychain.service.KeychainIntentService;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public class EmailKeyHelper {
+
+    public static void importContacts(Context context, Messenger messenger) {
+        importAll(context, messenger, ContactHelper.getContactMails(context));
+    }
+
+    public static void importAll(Context context, Messenger messenger, List<String> mails) {
+        Set<ImportKeysListEntry> keys = new HashSet<ImportKeysListEntry>();
+        for (String mail : mails) {
+            keys.addAll(getEmailKeys(context, mail));
+        }
+        importKeys(context, messenger, new ArrayList<ImportKeysListEntry>(keys));
+    }
+
+    public static List<ImportKeysListEntry> getEmailKeys(Context context, String mail) {
+        Set<ImportKeysListEntry> keys = new HashSet<ImportKeysListEntry>();
+
+        // Try _hkp._tcp SRV record first
+        String[] mailparts = mail.split("@");
+        if (mailparts.length == 2) {
+            HkpKeyserver hkp = HkpKeyserver.resolve(mailparts[1]);
+            if (hkp != null) {
+                keys.addAll(getEmailKeys(mail, hkp));
+            }
+        }
+
+        // Most users don't have the SRV record, so ask a default server as well
+        String[] servers = Preferences.getPreferences(context).getKeyServers();
+        if (servers != null && servers.length != 0) {
+            HkpKeyserver hkp = new HkpKeyserver(servers[0]);
+            keys.addAll(getEmailKeys(mail, hkp));
+        }
+        return new ArrayList<ImportKeysListEntry>(keys);
+    }
+
+    private static void importKeys(Context context, Messenger messenger, List<ImportKeysListEntry> keys) {
+        Intent importIntent = new Intent(context, KeychainIntentService.class);
+        importIntent.setAction(KeychainIntentService.ACTION_DOWNLOAD_AND_IMPORT_KEYS);
+        Bundle importData = new Bundle();
+        importData.putParcelableArrayList(KeychainIntentService.DOWNLOAD_KEY_LIST,
+                new ArrayList<ImportKeysListEntry>(keys));
+        importIntent.putExtra(KeychainIntentService.EXTRA_DATA, importData);
+        importIntent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger);
+
+        context.startService(importIntent);
+    }
+
+    public static List<ImportKeysListEntry> getEmailKeys(String mail, Keyserver keyServer) {
+        Set<ImportKeysListEntry> keys = new HashSet<ImportKeysListEntry>();
+        try {
+            for (ImportKeysListEntry key : keyServer.search(mail)) {
+                if (key.isRevoked() || key.isExpired()) continue;
+                for (String userId : key.getUserIds()) {
+                    if (userId.toLowerCase().contains(mail.toLowerCase())) {
+                        keys.add(key);
+                    }
+                }
+            }
+        } catch (Keyserver.QueryFailedException ignored) {
+        } catch (Keyserver.QueryNeedsRepairException ignored) {
+        }
+        return new ArrayList<ImportKeysListEntry>(keys);
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/HkpKeyserver.java

@@ -33,6 +33,10 @@ import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.pgp.PgpHelper;
 import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
 import org.sufficientlysecure.keychain.util.Log;
+import org.xbill.DNS.Lookup;
+import org.xbill.DNS.Record;
+import org.xbill.DNS.SRVRecord;
+import org.xbill.DNS.Type;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -45,6 +49,8 @@ import java.net.URLDecoder;
 import java.net.URLEncoder;
 import java.net.UnknownHostException;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
 import java.util.GregorianCalendar;
 import java.util.List;
 import java.util.Locale;
@@ -75,6 +81,7 @@ public class HkpKeyserver extends Keyserver {
 
     private String mHost;
     private short mPort;
+    private boolean mSecure;
 
     /**
      * pub:%keyid%:%algo%:%keylen%:%creationdate%:%expirationdate%:%flags%
@@ -109,7 +116,7 @@ public class HkpKeyserver extends Keyserver {
      */
     public static final Pattern PUB_KEY_LINE = Pattern
             .compile("pub:([0-9a-fA-F]+):([0-9]+):([0-9]+):([0-9]+):([0-9]*):([rde]*)[ \n\r]*" // pub line
-                    + "(uid:(.*):([0-9]+):([0-9]*):([rde]*))+", // one or more uid lines
+                    + "((uid:([^:]*):([0-9]+):([0-9]*):([rde]*)[ \n\r]*)+)", // one or more uid lines
                     Pattern.CASE_INSENSITIVE);
 
     /**
@@ -137,10 +144,11 @@ public class HkpKeyserver extends Keyserver {
      * </ul>
      */
     public static final Pattern UID_LINE = Pattern
-            .compile("uid:(.*):([0-9]+):([0-9]*):([rde]*)",
+            .compile("uid:([^:]*):([0-9]+):([0-9]*):([rde]*)",
                     Pattern.CASE_INSENSITIVE);
 
     private static final short PORT_DEFAULT = 11371;
+    private static final short PORT_DEFAULT_HKPS = 443;
 
     /**
      * @param hostAndPort may be just
@@ -151,31 +159,68 @@ public class HkpKeyserver extends Keyserver {
     public HkpKeyserver(String hostAndPort) {
         String host = hostAndPort;
         short port = PORT_DEFAULT;
-        final int colonPosition = hostAndPort.lastIndexOf(':');
+        boolean secure = false;
-        if (colonPosition > 0) {
+        String[] parts = hostAndPort.split(":");
-            host = hostAndPort.substring(0, colonPosition);
+        if (parts.length > 1) {
-            final String portStr = hostAndPort.substring(colonPosition + 1);
+            if (!parts[0].contains(".")) { // This is not a domain or ip, so it must be a protocol name
-            port = Short.decode(portStr);
+                if (parts[0].equalsIgnoreCase("hkps") || parts[0].equalsIgnoreCase("https")) {
+                    secure = true;
+                    port = PORT_DEFAULT_HKPS;
+                } else if (!parts[0].equalsIgnoreCase("hkp") && !parts[0].equalsIgnoreCase("http")) {
+                    throw new IllegalArgumentException("Protocol " + parts[0] + " is unknown");
+                }
+                host = parts[1];
+                if (host.startsWith("//")) { // People tend to type https:// and hkps://, so we'll support that as well
+                    host = host.substring(2);
+                }
+                if (parts.length > 2) {
+                    port = Short.decode(parts[2]);
+                }
+            } else {
+                host = parts[0];
+                port = Short.decode(parts[1]);
+            }
         }
         mHost = host;
         mPort = port;
+        mSecure = secure;
     }
 
     public HkpKeyserver(String host, short port) {
+        this(host, port, false);
+    }
+
+    public HkpKeyserver(String host, short port, boolean secure) {
         mHost = host;
         mPort = port;
+        mSecure = secure;
+    }
+
+    private String getUrlPrefix() {
+        return mSecure ? "https://" : "http://";
     }
 
     private String query(String request) throws QueryFailedException, HttpError {
+        List<String> urls = new ArrayList<String>();
+        if (mSecure) {
+            urls.add(getUrlPrefix() + mHost + ":" + mPort + request);
+        } else {
             InetAddress ips[];
             try {
                 ips = InetAddress.getAllByName(mHost);
             } catch (UnknownHostException e) {
                 throw new QueryFailedException(e.toString());
             }
-        for (int i = 0; i < ips.length; ++i) {
+            for (InetAddress ip : ips) {
+                // Note: This is actually not HTTP 1.1 compliant, as we hide the real "Host" value,
+                //       but Android's HTTPUrlConnection does not support any other way to set
+                //       Socket's remote IP address...
+                urls.add(getUrlPrefix() + ip.getHostAddress() + ":" + mPort + request);
+            }
+        }
+
+        for (String url : urls) {
             try {
-                String url = "http://" + ips[i].getHostAddress() + ":" + mPort + request;
                 Log.d(Constants.TAG, "hkp keyserver query: " + url);
                 URL realUrl = new URL(url);
                 HttpURLConnection conn = (HttpURLConnection) realUrl.openConnection();
@@ -238,6 +283,7 @@ public class HkpKeyserver extends Keyserver {
         while (matcher.find()) {
             final ImportKeysListEntry entry = new ImportKeysListEntry();
             entry.setQuery(query);
+            entry.setOrigin(getUrlPrefix() + mHost + ":" + mPort);
 
             entry.setBitStrength(Integer.parseInt(matcher.group(3)));
 
@@ -262,6 +308,7 @@ public class HkpKeyserver extends Keyserver {
             entry.setDate(tmpGreg.getTime());
 
             entry.setRevoked(matcher.group(6).contains("r"));
+            entry.setExpired(matcher.group(6).contains("e"));
 
             ArrayList<String> userIds = new ArrayList<String>();
             final String uidLines = matcher.group(7);
@@ -290,7 +337,7 @@ public class HkpKeyserver extends Keyserver {
     public String get(String keyIdHex) throws QueryFailedException {
         HttpClient client = new DefaultHttpClient();
         try {
-            String query = "http://" + mHost + ":" + mPort +
+            String query = getUrlPrefix() + mHost + ":" + mPort +
                     "/pks/lookup?op=get&options=mr&search=" + keyIdHex;
             Log.d(Constants.TAG, "hkp keyserver get: " + query);
             HttpGet get = new HttpGet(query);
@@ -319,7 +366,7 @@ public class HkpKeyserver extends Keyserver {
     public void add(String armoredKey) throws AddKeyException {
         HttpClient client = new DefaultHttpClient();
         try {
-            String query = "http://" + mHost + ":" + mPort + "/pks/add";
+            String query = getUrlPrefix() + mHost + ":" + mPort + "/pks/add";
             HttpPost post = new HttpPost(query);
             Log.d(Constants.TAG, "hkp keyserver add: " + query);
             List<NameValuePair> nameValuePairs = new ArrayList<NameValuePair>(2);
@@ -336,4 +383,36 @@ public class HkpKeyserver extends Keyserver {
             client.getConnectionManager().shutdown();
         }
     }
+
+    @Override
+    public String toString() {
+        return mHost + ":" + mPort;
+    }
+
+    /**
+     * Tries to find a server responsible for a given domain
+     *
+     * @return A responsible Keyserver or null if not found.
+     */
+    public static HkpKeyserver resolve(String domain) {
+        try {
+            Record[] records = new Lookup("_hkp._tcp." + domain, Type.SRV).run();
+            if (records.length > 0) {
+                Arrays.sort(records, new Comparator<Record>() {
+                    @Override
+                    public int compare(Record lhs, Record rhs) {
+                        if (!(lhs instanceof SRVRecord)) return 1;
+                        if (!(rhs instanceof SRVRecord)) return -1;
+                        return ((SRVRecord) lhs).getPriority() - ((SRVRecord) rhs).getPriority();
+                    }
+                });
+                Record record = records[0]; // This is our best choice
+                if (record instanceof SRVRecord) {
+                    return new HkpKeyserver(((SRVRecord) record).getTarget().toString(), (short) ((SRVRecord) record).getPort());
+                }
+            }
+        } catch (Exception ignored) {
+        }
+        return null;
+    }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/ImportKeysListEntry.java

@@ -32,18 +32,20 @@ import java.util.Date;
 public class ImportKeysListEntry implements Serializable, Parcelable {
     private static final long serialVersionUID = -7797972103284992662L;
 
-    public ArrayList<String> userIds;
+    private ArrayList<String> mUserIds;
-    public long keyId;
+    private long mKeyId;
-    public String keyIdHex;
+    private String mKeyIdHex;
-    public boolean revoked;
+    private boolean mRevoked;
-    public Date date; // TODO: not displayed
+    private boolean mExpired;
-    public String fingerprintHex;
+    private Date mDate; // TODO: not displayed
-    public int bitStrength;
+    private String mFingerprintHex;
-    public String algorithm;
+    private int mBitStrength;
-    public boolean secretKey;
+    private String mAlgorithm;
-    public String mPrimaryUserId;
+    private boolean mSecretKey;
+    private String mPrimaryUserId;
     private String mExtraData;
     private String mQuery;
+    private String mOrigin;
 
     private boolean mSelected;
 
@@ -54,35 +56,39 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
     @Override
     public void writeToParcel(Parcel dest, int flags) {
         dest.writeString(mPrimaryUserId);
-        dest.writeStringList(userIds);
+        dest.writeStringList(mUserIds);
-        dest.writeLong(keyId);
+        dest.writeLong(mKeyId);
-        dest.writeByte((byte) (revoked ? 1 : 0));
+        dest.writeByte((byte) (mRevoked ? 1 : 0));
-        dest.writeSerializable(date);
+        dest.writeByte((byte) (mExpired ? 1 : 0));
-        dest.writeString(fingerprintHex);
+        dest.writeSerializable(mDate);
-        dest.writeString(keyIdHex);
+        dest.writeString(mFingerprintHex);
-        dest.writeInt(bitStrength);
+        dest.writeString(mKeyIdHex);
-        dest.writeString(algorithm);
+        dest.writeInt(mBitStrength);
-        dest.writeByte((byte) (secretKey ? 1 : 0));
+        dest.writeString(mAlgorithm);
+        dest.writeByte((byte) (mSecretKey ? 1 : 0));
         dest.writeByte((byte) (mSelected ? 1 : 0));
         dest.writeString(mExtraData);
+        dest.writeString(mOrigin);
     }
 
     public static final Creator<ImportKeysListEntry> CREATOR = new Creator<ImportKeysListEntry>() {
         public ImportKeysListEntry createFromParcel(final Parcel source) {
             ImportKeysListEntry vr = new ImportKeysListEntry();
             vr.mPrimaryUserId = source.readString();
-            vr.userIds = new ArrayList<String>();
+            vr.mUserIds = new ArrayList<String>();
-            source.readStringList(vr.userIds);
+            source.readStringList(vr.mUserIds);
-            vr.keyId = source.readLong();
+            vr.mKeyId = source.readLong();
-            vr.revoked = source.readByte() == 1;
+            vr.mRevoked = source.readByte() == 1;
-            vr.date = (Date) source.readSerializable();
+            vr.mExpired = source.readByte() == 1;
-            vr.fingerprintHex = source.readString();
+            vr.mDate = (Date) source.readSerializable();
-            vr.keyIdHex = source.readString();
+            vr.mFingerprintHex = source.readString();
-            vr.bitStrength = source.readInt();
+            vr.mKeyIdHex = source.readString();
-            vr.algorithm = source.readString();
+            vr.mBitStrength = source.readInt();
-            vr.secretKey = source.readByte() == 1;
+            vr.mAlgorithm = source.readString();
+            vr.mSecretKey = source.readByte() == 1;
             vr.mSelected = source.readByte() == 1;
             vr.mExtraData = source.readString();
+            vr.mOrigin = source.readString();
 
             return vr;
         }
@@ -93,7 +99,7 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
     };
 
     public String getKeyIdHex() {
-        return keyIdHex;
+        return mKeyIdHex;
     }
 
     public boolean isSelected() {
@@ -104,72 +110,80 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
         this.mSelected = selected;
     }
 
+    public boolean isExpired() {
+        return mExpired;
+    }
+
+    public void setExpired(boolean expired) {
+        this.mExpired = expired;
+    }
+
     public long getKeyId() {
-        return keyId;
+        return mKeyId;
     }
 
     public void setKeyId(long keyId) {
-        this.keyId = keyId;
+        this.mKeyId = keyId;
     }
 
     public void setKeyIdHex(String keyIdHex) {
-        this.keyIdHex = keyIdHex;
+        this.mKeyIdHex = keyIdHex;
     }
 
     public boolean isRevoked() {
-        return revoked;
+        return mRevoked;
     }
 
     public void setRevoked(boolean revoked) {
-        this.revoked = revoked;
+        this.mRevoked = revoked;
     }
 
     public Date getDate() {
-        return date;
+        return mDate;
     }
 
     public void setDate(Date date) {
-        this.date = date;
+        this.mDate = date;
     }
 
     public String getFingerprintHex() {
-        return fingerprintHex;
+        return mFingerprintHex;
     }
 
     public void setFingerprintHex(String fingerprintHex) {
-        this.fingerprintHex = fingerprintHex;
+        this.mFingerprintHex = fingerprintHex;
     }
 
     public int getBitStrength() {
-        return bitStrength;
+        return mBitStrength;
     }
 
     public void setBitStrength(int bitStrength) {
-        this.bitStrength = bitStrength;
+        this.mBitStrength = bitStrength;
     }
 
     public String getAlgorithm() {
-        return algorithm;
+        return mAlgorithm;
     }
 
     public void setAlgorithm(String algorithm) {
-        this.algorithm = algorithm;
+        this.mAlgorithm = algorithm;
     }
 
     public boolean isSecretKey() {
-        return secretKey;
+        return mSecretKey;
     }
 
     public void setSecretKey(boolean secretKey) {
-        this.secretKey = secretKey;
+        this.mSecretKey = secretKey;
     }
 
     public ArrayList<String> getUserIds() {
-        return userIds;
+        return mUserIds;
     }
 
     public void setUserIds(ArrayList<String> userIds) {
-        this.userIds = userIds;
+        this.mUserIds = userIds;
     }
 
     public String getPrimaryUserId() {
@@ -196,15 +210,23 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
         mQuery = query;
     }
 
+    public String getOrigin() {
+        return mOrigin;
+    }
+
+    public void setOrigin(String origin) {
+        mOrigin = origin;
+    }
+
     /**
      * Constructor for later querying from keyserver
      */
     public ImportKeysListEntry() {
         // keys from keyserver are always public keys; from keybase too
-        secretKey = false;
+        mSecretKey = false;
         // do not select by default
         mSelected = false;
-        userIds = new ArrayList<String>();
+        mUserIds = new ArrayList<String>();
     }
 
     /**
@@ -215,24 +237,24 @@ public class ImportKeysListEntry implements Serializable, Parcelable {
         // selected is default
         this.mSelected = true;
 
-        secretKey = ring.isSecret();
+        mSecretKey = ring.isSecret();
         UncachedPublicKey key = ring.getPublicKey();
 
         mPrimaryUserId = key.getPrimaryUserId();
-        userIds = key.getUnorderedUserIds();
+        mUserIds = key.getUnorderedUserIds();
 
         // if there was no user id flagged as primary, use the first one
         if (mPrimaryUserId == null) {
-            mPrimaryUserId = userIds.get(0);
+            mPrimaryUserId = mUserIds.get(0);
         }
 
-        this.keyId = key.getKeyId();
+        this.mKeyId = key.getKeyId();
-        this.keyIdHex = PgpKeyHelper.convertKeyIdToHex(keyId);
+        this.mKeyIdHex = PgpKeyHelper.convertKeyIdToHex(mKeyId);
 
-        this.revoked = key.isRevoked();
+        this.mRevoked = key.isRevoked();
-        this.fingerprintHex = PgpKeyHelper.convertFingerprintToHex(key.getFingerprint());
+        this.mFingerprintHex = PgpKeyHelper.convertFingerprintToHex(key.getFingerprint());
-        this.bitStrength = key.getBitStrength();
+        this.mBitStrength = key.getBitStrength();
         final int algorithm = key.getAlgorithm();
-        this.algorithm = PgpKeyHelper.getAlgorithmInfo(context, algorithm);
+        this.mAlgorithm = PgpKeyHelper.getAlgorithmInfo(context, algorithm);
     }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/KeybaseKeyserver.java

@@ -31,6 +31,7 @@ import java.net.URLEncoder;
 import java.util.ArrayList;
 
 public class KeybaseKeyserver extends Keyserver {
+    public static final String ORIGIN = "keybase:keybase.io";
     private String mQuery;
 
     @Override
@@ -87,6 +88,7 @@ public class KeybaseKeyserver extends Keyserver {
 
         final ImportKeysListEntry entry = new ImportKeysListEntry();
         entry.setQuery(mQuery);
+        entry.setOrigin(ORIGIN);
 
         String keybaseId = JWalk.getString(match, "components", "username", "val");
         String fullName = JWalk.getString(match, "components", "full_name", "val");
@@ -144,7 +146,8 @@ public class KeybaseKeyserver extends Keyserver {
                 try {
                     JSONObject json = new JSONObject(text);
                     if (JWalk.getInt(json, "status", "code") != 0) {
-                        throw new QueryFailedException("Keybase autocomplete search failed");
+                        throw new QueryFailedException("Keybase.io query failed: " + path + "?" +
+                                query);
                     }
                     return json;
                 } catch (JSONException e) {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/keyimport/Keyserver.java

@@ -48,12 +48,12 @@ public abstract class Keyserver {
         private static final long serialVersionUID = -507574859137295530L;
     }
 
-    abstract List<ImportKeysListEntry> search(String query) throws QueryFailedException,
+    public abstract List<ImportKeysListEntry> search(String query) throws QueryFailedException,
             QueryNeedsRepairException;
 
-    abstract String get(String keyIdHex) throws QueryFailedException;
+    public abstract String get(String keyIdHex) throws QueryFailedException;
 
-    abstract void add(String armoredKey) throws AddKeyException;
+    public abstract void add(String armoredKey) throws AddKeyException;
 
     public static String readAll(InputStream in, String encoding) throws IOException {
         ByteArrayOutputStream raw = new ByteArrayOutputStream();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ContactSyncAdapterService.java

@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2014 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.service;
+
+import android.accounts.Account;
+import android.app.Service;
+import android.content.AbstractThreadedSyncAdapter;
+import android.content.ContentProviderClient;
+import android.content.Intent;
+import android.content.SyncResult;
+import android.os.*;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.KeychainApplication;
+import org.sufficientlysecure.keychain.helper.ContactHelper;
+import org.sufficientlysecure.keychain.helper.EmailKeyHelper;
+import org.sufficientlysecure.keychain.util.Log;
+
+public class ContactSyncAdapterService extends Service {
+
+    private class ContactSyncAdapter extends AbstractThreadedSyncAdapter {
+
+        public ContactSyncAdapter() {
+            super(ContactSyncAdapterService.this, true);
+        }
+
+        @Override
+        public void onPerformSync(Account account, Bundle extras, String authority, ContentProviderClient provider,
+                                  final SyncResult syncResult) {
+            EmailKeyHelper.importContacts(getContext(), new Messenger(new Handler(Looper.getMainLooper(),
+                    new Handler.Callback() {
+                        @Override
+                        public boolean handleMessage(Message msg) {
+                            Bundle data = msg.getData();
+                            switch (msg.arg1) {
+                                case KeychainIntentServiceHandler.MESSAGE_OKAY:
+                                    return true;
+                                case KeychainIntentServiceHandler.MESSAGE_UPDATE_PROGRESS:
+                                    if (data.containsKey(KeychainIntentServiceHandler.DATA_PROGRESS) &&
+                                            data.containsKey(KeychainIntentServiceHandler.DATA_PROGRESS_MAX)) {
+                                        Log.d(Constants.TAG, "Progress: " +
+                                                data.getInt(KeychainIntentServiceHandler.DATA_PROGRESS) + "/" +
+                                                data.getInt(KeychainIntentServiceHandler.DATA_PROGRESS_MAX));
+                                        return false;
+                                    }
+                                default:
+                                    Log.d(Constants.TAG, "Syncing... " + msg.toString());
+                                    return false;
+                            }
+                        }
+                    })));
+            KeychainApplication.setupAccountAsNeeded(ContactSyncAdapterService.this);
+            ContactHelper.writeKeysToContacts(ContactSyncAdapterService.this);
+        }
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return new ContactSyncAdapter().getSyncAdapterBinder();
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/DummyAccountService.java

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2014 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package org.sufficientlysecure.keychain.service;
+
+import android.accounts.AbstractAccountAuthenticator;
+import android.accounts.Account;
+import android.accounts.AccountAuthenticatorResponse;
+import android.accounts.NetworkErrorException;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.IBinder;
+import android.os.Message;
+import android.widget.Toast;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.util.Log;
+
+/**
+ * This service actually does nothing, it's sole task is to show a Toast if the use tries to create an account.
+ */
+public class DummyAccountService extends Service {
+
+    private class Toaster {
+        private static final String TOAST_MESSAGE = "toast_message";
+        private Context context;
+        private Handler handler = new Handler(new Handler.Callback() {
+            @Override
+            public boolean handleMessage(Message msg) {
+                Toast.makeText(context, msg.getData().getString(TOAST_MESSAGE), Toast.LENGTH_LONG).show();
+                return true;
+            }
+        });
+
+        private Toaster(Context context) {
+            this.context = context;
+        }
+
+        public void toast(int resourceId) {
+            toast(context.getString(resourceId));
+        }
+
+        public void toast(String message) {
+            Message msg = new Message();
+            Bundle bundle = new Bundle();
+            bundle.putString(TOAST_MESSAGE, message);
+            msg.setData(bundle);
+            handler.sendMessage(msg);
+        }
+    }
+
+    private class Authenticator extends AbstractAccountAuthenticator {
+
+        public Authenticator() {
+            super(DummyAccountService.this);
+        }
+
+        @Override
+        public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
+            Log.d(Constants.TAG, "DummyAccountService.editProperties");
+            return null;
+        }
+
+        @Override
+        public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType,
+                                 String[] requiredFeatures, Bundle options) throws NetworkErrorException {
+            response.onResult(new Bundle());
+            toaster.toast(R.string.info_no_manual_account_creation);
+            Log.d(Constants.TAG, "DummyAccountService.addAccount");
+            return null;
+        }
+
+        @Override
+        public Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account, Bundle options)
+                throws NetworkErrorException {
+            Log.d(Constants.TAG, "DummyAccountService.confirmCredentials");
+            return null;
+        }
+
+        @Override
+        public Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType,
+                                   Bundle options) throws NetworkErrorException {
+            Log.d(Constants.TAG, "DummyAccountService.getAuthToken");
+            return null;
+        }
+
+        @Override
+        public String getAuthTokenLabel(String authTokenType) {
+            Log.d(Constants.TAG, "DummyAccountService.getAuthTokenLabel");
+            return null;
+        }
+
+        @Override
+        public Bundle updateCredentials(AccountAuthenticatorResponse response, Account account, String authTokenType,
+                                        Bundle options) throws NetworkErrorException {
+            Log.d(Constants.TAG, "DummyAccountService.updateCredentials");
+            return null;
+        }
+
+        @Override
+        public Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features)
+                throws NetworkErrorException {
+            Log.d(Constants.TAG, "DummyAccountService.hasFeatures");
+            return null;
+        }
+    }
+
+    private Toaster toaster;
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        toaster = new Toaster(this);
+        return new Authenticator().getIBinder();
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainIntentService.java

@@ -32,6 +32,7 @@ import org.sufficientlysecure.keychain.helper.FileHelper;
 import org.sufficientlysecure.keychain.helper.OtherHelper;
 import org.sufficientlysecure.keychain.helper.Preferences;
 import org.sufficientlysecure.keychain.keyimport.HkpKeyserver;
+import org.sufficientlysecure.keychain.keyimport.Keyserver;
 import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
 import org.sufficientlysecure.keychain.keyimport.KeybaseKeyserver;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
@@ -734,49 +735,30 @@ public class KeychainIntentService extends IntentService
             } catch (Exception e) {
                 sendErrorToHandler(e);
             }
-        } else if (ACTION_IMPORT_KEYBASE_KEYS.equals(action)) {
+        } else if (ACTION_DOWNLOAD_AND_IMPORT_KEYS.equals(action) || ACTION_IMPORT_KEYBASE_KEYS.equals(action)) {
-            ArrayList<ImportKeysListEntry> entries = data.getParcelableArrayList(DOWNLOAD_KEY_LIST);
-
-            try {
-                KeybaseKeyserver server = new KeybaseKeyserver();
-                ArrayList<ParcelableKeyRing> keyRings = new ArrayList<ParcelableKeyRing>(entries.size());
-                for (ImportKeysListEntry entry : entries) {
-                    // the keybase handle is in userId(1)
-                    String keybaseId = entry.getExtraData();
-                    byte[] downloadedKeyBytes = server.get(keybaseId).getBytes();
-
-                    // save key bytes in entry object for doing the
-                    // actual import afterwards
-                    keyRings.add(new ParcelableKeyRing(downloadedKeyBytes));
-                }
-
-                Intent importIntent = new Intent(this, KeychainIntentService.class);
-                importIntent.setAction(ACTION_IMPORT_KEYRING);
-                Bundle importData = new Bundle();
-                importData.putParcelableArrayList(IMPORT_KEY_LIST, keyRings);
-                importIntent.putExtra(EXTRA_DATA, importData);
-                importIntent.putExtra(EXTRA_MESSENGER, mMessenger);
-
-                // now import it with this service
-                onHandleIntent(importIntent);
-
-                // result is handled in ACTION_IMPORT_KEYRING
-            } catch (Exception e) {
-                sendErrorToHandler(e);
-            }
-        } else if (ACTION_DOWNLOAD_AND_IMPORT_KEYS.equals(action)) {
             try {
                 ArrayList<ImportKeysListEntry> entries = data.getParcelableArrayList(DOWNLOAD_KEY_LIST);
 
                 // this downloads the keys and places them into the ImportKeysListEntry entries
                 String keyServer = data.getString(DOWNLOAD_KEY_SERVER);
-                HkpKeyserver server = new HkpKeyserver(keyServer);
 
                 ArrayList<ParcelableKeyRing> keyRings = new ArrayList<ParcelableKeyRing>(entries.size());
                 for (ImportKeysListEntry entry : entries) {
+
+                    Keyserver server;
+                    if (entry.getOrigin() == null) {
+                        server = new HkpKeyserver(keyServer);
+                    } else if (KeybaseKeyserver.ORIGIN.equals(entry.getOrigin())) {
+                        server = new KeybaseKeyserver();
+                    } else {
+                        server = new HkpKeyserver(entry.getOrigin());
+                    }
+
                     // if available use complete fingerprint for get request
                     byte[] downloadedKeyBytes;
-                    if (entry.getFingerprintHex() != null) {
+                    if (KeybaseKeyserver.ORIGIN.equals(entry.getOrigin())) {
+                        downloadedKeyBytes = server.get(entry.getExtraData()).getBytes();
+                    } else if (entry.getFingerprintHex() != null) {
                         downloadedKeyBytes = server.get("0x" + entry.getFingerprintHex()).getBytes();
                     } else {
                         downloadedKeyBytes = server.get(entry.getKeyIdHex()).getBytes();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/HelpActivity.java

@@ -25,7 +25,7 @@ import android.support.v7.app.ActionBarActivity;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.adapter.PagerTabStripAdapter;
-import org.sufficientlysecure.keychain.util.SlidingTabLayout;
+import org.sufficientlysecure.keychain.ui.widget.SlidingTabLayout;
 
 public class HelpActivity extends ActionBarActivity {
     public static final String EXTRA_SELECTED_TAB = "selected_tab";

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java

@@ -252,7 +252,7 @@ public class KeyListFragment extends LoaderFragment
     static final int INDEX_HAS_ANY_SECRET = 6;
 
     static final String ORDER =
-            KeyRings.HAS_ANY_SECRET + " DESC, " + KeyRings.USER_ID + " ASC";
+            KeyRings.HAS_ANY_SECRET + " DESC, UPPER(" + KeyRings.USER_ID + ") ASC";
 
 
     @Override
@@ -592,7 +592,7 @@ public class KeyListFragment extends LoaderFragment
             String userId = mCursor.getString(KeyListFragment.INDEX_USER_ID);
             String headerText = convertView.getResources().getString(R.string.user_id_no_name);
             if (userId != null && userId.length() > 0) {
-                headerText = "" + userId.subSequence(0, 1).charAt(0);
+                headerText = "" + userId.charAt(0);
             }
             holder.mText.setText(headerText);
             holder.mCount.setVisibility(View.GONE);
@@ -621,7 +621,7 @@ public class KeyListFragment extends LoaderFragment
             // otherwise, return the first character of the name as ID
             String userId = mCursor.getString(KeyListFragment.INDEX_USER_ID);
             if (userId != null && userId.length() > 0) {
-                return userId.charAt(0);
+                return Character.toUpperCase(userId.charAt(0));
             } else {
                 return Long.MAX_VALUE;
             }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java

@@ -20,6 +20,7 @@ package org.sufficientlysecure.keychain.ui;
 
 import android.annotation.TargetApi;
 import android.app.Activity;
+import android.content.Context;
 import android.content.Intent;
 import android.database.Cursor;
 import android.net.Uri;
@@ -32,6 +33,7 @@ import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
+import android.provider.ContactsContract;
 import android.support.v4.app.LoaderManager;
 import android.support.v4.content.CursorLoader;
 import android.support.v4.content.Loader;
@@ -47,6 +49,7 @@ import com.devspark.appmsg.AppMsg;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.helper.ContactHelper;
 import org.sufficientlysecure.keychain.helper.ExportHelper;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
@@ -54,7 +57,7 @@ import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.ui.adapter.PagerTabStripAdapter;
 import org.sufficientlysecure.keychain.util.Log;
-import org.sufficientlysecure.keychain.util.SlidingTabLayout;
+import org.sufficientlysecure.keychain.ui.widget.SlidingTabLayout;
 
 import java.util.Date;
 import java.util.HashMap;
@@ -92,6 +95,8 @@ public class ViewKeyActivity extends ActionBarActivity implements
 
     private static final int LOADER_ID_UNIFIED = 0;
 
+    private boolean mShowAdvancedTabs;
+
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
@@ -116,16 +121,13 @@ public class ViewKeyActivity extends ActionBarActivity implements
         mViewPager = (ViewPager) findViewById(R.id.view_key_pager);
         mSlidingTabLayout = (SlidingTabLayout) findViewById(R.id.view_key_sliding_tab_layout);
 
-        mTabsAdapter = new PagerTabStripAdapter(this);
-        mViewPager.setAdapter(mTabsAdapter);
-
         int switchToTab = TAB_MAIN;
         Intent intent = getIntent();
         if (intent.getExtras() != null && intent.getExtras().containsKey(EXTRA_SELECTED_TAB)) {
             switchToTab = intent.getExtras().getInt(EXTRA_SELECTED_TAB);
         }
 
-        Uri dataUri = getIntent().getData();
+        Uri dataUri = getDataUri();
         if (dataUri == null) {
             Log.e(Constants.TAG, "Data missing. Should be Uri of key!");
             finish();
@@ -136,6 +138,18 @@ public class ViewKeyActivity extends ActionBarActivity implements
 
         initNfc(dataUri);
 
+        mShowAdvancedTabs = false;
+
+        initTabs(dataUri);
+
+        // switch to tab selected by extra
+        mViewPager.setCurrentItem(switchToTab);
+    }
+
+    private void initTabs(Uri dataUri) {
+        mTabsAdapter = new PagerTabStripAdapter(this);
+        mViewPager.setAdapter(mTabsAdapter);
+
         Bundle mainBundle = new Bundle();
         mainBundle.putParcelable(ViewKeyMainFragment.ARG_DATA_URI, dataUri);
         mTabsAdapter.addTab(ViewKeyMainFragment.class,
@@ -146,6 +160,11 @@ public class ViewKeyActivity extends ActionBarActivity implements
         mTabsAdapter.addTab(ViewKeyShareFragment.class,
                 mainBundle, getString(R.string.key_view_tab_share));
 
+        // update layout after operations
+        mSlidingTabLayout.setViewPager(mViewPager);
+    }
+
+    private void addAdvancedTabs(Uri dataUri) {
         Bundle keyDetailsBundle = new Bundle();
         keyDetailsBundle.putParcelable(ViewKeyKeysFragment.ARG_DATA_URI, dataUri);
         mTabsAdapter.addTab(ViewKeyKeysFragment.class,
@@ -156,11 +175,54 @@ public class ViewKeyActivity extends ActionBarActivity implements
         mTabsAdapter.addTab(ViewKeyCertsFragment.class,
                 certBundle, getString(R.string.key_view_tab_certs));
 
-        // NOTE: must be after adding the tabs!
+        // update layout after operations
+        mSlidingTabLayout.setViewPager(mViewPager);
+    }
+
+    private void removeAdvancedTabs() {
+        // before removing, switch to the first tab if necessary
+        if (mViewPager.getCurrentItem() >= TAB_KEYS) {
+            // remove _after_ switching to the main tab
+            mViewPager.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
+                @Override
+                public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
+                }
+
+                @Override
+                public void onPageSelected(int position) {
+                }
+
+                @Override
+                public void onPageScrollStateChanged(int state) {
+                    if (ViewPager.SCROLL_STATE_SETTLING == state) {
+                        mTabsAdapter.removeTab(TAB_CERTS);
+                        mTabsAdapter.removeTab(TAB_KEYS);
+
+                        // update layout after operations
                         mSlidingTabLayout.setViewPager(mViewPager);
 
-        // switch to tab selected by extra
+                        // remove this listener again
-        mViewPager.setCurrentItem(switchToTab);
+//                        mViewPager.setOnPageChangeListener(null);
+                    }
+                }
+            });
+
+            mViewPager.setCurrentItem(TAB_MAIN);
+        } else {
+            mTabsAdapter.removeTab(TAB_CERTS);
+            mTabsAdapter.removeTab(TAB_KEYS);
+        }
+
+        // update layout after operations
+        mSlidingTabLayout.setViewPager(mViewPager);
+    }
+
+    private Uri getDataUri() {
+        Uri dataUri = getIntent().getData();
+        if (dataUri != null && dataUri.getHost().equals(ContactsContract.AUTHORITY)) {
+            dataUri = ContactHelper.dataUriFromContactUri(this, dataUri);
+        }
+        return dataUri;
     }
 
     private void loadData(Uri dataUri) {
@@ -177,6 +239,9 @@ public class ViewKeyActivity extends ActionBarActivity implements
     public boolean onCreateOptionsMenu(Menu menu) {
         super.onCreateOptionsMenu(menu);
         getMenuInflater().inflate(R.menu.key_view, menu);
+
+        MenuItem showAdvancedInfoItem = menu.findItem(R.id.menu_key_view_advanced);
+        showAdvancedInfoItem.setChecked(mShowAdvancedTabs);
         return true;
     }
 
@@ -184,24 +249,37 @@ public class ViewKeyActivity extends ActionBarActivity implements
     public boolean onOptionsItemSelected(MenuItem item) {
         try {
             switch (item.getItemId()) {
-                case android.R.id.home:
+                case android.R.id.home: {
                     Intent homeIntent = new Intent(this, KeyListActivity.class);
                     homeIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
                     startActivity(homeIntent);
                     return true;
-                case R.id.menu_key_view_update:
+                }
+                case R.id.menu_key_view_update: {
                     updateFromKeyserver(mDataUri, mProviderHelper);
                     return true;
-                case R.id.menu_key_view_export_keyserver:
+                }
+                case R.id.menu_key_view_export_keyserver: {
                     uploadToKeyserver(mDataUri);
                     return true;
-                case R.id.menu_key_view_export_file:
+                }
+                case R.id.menu_key_view_export_file: {
                     exportToFile(mDataUri, mExportHelper, mProviderHelper);
                     return true;
+                }
                 case R.id.menu_key_view_delete: {
                     deleteKey(mDataUri, mExportHelper);
                     return true;
                 }
+                case R.id.menu_key_view_advanced: {
+                    mShowAdvancedTabs = !mShowAdvancedTabs;
+                    item.setChecked(mShowAdvancedTabs);
+                    if (mShowAdvancedTabs) {
+                        addAdvancedTabs(mDataUri);
+                    } else {
+                        removeAdvancedTabs();
+                    }
+                }
             }
         } catch (ProviderHelper.NotFoundException e) {
             AppMsg.makeText(this, R.string.error_key_not_found, AppMsg.STYLE_ALERT).show();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysAdapter.java

@@ -33,7 +33,6 @@ import android.widget.TextView;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
 import org.sufficientlysecure.keychain.util.Highlighter;
 
 import java.util.ArrayList;
@@ -120,13 +119,13 @@ public class ImportKeysAdapter extends ArrayAdapter<ImportKeysListEntry> {
         }
 
         // main user id
-        String userId = entry.userIds.get(0);
+        String userId = entry.getUserIds().get(0);
         String[] userIdSplit = KeyRing.splitUserId(userId);
 
         // name
         if (userIdSplit[0] != null) {
             // show red user id if it is a secret key
-            if (entry.secretKey) {
+            if (entry.isSecretKey()) {
                 holder.mainUserId.setText(mActivity.getString(R.string.secret_key)
                         + " " + userIdSplit[0]);
                 holder.mainUserId.setTextColor(Color.RED);
@@ -147,30 +146,26 @@ public class ImportKeysAdapter extends ArrayAdapter<ImportKeysListEntry> {
             holder.mainUserIdRest.setVisibility(View.GONE);
         }
 
-        holder.keyId.setText(entry.keyIdHex);
+        holder.keyId.setText(entry.getKeyIdHex());
 
-        if (entry.fingerprintHex != null) {
+        // don't show full fingerprint on key import
-            holder.fingerprint.setVisibility(View.VISIBLE);
-            holder.fingerprint.setText(PgpKeyHelper.colorizeFingerprint(entry.fingerprintHex));
-        } else {
         holder.fingerprint.setVisibility(View.GONE);
-        }
 
-        if (entry.bitStrength != 0 && entry.algorithm != null) {
+        if (entry.getBitStrength() != 0 && entry.getAlgorithm() != null) {
-            holder.algorithm.setText("" + entry.bitStrength + "/" + entry.algorithm);
+            holder.algorithm.setText("" + entry.getBitStrength() + "/" + entry.getAlgorithm());
             holder.algorithm.setVisibility(View.VISIBLE);
         } else {
             holder.algorithm.setVisibility(View.INVISIBLE);
         }
 
-        if (entry.revoked) {
+        if (entry.isRevoked()) {
             holder.status.setVisibility(View.VISIBLE);
             holder.status.setText(R.string.revoked);
         } else {
             holder.status.setVisibility(View.GONE);
         }
 
-        if (entry.userIds.size() == 1) {
+        if (entry.getUserIds().size() == 1) {
             holder.userIdsList.setVisibility(View.GONE);
         } else {
             holder.userIdsList.setVisibility(View.VISIBLE);
@@ -178,7 +173,7 @@ public class ImportKeysAdapter extends ArrayAdapter<ImportKeysListEntry> {
             // clear view from holder
             holder.userIdsList.removeAllViews();
 
-            Iterator<String> it = entry.userIds.iterator();
+            Iterator<String> it = entry.getUserIds().iterator();
             // skip primary user id
             it.next();
             while (it.hasNext()) {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/PagerTabStripAdapter.java

@@ -20,8 +20,13 @@ package org.sufficientlysecure.keychain.ui.adapter;
 import android.app.Activity;
 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.v7.app.ActionBarActivity;
+import android.view.ViewGroup;
+
+import org.sufficientlysecure.keychain.Constants;
 
 import java.util.ArrayList;
 
@@ -52,6 +57,11 @@ public class PagerTabStripAdapter extends FragmentPagerAdapter {
         notifyDataSetChanged();
     }
 
+    public void removeTab(int index) {
+        mTabs.remove(index);
+        notifyDataSetChanged();
+    }
+
     @Override
     public int getCount() {
         return mTabs.size();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/SlidingTabLayout.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.sufficientlysecure.keychain.util;
+package org.sufficientlysecure.keychain.ui.widget;
 
 import android.content.Context;
 import android.graphics.Typeface;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/SlidingTabStrip.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.sufficientlysecure.keychain.util;
+package org.sufficientlysecure.keychain.ui.widget;
 
 import android.R;
 import android.content.Context;

OpenKeychain/src/main/res/layout/help_activity.xml

@@ -4,7 +4,7 @@
     android:layout_height="match_parent"
     android:orientation="vertical" >
 
-    <org.sufficientlysecure.keychain.util.SlidingTabLayout
+    <org.sufficientlysecure.keychain.ui.widget.SlidingTabLayout
         android:id="@+id/sliding_tab_layout"
         android:layout_width="match_parent"
         android:layout_height="wrap_content" />

OpenKeychain/src/main/res/layout/view_key_activity.xml

@@ -35,7 +35,7 @@
         android:visibility="gone"
         android:id="@+id/status_divider" />
 
-    <org.sufficientlysecure.keychain.util.SlidingTabLayout
+    <org.sufficientlysecure.keychain.ui.widget.SlidingTabLayout
         android:id="@+id/view_key_sliding_tab_layout"
         android:layout_width="match_parent"
         android:layout_height="wrap_content" />

OpenKeychain/src/main/res/menu/key_view.xml

@@ -31,4 +31,10 @@
         app:showAsAction="never"
         android:title="@string/menu_delete_key" />
 
+    <item
+        android:id="@+id/menu_key_view_advanced"
+        app:showAsAction="never"
+        android:checkable="true"
+        android:title="@string/menu_advanced" />
+
 </menu>

OpenKeychain/src/main/res/values/strings.xml

@@ -103,6 +103,7 @@
     <string name="menu_select_all">Select all</string>
     <string name="menu_add_keys">Add keys</string>
     <string name="menu_export_all_keys">Export all keys</string>
+    <string name="menu_advanced">Show advanced info</string>
 
     <!-- label -->
     <string name="label_sign">Sign</string>
@@ -609,5 +610,7 @@
     <string name="can_sign_not">cannot sign</string>
     <string name="error_encoding">Encoding error</string>
     <string name="error_no_encrypt_subkey">No encryption subkey available!</string>
+    <string name="info_no_manual_account_creation">Do not create OpenKeychain-Accounts manually.\nFor more information, see Help.</string>
+    <string name="contact_show_key">Show key (%s)</string>
 
 </resources>

OpenKeychain/src/main/res/xml/account_desc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<account-authenticator xmlns:android="http://schemas.android.com/apk/res/android"
+                       android:accountType="org.sufficientlysecure.keychain"
+                       android:icon="@drawable/icon"
+                       android:label="@string/app_name"/>

OpenKeychain/src/main/res/xml/custom_pgp_contacts_structure.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ContactsSource xmlns:android="http://schemas.android.com/apk/res/android">
+    <ContactsDataKind android:mimeType="vnd.android.cursor.item/vnd.org.sufficientlysecure.keychain.key"
+                      android:detailColumn="data1"/>
+</ContactsSource>

OpenKeychain/src/main/res/xml/sync_adapter_desc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<sync-adapter xmlns:android="http://schemas.android.com/apk/res/android"
+              android:contentAuthority="com.android.contacts"
+              android:accountType="org.sufficientlysecure.keychain"
+              android:supportsUploading="false"
+              android:userVisible="true"/>

README.md

@@ -33,7 +33,7 @@ Development mailinglist at http://groups.google.com/d/forum/openpgp-keychain-dev
 1. Get all external submodules with ``git submodule update --init --recursive``
 2. Have Android SDK "tools", "platform-tools", and "build-tools" directories in your PATH (http://developer.android.com/sdk/index.html)
 3. Open the Android SDK Manager (shell command: ``android``).  
-Expand the Tools directory and select "Android SDK Build-tools (Version 19.0.3)".  
+Expand the Tools directory and select "Android SDK Build-tools (Version 19.1)".  
 Expand the Extras directory and install "Android Support Repository"  
 Select everything for the newest SDK Platform (API-Level 19)
 4. Export ANDROID_HOME pointing to your Android SDK
@@ -42,8 +42,8 @@ Select everything for the newest SDK Platform (API-Level 19)
 
 ### Build API Demo with Gradle
 
-1. Follow 1-3 from above
+1. Follow 1-4 from above
-2. Change to API Demo directory ``cd OpenKeychain-API``
+2. The example code is available at https://github.com/open-keychain/api-example
 3. Execute ``./gradlew build``
 
 ### Development with Android Studio

build.gradle

@@ -5,8 +5,8 @@ buildscript {
 
     dependencies {
         // NOTE: Always use fixed version codes not dynamic ones, e.g. 0.7.3 instead of 0.7.+, see README for more information
-        classpath 'com.android.tools.build:gradle:0.10.0'
+        classpath 'com.android.tools.build:gradle:0.11.1'
-        classpath 'org.robolectric.gradle:gradle-android-test-plugin:0.10.0'
+        //classpath 'org.robolectric.gradle:gradle-android-test-plugin:0.10.0'
     }
 }
 
@@ -17,5 +17,5 @@ allprojects {
 }
 
 task wrapper(type: Wrapper) {
-    gradleVersion = '1.10'
+    gradleVersion = '1.12'
 }

extern/AndroidBootstrap

@@ -1 +1 @@
-Subproject commit bfa160c4ef3a1a53aebd68aca9c05b8e546219e0
+Subproject commit 02f02391e3eee9331e07d7690d3b533a8b0f69e2

extern/AppMsg

@@ -1 +1 @@
-Subproject commit ca714df97bfce67a7a9a1efefd2c49645b6f22e4
+Subproject commit 61e74741909a712db2e0d31ddffa5b7cf37c21f2

extern/StickyListHeaders

@@ -1 +1 @@
-Subproject commit efe46c21143cc54a2394303a67822f14580d1d20
+Subproject commit 706c0e447229226b6edc82ab10630d39fd0f6c38

extern/SuperToasts

@@ -1 +1 @@
-Subproject commit e93d50cbf06e4dd7d61d33b6435eb3e7a75a152d
+Subproject commit 8578cfe6917cf16a9f123c1964e4bbff2a15be59

extern/dnsjava

@@ -0,0 +1 @@
+Subproject commit 71c8a9e56b19b34907e7e2e810ca15b57e3edc2b

extern/html-textview

@@ -1 +1 @@
-Subproject commit c31ef2aff4282ad00af98e879e3e0a6000885b55
+Subproject commit eedaa334e761273efbfc49ded2124df58c8a4d88

extern/openkeychain-api-lib

@@ -1 +1 @@
-Subproject commit 26497acb27e9f6349c0557b15cd24a5b0b735e74
+Subproject commit 175a3cb772c88c9b50985abc98f81c9ea69c3659

extern/openpgp-api-lib

@@ -1 +1 @@
-Subproject commit 650e1ebda82596cd4fbfaae406e6eccf189f4f63
+Subproject commit a77887d32fae68171fcd0d2989bf537c0c11f0b9

extern/zxing-android-integration

@@ -1 +1 @@
-Subproject commit 34029d4dcac81ec06137a046a189dac608e76efe
+Subproject commit 1d787845663fd232f98f5e8e0923733c1a188f2a

extern/zxing-qr-code

@@ -1 +1 @@
-Subproject commit 50193905fd8cef92140ea242f77b04bb31391c9e
+Subproject commit 9ef2f3b66ea7cc283e865ec39434d023a18d17f3

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Thu Mar 06 22:23:44 CET 2014
+#Mon Jun 09 22:04:23 CEST 2014
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=http\://services.gradle.org/distributions/gradle-1.10-bin.zip
+distributionUrl=http\://services.gradle.org/distributions/gradle-1.12-bin.zip

settings.gradle

@@ -12,3 +12,4 @@ include ':extern:spongycastle:pkix'
 include ':extern:spongycastle:prov'
 include ':extern:AppMsg:library'
 include ':extern:SuperToasts:supertoasts'
+include ':extern:dnsjava'