Renaming APG to OpenPGP Keychain

23 files changed, 1615 insertions, 0 deletions

diff --git a/OpenPGP-Keychain-API-Lib/.gitignore b/OpenPGP-Keychain-API-Lib/.gitignore
new file mode 100644
index 000000000..2e423e1a3
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/.gitignore
@@ -0,0 +1,23 @@
+#Android generated
+bin
+gen
+obj
+libs/armeabi
+lint.xml
+local.properties
+
+#Eclipse
+.project
+.classpath
+.settings
+
+#IntelliJ IDEA
+.idea
+*.iml
+
+#Maven
+target
+release.properties
+
+#Mac
+.DS_Store
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/AndroidManifest.xml b/OpenPGP-Keychain-API-Lib/AndroidManifest.xml
new file mode 100644
index 000000000..afdcaaedf
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/AndroidManifest.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="org.sufficientlysecure.keychain.integration"
+    android:versionCode="1"
+    android:versionName="1.0" >
+
+    <uses-sdk
+        android:minSdkVersion="7"
+        android:targetSdkVersion="14" />
+
+</manifest>
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/build.xml b/OpenPGP-Keychain-API-Lib/build.xml
new file mode 100644
index 000000000..895594080
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/build.xml
@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project name="apg_integration_lib" default="help">
+
+    <!-- The local.properties file is created and updated by the 'android' tool.
+         It contains the path to the SDK. It should *NOT* be checked into
+         Version Control Systems. -->
+    <property file="local.properties" />
+
+    <!-- The ant.properties file can be created by you. It is only edited by the
+         'android' tool to add properties to it.
+         This is the place to change some Ant specific build properties.
+         Here are some properties you may want to change/update:
+
+         source.dir
+             The name of the source directory. Default is 'src'.
+         out.dir
+             The name of the output directory. Default is 'bin'.
+
+         For other overridable properties, look at the beginning of the rules
+         files in the SDK, at tools/ant/build.xml
+
+         Properties related to the SDK location or the project target should
+         be updated using the 'android' tool with the 'update' action.
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems.
+
+         -->
+    <property file="ant.properties" />
+
+    <!-- The project.properties file is created and updated by the 'android'
+         tool, as well as ADT.
+
+         This contains project specific properties such as project target, and library
+         dependencies. Lower level build properties are stored in ant.properties
+         (or in .classpath for Eclipse projects).
+
+         This file is an integral part of the build system for your
+         application and should be checked into Version Control Systems. -->
+    <loadproperties srcFile="project.properties" />
+
+    <!-- quick check on sdk.dir -->
+    <fail
+            message="sdk.dir is missing. Make sure to generate local.properties using 'android update project' or to inject it through an env var"
+            unless="sdk.dir"
+    />
+
+    <!--
+        Import per project custom build rules if present at the root of the project.
+        This is the place to put custom intermediary targets such as:
+            -pre-build
+            -pre-compile
+            -post-compile (This is typically used for code obfuscation.
+                           Compiled code location: ${out.classes.absolute.dir}
+                           If this is not done in place, override ${out.dex.input.absolute.dir})
+            -post-package
+            -post-build
+            -pre-clean
+    -->
+    <import file="custom_rules.xml" optional="true" />
+
+    <!-- Import the actual build file.
+
+         To customize existing targets, there are two options:
+         - Customize only one target:
+             - copy/paste the target into this file, *before* the
+               <import> task.
+             - customize it to your needs.
+         - Customize the whole content of build.xml
+             - copy/paste the content of the rules files (minus the top node)
+               into this file, replacing the <import> task.
+             - customize to your needs.
+
+         ***********************
+         ****** IMPORTANT ******
+         ***********************
+         In all cases you must update the value of version-tag below to read 'custom' instead of an integer,
+         in order to avoid having your file be overridden by tools such as "android update project"
+    -->
+    <!-- version-tag: 1 -->
+    <import file="${sdk.dir}/tools/ant/build.xml" />
+
+</project>
diff --git a/OpenPGP-Keychain-API-Lib/libs/android-support-v4.jar b/OpenPGP-Keychain-API-Lib/libs/android-support-v4.jar
new file mode 100644
index 000000000..99e063b33
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/libs/android-support-v4.jar
diff --git a/OpenPGP-Keychain-API-Lib/proguard-project.txt b/OpenPGP-Keychain-API-Lib/proguard-project.txt
new file mode 100644
index 000000000..f2fe1559a
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/proguard-project.txt
@@ -0,0 +1,20 @@
+# To enable ProGuard in your project, edit project.properties
+# to define the proguard.config property as described in that file.
+#
+# Add project specific ProGuard rules here.
+# By default, the flags in this file are appended to flags specified
+# in ${sdk.dir}/tools/proguard/proguard-android.txt
+# You can edit the include path and order by changing the ProGuard
+# include property in project.properties.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# Add any project specific keep options here:
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
diff --git a/OpenPGP-Keychain-API-Lib/project.properties b/OpenPGP-Keychain-API-Lib/project.properties
new file mode 100644
index 000000000..36f15941e
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/project.properties
@@ -0,0 +1,15 @@
+# This file is automatically generated by Android Tools.
+# Do not modify this file -- YOUR CHANGES WILL BE ERASED!
+#
+# This file must be checked in Version Control Systems.
+#
+# To customize properties used by the Ant build system edit
+# "ant.properties", and override values to adapt the script to your
+# project structure.
+#
+# To enable ProGuard to shrink and obfuscate your code, uncomment this (available properties: sdk.dir, user.home):
+#proguard.config=${sdk.dir}/tools/proguard/proguard-android.txt:proguard-project.txt
+
+# Project target.
+target=android-15
+android.library=true
diff --git a/OpenPGP-Keychain-API-Lib/res/.readme b/OpenPGP-Keychain-API-Lib/res/.readme
new file mode 100644
index 000000000..97473e05c
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/res/.readme
@@ -0,0 +1 @@
+Directory must be empty. Then Android will build a jar instead of an apk!
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/Constants.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/Constants.java
new file mode 100644
index 000000000..51998a33e
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/Constants.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+public class Constants {
+    public static final String TAG = "Keychain Integration Lib";
+
+    public static final String KEYCHAIN_PACKAGE_NAME = "org.sufficientlysecure.keychain";
+    public static final int MIN_REQUIRED_VERSION = 50;
+
+}
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainContentProviderHelper.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainContentProviderHelper.java
new file mode 100644
index 000000000..bc2a4ad7a
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainContentProviderHelper.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2010-2011 K-9 Mail Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import android.content.ContentUris;
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.widget.Toast;
+
+public class KeychainContentProviderHelper {
+    public static final String AUTHORITY = Constants.KEYCHAIN_PACKAGE_NAME;
+
+    public static final Uri CONTENT_URI_PUBLIC_KEY_RING_BY_KEY_ID = Uri.parse("content://"
+            + AUTHORITY + "/key_rings/public/key_id/");
+    public static final Uri CONTENT_URI_PUBLIC_KEY_RING_BY_EMAILS = Uri.parse("content://"
+            + AUTHORITY + "/key_rings/public/emails/");
+    public static final Uri CONTENT_URI_PUBLIC_KEY_RING_BY_LIKE_EMAIL = Uri.parse("content://"
+            + AUTHORITY + "/key_rings/public/like_email/");
+
+    public static final Uri CONTENT_URI_SECRET_KEY_RING_BY_KEY_ID = Uri.parse("content://"
+            + AUTHORITY + "/key_rings/secret/key_id/");
+    public static final Uri CONTENT_URI_SECRET_KEY_RING_BY_EMAILS = Uri.parse("content://"
+            + AUTHORITY + "/key_rings/secret/emails/");
+    public static final Uri CONTENT_URI_SECRET_KEY_RING_BY_LIKE_EMAIL = Uri.parse("content://"
+            + AUTHORITY + "/key_rings/secret/like_email/");
+
+    private Context mContext;
+
+    public KeychainContentProviderHelper(Context context) {
+        this.mContext = context;
+    }
+
+    /**
+     * Get secret key ids based on a given email.
+     * 
+     * @param context
+     * @param email
+     *            The email in question.
+     * @return key ids
+     */
+    public long[] getSecretKeyringIdsByEmail(String email) {
+        long ids[] = null;
+        try {
+            Uri contentUri = Uri.withAppendedPath(CONTENT_URI_SECRET_KEY_RING_BY_EMAILS, email);
+            Cursor c = mContext.getContentResolver().query(contentUri,
+                    new String[] { "master_key_id" }, null, null, null);
+            if (c != null && c.getCount() > 0) {
+                ids = new long[c.getCount()];
+                while (c.moveToNext()) {
+                    ids[c.getPosition()] = c.getLong(0);
+                }
+            }
+
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+
+        return ids;
+    }
+
+    /**
+     * Get secret key ids based on a given String that is part of the email.
+     * 
+     * Example: String: example, then emails: test@example.com, example@google.com are returned
+     * 
+     * @param context
+     * @param email
+     *            The email in question.
+     * @return key ids
+     */
+    public long[] getSecretKeyringIdsByLikeEmail(String likeEmail) {
+        long ids[] = null;
+        try {
+            Uri contentUri = Uri.withAppendedPath(CONTENT_URI_SECRET_KEY_RING_BY_LIKE_EMAIL,
+                    likeEmail);
+            Cursor c = mContext.getContentResolver().query(contentUri,
+                    new String[] { "master_key_id" }, null, null, null);
+            if (c != null && c.getCount() > 0) {
+                ids = new long[c.getCount()];
+                while (c.moveToNext()) {
+                    ids[c.getPosition()] = c.getLong(0);
+                }
+            }
+
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+
+        return ids;
+    }
+
+    /**
+     * Get public key ids based on a given email.
+     * 
+     * @param context
+     * @param email
+     *            The email in question.
+     * @return key ids
+     */
+    public long[] getPublicKeyringIdsByEmail(String email) {
+        long ids[] = null;
+        try {
+            Uri contentUri = Uri.withAppendedPath(CONTENT_URI_PUBLIC_KEY_RING_BY_EMAILS, email);
+            Cursor c = mContext.getContentResolver().query(contentUri,
+                    new String[] { "master_key_id" }, null, null, null);
+            if (c != null && c.getCount() > 0) {
+                ids = new long[c.getCount()];
+                while (c.moveToNext()) {
+                    ids[c.getPosition()] = c.getLong(0);
+                }
+            }
+
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+
+        return ids;
+    }
+
+    /**
+     * Get public key ids based on a given String that is part of the email.
+     * 
+     * Example: String: example, then emails: test@example.com, example@google.com are returned
+     * 
+     * @param context
+     * @param email
+     *            The email in question.
+     * @return key ids
+     */
+    public long[] getPublicKeyringIdsByLikeEmail(String likeEmail) {
+        long ids[] = null;
+        try {
+            Uri contentUri = Uri.withAppendedPath(CONTENT_URI_PUBLIC_KEY_RING_BY_LIKE_EMAIL,
+                    likeEmail);
+            Cursor c = mContext.getContentResolver().query(contentUri,
+                    new String[] { "master_key_id" }, null, null, null);
+            if (c != null && c.getCount() > 0) {
+                ids = new long[c.getCount()];
+                while (c.moveToNext()) {
+                    ids[c.getPosition()] = c.getLong(0);
+                }
+            }
+
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+
+        return ids;
+    }
+
+    /**
+     * Find out if a given email has a secret key.
+     * 
+     * @param context
+     * @param email
+     *            The email in question.
+     * @return true if there is a secret key for this email.
+     */
+    public boolean hasSecretKeyringByEmail(String email) {
+        try {
+            Uri contentUri = Uri.withAppendedPath(CONTENT_URI_SECRET_KEY_RING_BY_EMAILS, email);
+            Cursor c = mContext.getContentResolver().query(contentUri,
+                    new String[] { "master_key_id" }, null, null, null);
+            if (c != null && c.getCount() > 0) {
+                c.close();
+                return true;
+            }
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+        return false;
+    }
+
+    /**
+     * Find out if a given email has a public key.
+     * 
+     * @param context
+     * @param email
+     *            The email in question.
+     * @return true if there is a public key for this email.
+     */
+    public boolean hasPublicKeyringByEmail(String email) {
+        try {
+            Uri contentUri = Uri.withAppendedPath(CONTENT_URI_PUBLIC_KEY_RING_BY_EMAILS, email);
+            Cursor c = mContext.getContentResolver().query(contentUri,
+                    new String[] { "master_key_id" }, null, null, null);
+            if (c != null && c.getCount() > 0) {
+                c.close();
+                return true;
+            }
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+        return false;
+    }
+
+    /**
+     * Get the user id based on the key id.
+     * 
+     * @param context
+     * @param keyId
+     * @return user id
+     */
+    public String getUserId(long keyId) {
+        String userId = null;
+        try {
+            Uri contentUri = ContentUris.withAppendedId(CONTENT_URI_SECRET_KEY_RING_BY_KEY_ID,
+                    keyId);
+            Cursor c = mContext.getContentResolver().query(contentUri, new String[] { "user_id" },
+                    null, null, null);
+            if (c != null && c.moveToFirst()) {
+                userId = c.getString(0);
+            }
+
+            if (c != null) {
+                c.close();
+            }
+        } catch (SecurityException e) {
+            insufficientPermissions();
+        }
+
+        if (userId == null) {
+            userId = "unknown";
+        }
+        return userId;
+    }
+
+    private void insufficientPermissions() {
+        Toast.makeText(mContext, "Permission to access APG Provider is missing!", Toast.LENGTH_LONG)
+                .show();
+    }
+}
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainData.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainData.java
new file mode 100644
index 000000000..619909c65
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainData.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2010-2011 K-9 Mail Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import java.io.Serializable;
+import java.util.Arrays;
+
+public class KeychainData implements Serializable {
+    private static final long serialVersionUID = 6314045536270848410L;
+    protected long[] mPublicKeyIds = null;
+    protected String[] mPublicUserIds = null;
+    protected long mSecretKeyId = 0;
+    protected String mSecretKeyUserId = null;
+    protected boolean mSignatureSuccess = false;
+    protected boolean mSignatureUnknown = false;
+    protected String mDecryptedData = null;
+    protected String mEncryptedData = null;
+
+    public void setSecretKeyId(long keyId) {
+        mSecretKeyId = keyId;
+    }
+
+    public long getSecretKeyId() {
+        return mSecretKeyId;
+    }
+
+    public void setPublicKeyIds(long[] keyIds) {
+        mPublicKeyIds = keyIds;
+    }
+
+    public long[] getPublicKeys() {
+        return mPublicKeyIds;
+    }
+
+    public void setPublicUserIds(String[] userIds) {
+        mPublicUserIds = userIds;
+    }
+
+    public String[] getPublicUserIds() {
+        return mPublicUserIds;
+    }
+
+    public boolean hasSecretKey() {
+        return mSecretKeyId != 0;
+    }
+
+    public boolean hasPublicKeys() {
+        return (mPublicKeyIds != null) && (mPublicKeyIds.length > 0);
+    }
+
+    public String getEncryptedData() {
+        return mEncryptedData;
+    }
+
+    public void setEncryptedData(String data) {
+        mEncryptedData = data;
+    }
+
+    public String getDecryptedData() {
+        return mDecryptedData;
+    }
+
+    public void setDecryptedData(String data) {
+        mDecryptedData = data;
+    }
+
+    public void setSecretKeyUserId(String userId) {
+        mSecretKeyUserId = userId;
+    }
+
+    public String getSecretKeyUserId() {
+        return mSecretKeyUserId;
+    }
+
+    public boolean getSignatureSuccess() {
+        return mSignatureSuccess;
+    }
+
+    public void setSignatureSuccess(boolean success) {
+        mSignatureSuccess = success;
+    }
+
+    public boolean getSignatureUnknown() {
+        return mSignatureUnknown;
+    }
+
+    public void setSignatureUnknown(boolean unknown) {
+        mSignatureUnknown = unknown;
+    }
+
+    @Override
+    public String toString() {
+        String output = "mPublicKeyIds: " + Arrays.toString(mPublicKeyIds) + "\nmSecretKeyId: "
+                + mSecretKeyId + "\nmSecretKeyUserId: " + mSecretKeyUserId
+                + "\nmSignatureSuccess: " + mSignatureSuccess + "\nmSignatureUnknown: "
+                + mSignatureUnknown + "\nmDecryptedData: " + mDecryptedData + "\nmEncryptedData: "
+                + mEncryptedData;
+
+        return output;
+    }
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelper.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelper.java
new file mode 100644
index 000000000..756dd974b
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelper.java
@@ -0,0 +1,451 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2010-2011 K-9 Mail Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import android.app.Activity;
+import android.content.ActivityNotFoundException;
+import android.content.Intent;
+import android.widget.Toast;
+
+public class KeychainIntentHelper {
+
+    public static final String APG_INTENT_PREFIX = "org.thialfihar.android.apg.intent.";
+
+    // Intents
+    /**
+     * Encrypt
+     */
+    // without permission
+    public static final String ACTION_ENCRYPT = APG_INTENT_PREFIX + "ENCRYPT";
+    public static final String ACTION_ENCRYPT_FILE = APG_INTENT_PREFIX + "ENCRYPT_FILE";
+
+    // with permission
+    public static final String ACTION_ENCRYPT_AND_RETURN = APG_INTENT_PREFIX + "ENCRYPT_AND_RETURN";
+    public static final String ACTION_GENERATE_SIGNATURE_AND_RETURN = APG_INTENT_PREFIX
+            + "GENERATE_SIGNATURE_AND_RETURN";
+    public static final String ACTION_ENCRYPT_STREAM_AND_RETURN = APG_INTENT_PREFIX
+            + "ENCRYPT_STREAM_AND_RETURN";
+
+    /**
+     * Decrypt
+     */
+    // without permission
+    public static final String ACTION_DECRYPT = APG_INTENT_PREFIX + "DECRYPT";
+    public static final String ACTION_DECRYPT_FILE = APG_INTENT_PREFIX + "DECRYPT_FILE";
+
+    // with permission
+    public static final String ACTION_DECRYPT_AND_RETURN = APG_INTENT_PREFIX + "DECRYPT_AND_RETURN";
+    public static final String ACTION_DECRYPT_STREAM_AND_RETURN = APG_INTENT_PREFIX
+            + "DECRYPT_STREAM_AND_RETURN";
+
+    /**
+     * Select keys, without permission
+     */
+    public static final String ACTION_SELECT_PUBLIC_KEYS = APG_INTENT_PREFIX + "SELECT_PUBLIC_KEYS";
+    public static final String ACTION_SELECT_SECRET_KEY = APG_INTENT_PREFIX + "SELECT_SECRET_KEY";
+
+    /**
+     * Create key/edit key, without permission
+     */
+    public static final String ACTION_CREATE_KEY = APG_INTENT_PREFIX + "CREATE_KEY";
+    public static final String ACTION_EDIT_KEY = APG_INTENT_PREFIX + "EDIT_KEY";
+
+    /**
+     * Import actions
+     */
+    public static final String ACTION_IMPORT = APG_INTENT_PREFIX + "IMPORT";
+
+    // only used by IMPORT
+    public static final String EXTRA_IMPORT_TEXT = "text";
+    public static final String EXTRA_IMPORT_KEYRING_BYTES = "keyringBytes";
+
+    public static final String ACTION_IMPORT_FROM_FILE = APG_INTENT_PREFIX + "IMPORT_FROM_FILE";
+    public static final String ACTION_IMPORT_FROM_QR_CODE = APG_INTENT_PREFIX
+            + "IMPORT_FROM_QR_CODE";
+
+    /**
+     * Share actions
+     */
+    public static final String ACTION_SHARE_KEYRING = APG_INTENT_PREFIX + "SHARE_KEYRING";
+    public static final String ACTION_SHARE_KEYRING_WITH_QR_CODE = APG_INTENT_PREFIX
+            + "SHARE_KEYRING_WITH_QR_CODE";
+    public static final String ACTION_SHARE_KEYRING_WITH_NFC = APG_INTENT_PREFIX
+            + "SHARE_KEYRING_WITH_NFC";
+
+    // used by SHARE_WITH_QR_CODE and SHARE_WITH_NFC
+    public static final String EXTRA_MASTER_KEY_ID = "masterKeyId";
+
+    public static final String EXTRA_TEXT = "text";
+    public static final String EXTRA_DATA = "data";
+    public static final String EXTRA_ERROR = "error";
+    public static final String EXTRA_DECRYPTED_MESSAGE = "decryptedMessage";
+    public static final String EXTRA_ENCRYPTED_MESSAGE = "encryptedMessage";
+    public static final String EXTRA_SIGNATURE = "signature";
+    public static final String EXTRA_SIGNATURE_KEY_ID = "signatureKeyId";
+    public static final String EXTRA_SIGNATURE_USER_ID = "signatureUserId";
+    public static final String EXTRA_SIGNATURE_SUCCESS = "signatureSuccess";
+    public static final String EXTRA_SIGNATURE_UNKNOWN = "signatureUnknown";
+    public static final String EXTRA_USER_ID = "userId";
+    public static final String EXTRA_USER_IDS = "userIds";
+    public static final String EXTRA_KEY_ID = "masterKeyId";
+    public static final String EXTRA_ENCRYPTION_KEY_IDS = "encryptionKeyIds";
+    public static final String EXTRA_SELECTION = "selection";
+    public static final String EXTRA_MESSAGE = "message";
+    public static final String EXTRA_NO_PASSPHRASE = "noPassphrase";
+    public static final String EXTRA_GENERATE_DEFAULT_KEYS = "generateDefaultKeys";
+    public static final String EXTRA_INTENT_VERSION = "intentVersion";
+
+    public static final String RESULT_EXTRA_MASTER_KEY_IDS = "masterKeyIds";
+    public static final String RESULT_EXTRA_USER_IDS = "userIds";
+
+    // result from EditKey
+    public static final String RESULT_EXTRA_MASTER_KEY_ID = "masterKeyId";
+    public static final String RESULT_EXTRA_USER_ID = "userId";
+
+    public static final String INTENT_VERSION = "1";
+
+    public static final int DECRYPT_MESSAGE = 0x00007121;
+    public static final int ENCRYPT_MESSAGE = 0x00007122;
+    public static final int SELECT_PUBLIC_KEYS = 0x00007123;
+    public static final int SELECT_SECRET_KEY = 0x00007124;
+    public static final int CREATE_KEY = 0x00007125;
+    public static final int EDIT_KEY = 0x00007126;
+
+    private Activity activity;
+
+    public KeychainIntentHelper(Activity activity) {
+        this.activity = activity;
+    }
+
+    /**
+     * Start an activity.<br>
+     * This method is defined to allow different methods of activity starting for newer versions of
+     * Android and for compatibility library.
+     * 
+     * @param intent
+     *            Intent to start.
+     * @param code
+     *            Request code for the activity
+     * @see android.app.Activity#startActivityForResult(Intent, int)
+     * @see android.app.Fragment#startActivityForResult(Intent, int)
+     */
+    protected void startActivityForResult(Intent intent, int code) {
+        activity.startActivityForResult(intent, code);
+    }
+
+    /**
+     * Open activity to scan qr code and import key in it
+     * 
+     * @return true when activity was found and executed successfully
+     */
+    public boolean importFromQrCode() {
+        Intent intent = new Intent(ACTION_IMPORT_FROM_QR_CODE);
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        try {
+            startActivityForResult(intent, -1);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Opens activity with qr code for masterKeyId
+     * 
+     * @return true when activity was found and executed successfully
+     */
+    public boolean shareWithQrCode(long masterKeyId) {
+        Intent intent = new Intent(ACTION_SHARE_KEYRING_WITH_QR_CODE);
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        intent.putExtra(EXTRA_MASTER_KEY_ID, masterKeyId);
+        try {
+            startActivityForResult(intent, -1);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Opens activity to share keyring withnc based on given masterKeyId
+     * 
+     * @return true when activity was found and executed successfully
+     */
+    public boolean shareWithNfc(long masterKeyId) {
+        Intent intent = new Intent(ACTION_SHARE_KEYRING_WITH_NFC);
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        intent.putExtra(EXTRA_MASTER_KEY_ID, masterKeyId);
+        try {
+            startActivityForResult(intent, -1);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Opens APG activity to create new key
+     * 
+     * @param userIds
+     *            value to specify prefilled values for user that should be created
+     * @return true when activity was found and executed successfully
+     */
+    public boolean createNewKey(String userIds, boolean noPassphrase, boolean generateDefaultKeys) {
+        Intent intent = new Intent(ACTION_CREATE_KEY);
+        if (userIds != null) {
+            intent.putExtra(EXTRA_USER_IDS, userIds);
+        }
+        intent.putExtra(EXTRA_NO_PASSPHRASE, noPassphrase);
+        intent.putExtra(EXTRA_GENERATE_DEFAULT_KEYS, generateDefaultKeys);
+
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        try {
+            startActivityForResult(intent, CREATE_KEY);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Opens APG activity to create new key
+     * 
+     * @return true when activity was found and executed successfully
+     */
+    public boolean createNewKey() {
+        return createNewKey(null, false, false);
+    }
+
+    /**
+     * Opens APG activity to edit already existing key based on keyId
+     * 
+     * @param keyId
+     * @return true when activity was found and executed successfully
+     */
+    public boolean editKey(long keyId) {
+        Intent intent = new Intent(ACTION_EDIT_KEY);
+        intent.putExtra(EXTRA_KEY_ID, keyId);
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        try {
+            startActivityForResult(intent, EDIT_KEY);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Opens APG activity to select the signature key.
+     * 
+     * @return true when activity was found and executed successfully
+     */
+    public boolean selectSecretKey() {
+        Intent intent = new Intent(ACTION_SELECT_SECRET_KEY);
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        try {
+            startActivityForResult(intent, SELECT_SECRET_KEY);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Encrypts the given data by opening APGs encrypt activity. If encryptionKeys are given it
+     * encrypts immediately and goes back to your program after that
+     * 
+     * @param data
+     *            String that contains the message to be encrypted
+     * @param encryptionKeyIds
+     *            long[] that holds the ids of the encryption keys
+     * @param signatureKeyId
+     *            id of the signature key
+     * @return true when activity was found and executed successfully
+     */
+    public boolean encrypt(String data, long[] encryptionKeyIds, long signatureKeyId,
+            boolean returnResult) {
+        Intent intent = new Intent();
+        if (returnResult) {
+            intent.setAction(ACTION_ENCRYPT_AND_RETURN);
+        } else {
+            intent.setAction(ACTION_ENCRYPT);
+        }
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        intent.setType("text/plain");
+        intent.putExtra(EXTRA_TEXT, data);
+        intent.putExtra(EXTRA_ENCRYPTION_KEY_IDS, encryptionKeyIds);
+        intent.putExtra(EXTRA_SIGNATURE_KEY_ID, signatureKeyId);
+        try {
+            startActivityForResult(intent, ENCRYPT_MESSAGE);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Start the decrypt activity.
+     * 
+     * @param activity
+     * @param data
+     * @param pgpData
+     * @return true when activity was found and executed successfully
+     */
+    public boolean decrypt(String data, boolean returnResult) {
+        Intent intent = new Intent();
+        if (returnResult) {
+            intent.setAction(ACTION_DECRYPT_AND_RETURN);
+        } else {
+            intent.setAction(ACTION_DECRYPT);
+        }
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+        intent.setType("text/plain");
+        if (data == null) {
+            return false;
+        }
+        try {
+            intent.putExtra(EXTRA_TEXT, data);
+            startActivityForResult(intent, DECRYPT_MESSAGE);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    /**
+     * Handle the activity results that concern us.
+     * 
+     * @param requestCode
+     * @param resultCode
+     * @param data
+     * @return handled or not
+     */
+    public boolean onActivityResult(int requestCode, int resultCode, Intent data, KeychainData apgData) {
+
+        switch (requestCode) {
+        case CREATE_KEY:
+            if (resultCode != Activity.RESULT_OK || data == null) {
+                // user canceled!
+                break;
+            }
+            apgData.setSecretKeyId(data.getLongExtra(RESULT_EXTRA_MASTER_KEY_ID, 0));
+            apgData.setSecretKeyUserId(data.getStringExtra(RESULT_EXTRA_USER_ID));
+
+            break;
+        case SELECT_SECRET_KEY:
+            if (resultCode != Activity.RESULT_OK || data == null) {
+                // user canceled!
+                break;
+            }
+            apgData.setSecretKeyId(data.getLongExtra(EXTRA_KEY_ID, 0));
+            apgData.setSecretKeyUserId(data.getStringExtra(EXTRA_USER_ID));
+
+            break;
+        case SELECT_PUBLIC_KEYS:
+            if (resultCode != Activity.RESULT_OK || data == null) {
+                apgData.setPublicKeyIds(null);
+                break;
+            }
+            apgData.setPublicKeyIds(data.getLongArrayExtra(RESULT_EXTRA_MASTER_KEY_IDS));
+            apgData.setPublicUserIds(data.getStringArrayExtra(RESULT_EXTRA_USER_IDS));
+
+            break;
+        case ENCRYPT_MESSAGE:
+            if (resultCode != Activity.RESULT_OK || data == null) {
+                apgData.setPublicKeyIds(null);
+                break;
+            }
+            apgData.setEncryptedData(data.getStringExtra(EXTRA_ENCRYPTED_MESSAGE));
+
+            break;
+        case DECRYPT_MESSAGE:
+            if (resultCode != Activity.RESULT_OK || data == null) {
+                break;
+            }
+
+            apgData.setSecretKeyUserId(data.getStringExtra(EXTRA_SIGNATURE_USER_ID));
+            apgData.setSecretKeyId(data.getLongExtra(EXTRA_SIGNATURE_KEY_ID, 0));
+            apgData.setSignatureSuccess(data.getBooleanExtra(EXTRA_SIGNATURE_SUCCESS, false));
+            apgData.setSignatureUnknown(data.getBooleanExtra(EXTRA_SIGNATURE_UNKNOWN, false));
+
+            apgData.setDecryptedData(data.getStringExtra(EXTRA_DECRYPTED_MESSAGE));
+
+            break;
+        default:
+            return false;
+        }
+
+        return true;
+    }
+
+    /**
+     * Select encryption keys.
+     * 
+     * @param emails
+     *            The emails that should be used for preselection.
+     * @return true when activity was found and executed successfully
+     */
+    public boolean selectPublicKeys(String emails) {
+        return selectPublicKeys(emails, null);
+    }
+
+    /**
+     * Select encryption keys.
+     * 
+     * @param emails
+     *            The emails that should be used for preselection.
+     * @param apgData
+     *            ApgData with encryption keys and signature keys preselected
+     * @return true when activity was found and executed successfully
+     */
+    public boolean selectPublicKeys(String emails, KeychainData apgData) {
+        Intent intent = new Intent(ACTION_SELECT_PUBLIC_KEYS);
+        intent.putExtra(EXTRA_INTENT_VERSION, INTENT_VERSION);
+
+        long[] initialKeyIds = null;
+        if (apgData == null || !apgData.hasPublicKeys()) {
+            KeychainContentProviderHelper cPHelper = new KeychainContentProviderHelper(activity);
+
+            initialKeyIds = cPHelper.getPublicKeyringIdsByEmail(emails);
+        } else {
+            initialKeyIds = apgData.getPublicKeys();
+        }
+        intent.putExtra(EXTRA_SELECTION, initialKeyIds);
+
+        try {
+            startActivityForResult(intent, SELECT_PUBLIC_KEYS);
+            return true;
+        } catch (ActivityNotFoundException e) {
+            activityNotFound();
+            return false;
+        }
+    }
+
+    private void activityNotFound() {
+        Toast.makeText(activity, "APG Activity not found! Is APG installed correctly?",
+                Toast.LENGTH_LONG).show();
+    }
+}
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperSupportV4.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperSupportV4.java
new file mode 100644
index 000000000..c8891287b
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperSupportV4.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import android.content.Intent;
+import android.support.v4.app.Fragment;
+
+/**
+ * ApgIntentHelper for the V4 Android compatibility package.
+ */
+public final class KeychainIntentHelperSupportV4 extends KeychainIntentHelper {
+
+    private final Fragment fragment;
+
+    /**
+     * @param fragment
+     *            Fragment to handle activity response.
+     */
+    public KeychainIntentHelperSupportV4(Fragment fragment) {
+        super(fragment.getActivity());
+        this.fragment = fragment;
+    }
+
+    @Override
+    protected void startActivityForResult(Intent intent, int code) {
+        fragment.startActivityForResult(intent, code);
+    }
+
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperV30.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperV30.java
new file mode 100644
index 000000000..5ecf0e4f7
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainIntentHelperV30.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import android.annotation.TargetApi;
+import android.app.Fragment;
+import android.content.Intent;
+import android.os.Build;
+
+/**
+ * ApgIntentHelper for Android version 3.0 and beyond.
+ */
+@TargetApi(Build.VERSION_CODES.HONEYCOMB)
+public final class KeychainIntentHelperV30 extends KeychainIntentHelper {
+
+    private final Fragment fragment;
+
+    /**
+     * @param fragment
+     *            Fragment to handle activity response.
+     */
+    public KeychainIntentHelperV30(Fragment fragment) {
+        super(fragment.getActivity());
+        this.fragment = fragment;
+    }
+
+    @Override
+    protected void startActivityForResult(Intent intent, int code) {
+        fragment.startActivityForResult(intent, code);
+    }
+
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainServiceHelper.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainServiceHelper.java
new file mode 100644
index 000000000..54e1f517a
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainServiceHelper.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.net.Uri;
+import android.util.Log;
+
+public class KeychainServiceHelper {
+
+    private final static String BLOB_URI = "content://org.sufficientlysecure.keychain.provider.apgserviceblobprovider";
+
+    private Context context;
+
+    public KeychainServiceHelper(Context context) {
+        this.context = context;
+    }
+
+    /**
+     * Set up binary data to en/decrypt
+     * 
+     * @param is
+     *            InputStream to get the data from
+     */
+    public void setBlob(InputStream is) {
+        Log.d(Constants.TAG, "setBlob() called");
+        // 1. get the new contentUri
+        ContentResolver cr = context.getContentResolver();
+        Uri contentUri = cr.insert(Uri.parse(BLOB_URI), new ContentValues());
+
+        // 2. insert binary data
+        OutputStream os = null;
+        try {
+            os = cr.openOutputStream(contentUri, "w");
+        } catch (Exception e) {
+            Log.e(Constants.TAG, "... exception on setBlob", e);
+        }
+
+        byte[] buffer = new byte[8];
+        int len = 0;
+        try {
+            while ((len = is.read(buffer)) != -1) {
+                os.write(buffer, 0, len);
+            }
+            Log.d(Constants.TAG, "... write finished, now closing");
+            os.close();
+        } catch (Exception e) {
+            Log.e(Constants.TAG, "... error on writing buffer", e);
+        }
+
+        // mArgs.putString("BLOB", contentUri.toString());
+    }
+
+    /**
+     * Get the binary result
+     * 
+     * <p>
+     * This gets your binary result. It only works if you called {@link #setBlob(InputStream)}
+     * before.
+     * 
+     * If you did not call encrypt nor decrypt, this will be the same data as you inputed.
+     * </p>
+     * 
+     * @return InputStream of the binary data which was en/decrypted
+     * 
+     * @see #setBlob(InputStream)
+     * @see #getResult()
+     */
+    public InputStream getBlobResult() {
+        // if (mArgs.containsKey("BLOB")) {
+        ContentResolver cr = context.getContentResolver();
+        InputStream in = null;
+        try {
+            // in = cr.openInputStream(Uri.parse(mArgs.getString("BLOB")));
+        } catch (Exception e) {
+            Log.e(Constants.TAG, "Could not return blob in result", e);
+        }
+        return in;
+        // } else {
+        // return null;
+        // }
+    }
+}
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainUtil.java b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainUtil.java
new file mode 100644
index 000000000..19d3850d7
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/integration/KeychainUtil.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2010-2011 K-9 Mail Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.sufficientlysecure.keychain.integration;
+
+import android.content.Context;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager.NameNotFoundException;
+
+import android.widget.Toast;
+
+public class KeychainUtil {
+
+    /**
+     * Check whether OpenPGP Keychain is installed and at a high enough version.
+     * 
+     * @param context
+     * @return whether a suitable version of APG was found
+     */
+    public boolean isApgAvailable(Context context) {
+        try {
+            PackageInfo pi = context.getPackageManager().getPackageInfo(
+                    Constants.KEYCHAIN_PACKAGE_NAME, 0);
+            if (pi.versionCode >= Constants.MIN_REQUIRED_VERSION) {
+                return true;
+            } else {
+                Toast.makeText(
+                        context,
+                        "This OpenPGP Keychain version is not supported! Please update to a newer one!",
+                        Toast.LENGTH_LONG).show();
+            }
+        } catch (NameNotFoundException e) {
+            // not found
+        }
+
+        return false;
+    }
+
+    /**
+     * Splits userId string into naming part and email part
+     * 
+     * @param userId
+     * @return array with naming (0) and email (1)
+     */
+    public static String[] splitUserId(String userId) {
+        String[] output = new String[2];
+
+        String chunks[] = userId.split(" <", 2);
+        userId = chunks[0];
+        if (chunks.length > 1) {
+            output[1] = "<" + chunks[1];
+            output[1] = output[1].replaceAll("<", "");
+            output[1] = output[1].replaceAll(">", "");
+        }
+        output[0] = userId;
+
+        return output;
+    }
+}
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainApiService.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainApiService.aidl
new file mode 100644
index 000000000..ac8327b8e
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainApiService.aidl
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service;
+
+import org.sufficientlysecure.keychain.service.handler.IKeychainEncryptHandler;
+import org.sufficientlysecure.keychain.service.handler.IKeychainDecryptHandler;
+import org.sufficientlysecure.keychain.service.handler.IKeychainGetDecryptionKeyIdHandler;
+
+/**
+ * All methods are oneway, which means they are asynchronous and non-blocking.
+ * Results are returned into given Handler, which has to be implemented on client side.
+ */
+interface IKeychainApiService {
+       
+    /**
+     * Encrypt
+     *
+     * Either inputBytes or inputUri is given, the other should be null.
+     * 
+     * @param inputBytes
+     *            Byte array you want to encrypt
+     * @param inputUri
+     *            Blob in ContentProvider you want to encrypt
+     * @param useAsciiArmor 
+     *            Convert bytes to ascii armored text to guard against encoding problems
+     * @param compression
+     *            Compression: 0x21070001: none, 1: Zip, 2: Zlib, 3: BZip2
+     * @param encryptionKeyIds
+     *            Ids of public keys used for encryption
+     * @param symmetricEncryptionAlgorithm
+     *            7: AES-128, 8: AES-192, 9: AES-256, 4: Blowfish, 10: Twofish, 3: CAST5,
+     *            6: DES, 2: Triple DES, 1: IDEA
+     * @param handler
+     *            Results are returned to this IKeychainEncryptDecryptHandler Handler
+     *            to onSuccessEncrypt(in byte[] output), after successful encryption
+     */
+    oneway void encryptAsymmetric(in byte[] inputBytes, in String inputUri, in boolean useAsciiArmor,
+            in int compression, in long[] encryptionKeyIds, in int symmetricEncryptionAlgorithm,
+            in IKeychainEncryptHandler handler);
+    
+    /**
+     * Same as encryptAsymmetric but using a passphrase for symmetric encryption
+     *
+     * @param encryptionPassphrase
+     *            Passphrase for direct symmetric encryption using symmetricEncryptionAlgorithm
+     */
+    oneway void encryptSymmetric(in byte[] inputBytes, in String inputUri, in boolean useAsciiArmor,
+            in int compression, in String encryptionPassphrase, in int symmetricEncryptionAlgorithm,
+            in IKeychainEncryptHandler handler);
+    
+    /**
+     * Encrypt and sign
+     *
+     * Either inputBytes or inputUri is given, the other should be null.
+     * 
+     * @param inputBytes
+     *            Byte array you want to encrypt
+     * @param inputUri
+     *            Blob in ContentProvider you want to encrypt
+     * @param useAsciiArmor 
+     *            Convert bytes to ascii armored text to guard against encoding problems
+     * @param compression
+     *            Compression: 0x21070001: none, 1: Zip, 2: Zlib, 3: BZip2
+     * @param encryptionKeyIds
+     *            Ids of public keys used for encryption
+     * @param symmetricEncryptionAlgorithm
+     *            7: AES-128, 8: AES-192, 9: AES-256, 4: Blowfish, 10: Twofish, 3: CAST5,
+     *            6: DES, 2: Triple DES, 1: IDEA
+     * @param signatureKeyId
+     *            Key id of key to sign with
+     * @param signatureHashAlgorithm
+     *            1: MD5, 3: RIPEMD-160, 2: SHA-1, 11: SHA-224, 8: SHA-256, 9: SHA-384,
+     *            10: SHA-512
+     * @param signatureForceV3
+     *            Force V3 signatures
+     * @param signaturePassphrase
+     *            Passphrase to unlock signature key
+     * @param handler
+     *            Results are returned to this IKeychainEncryptDecryptHandler Handler
+     *            to onSuccessEncrypt(in byte[] output), after successful encryption and signing
+     */
+    oneway void encryptAndSignAsymmetric(in byte[] inputBytes, in String inputUri,
+            in boolean useAsciiArmor, in int compression, in long[] encryptionKeyIds,
+            in int symmetricEncryptionAlgorithm, in long signatureKeyId, in int signatureHashAlgorithm,
+            in boolean signatureForceV3, in String signaturePassphrase,
+            in IKeychainEncryptHandler handler);
+    
+    /**
+     * Same as encryptAndSignAsymmetric but using a passphrase for symmetric encryption
+     *
+     * @param encryptionPassphrase
+     *            Passphrase for direct symmetric encryption using symmetricEncryptionAlgorithm
+     */
+    oneway void encryptAndSignSymmetric(in byte[] inputBytes, in String inputUri,
+            in boolean useAsciiArmor, in int compression, in String encryptionPassphrase,
+            in int symmetricEncryptionAlgorithm, in long signatureKeyId, in int signatureHashAlgorithm,
+            in boolean signatureForceV3, in String signaturePassphrase,
+            in IKeychainEncryptHandler handler);
+    
+    /**
+     * Decrypts and verifies given input bytes. If no signature is present this method
+     * will only decrypt.
+     * 
+     * @param inputBytes
+     *            Byte array you want to decrypt and verify
+     * @param inputUri
+     *            Blob in ContentProvider you want to decrypt and verify
+     * @param keyPassphrase
+     *            Passphrase to unlock secret key for decryption.
+     * @param handler
+     *            Handler where to return results to after successful encryption
+     */
+    oneway void decryptAndVerifyAsymmetric(in byte[] inputBytes, in String inputUri,
+            in String keyPassphrase, in IKeychainDecryptHandler handler);
+    
+    /**
+     * Same as decryptAndVerifyAsymmetric but for symmetric decryption.
+     *
+     * @param encryptionPassphrase
+     *            Passphrase to decrypt
+     */
+    oneway void decryptAndVerifySymmetric(in byte[] inputBytes, in String inputUri,
+            in String encryptionPassphrase, in IKeychainDecryptHandler handler);
+    
+    /**
+     *
+     */
+    oneway void getDecryptionKeyId(in byte[] inputBytes, in String inputUri,
+            in IKeychainGetDecryptionKeyIdHandler handler);
+    
+    
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainKeyService.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainKeyService.aidl
new file mode 100644
index 000000000..ecea2b8ff
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/IKeychainKeyService.aidl
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service;
+
+import org.sufficientlysecure.keychain.service.handler.IKeychainGetKeyringsHandler;
+
+/**
+ * All methods are oneway, which means they are asynchronous and non-blocking.
+ * Results are returned into given Handler, which has to be implemented on client side.
+ */
+interface IKeychainKeyService {
+
+    oneway void getPublicKeyRings(in long[] masterKeyIds, in boolean asAsciiArmoredStringArray,
+            in IKeychainGetKeyringsHandler handler);
+
+    oneway void getSecretKeyRings(in long[] masterKeyIds, in boolean asAsciiArmoredStringArray,
+            in IKeychainGetKeyringsHandler handler);
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainDecryptHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainDecryptHandler.aidl
new file mode 100644
index 000000000..31ead701d
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainDecryptHandler.aidl
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service.handler;
+
+interface IKeychainDecryptHandler {
+
+    oneway void onSuccess(in byte[] outputBytes, in String outputUri, in boolean signature,
+            in long signatureKeyId, in String signatureUserId, in boolean signatureSuccess,
+            in boolean signatureUnknown);
+
+
+    oneway void onException(in int exceptionNumber, in String message);
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainEncryptHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainEncryptHandler.aidl
new file mode 100644
index 000000000..5b21a0613
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainEncryptHandler.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service.handler;
+
+interface IKeychainEncryptHandler {
+    /**
+     * Either output or streamUri is given. One of them is null
+     *
+     */
+    oneway void onSuccess(in byte[] outputBytes, in String outputUri);
+
+
+    oneway void onException(in int exceptionNumber, in String message);
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetDecryptionKeyIdHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetDecryptionKeyIdHandler.aidl
new file mode 100644
index 000000000..2fff74a92
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetDecryptionKeyIdHandler.aidl
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service.handler;
+
+interface IKeychainGetDecryptionKeyIdHandler {
+
+    oneway void onSuccess(in long secretKeyId, in boolean symmetric);
+
+
+    oneway void onException(in int exceptionNumber, in String message);
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetKeyringsHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetKeyringsHandler.aidl
new file mode 100644
index 000000000..c3a7d1faf
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainGetKeyringsHandler.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service.handler;
+
+interface IKeychainGetKeyringsHandler {
+    /**
+     * Either outputBytes or outputString is given. One of them is null
+     *
+     */
+    oneway void onSuccess(in byte[] outputBytes, in List<String> outputString);
+
+
+    oneway void onException(in int exceptionNumber, in String message);
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainSignHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainSignHandler.aidl
new file mode 100644
index 000000000..69badab4c
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainSignHandler.aidl
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service.handler;
+
+interface IKeychainSignHandler {
+    /**
+     * Either output or streamUri is given. One of them is null
+     *
+     */
+    oneway void onSuccess(in byte[] outputBytes, in String outputUri);
+
+
+    oneway void onException(in int exceptionNumber, in String message);
+}
\ No newline at end of file
diff --git a/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainVerifyHandler.aidl b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainVerifyHandler.aidl
new file mode 100644
index 000000000..aaa9a7f6a
--- /dev/null
+++ b/OpenPGP-Keychain-API-Lib/src/org/sufficientlysecure/keychain/service/handler/IKeychainVerifyHandler.aidl
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2012 Dominik Schürmann <dominik@dominikschuermann.de>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ 
+package org.sufficientlysecure.keychain.service.handler;
+
+interface IKeychainVerifyHandler {
+
+    oneway void onSuccess(in boolean signature, in long signatureKeyId,
+            in String signatureUserId, in boolean signatureSuccess, in boolean signatureUnknown);
+
+
+    oneway void onException(in int exceptionNumber, in String message);
+}
\ No newline at end of file