diff --git a/OpenPGP-Keychain-API/example-app/src/main/java/org/sufficientlysecure/keychain/demo/OpenPgpProviderActivity.java b/OpenPGP-Keychain-API/example-app/src/main/java/org/sufficientlysecure/keychain/demo/OpenPgpProviderActivity.java
index e578d0660..dee977657 100644
--- a/OpenPGP-Keychain-API/example-app/src/main/java/org/sufficientlysecure/keychain/demo/OpenPgpProviderActivity.java
+++ b/OpenPGP-Keychain-API/example-app/src/main/java/org/sufficientlysecure/keychain/demo/OpenPgpProviderActivity.java
@@ -44,6 +44,7 @@ import org.openintents.openpgp.util.OpenPgpServiceConnection;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.InputStream;
+import java.io.OutputStream;
 import java.io.UnsupportedEncodingException;
 import java.util.ArrayList;
 import java.util.List;
@@ -140,6 +141,54 @@ public class OpenPgpProviderActivity extends Activity {
         return is;
     }
 
+    private class MyCallback implements OpenPgpApi.IOpenPgpCallback {
+        boolean returnToCiphertextField;
+        ByteArrayOutputStream os;
+        int requestCode;
+
+        private MyCallback(boolean returnToCiphertextField, ByteArrayOutputStream os, int requestCode) {
+            this.returnToCiphertextField = returnToCiphertextField;
+            this.os = os;
+            this.requestCode = requestCode;
+        }
+
+        @Override
+        public void onReturn(Bundle result) {
+            switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
+                case OpenPgpConstants.RESULT_CODE_SUCCESS: {
+                    try {
+                        Log.d(OpenPgpConstants.TAG, "result: " + os.toByteArray().length
+                                + " str=" + os.toString("UTF-8"));
+
+                        if (returnToCiphertextField) {
+                            mCiphertext.setText(os.toString("UTF-8"));
+                        } else {
+                            mMessage.setText(os.toString("UTF-8"));
+                        }
+                    } catch (UnsupportedEncodingException e) {
+                        Log.e(Constants.TAG, "UnsupportedEncodingException", e);
+                    }
+                    break;
+                }
+                case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED: {
+                    PendingIntent pi = result.getParcelable(OpenPgpConstants.RESULT_INTENT);
+                    try {
+                        OpenPgpProviderActivity.this.startIntentSenderForResult(pi.getIntentSender(),
+                                requestCode, null, 0, 0, 0);
+                    } catch (IntentSender.SendIntentException e) {
+                        Log.e(Constants.TAG, "SendIntentException", e);
+                    }
+                    break;
+                }
+                case OpenPgpConstants.RESULT_CODE_ERROR: {
+                    OpenPgpError error = result.getParcelable(OpenPgpConstants.RESULT_ERRORS);
+                    handleError(error);
+                    break;
+                }
+            }
+        }
+    }
+
 
     public void sign(Bundle params) {
         params.putBoolean(OpenPgpConstants.PARAMS_REQUEST_ASCII_ARMOR, true);
@@ -148,34 +197,7 @@ public class OpenPgpProviderActivity extends Activity {
         final ByteArrayOutputStream os = new ByteArrayOutputStream();
 
         OpenPgpApi api = new OpenPgpApi(mCryptoServiceConnection.getService());
-        api.sign(params, is, os, new OpenPgpApi.IOpenPgpCallback() {
-            @Override
-            public void onReturn(Bundle result) {
-                switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
-                    case OpenPgpConstants.RESULT_CODE_SUCCESS: {
-                        try {
-                            Log.d(OpenPgpConstants.TAG, "result: " + os.toByteArray().length
-                                    + " str=" + os.toString("UTF-8"));
-
-                            mCiphertext.setText(os.toString("UTF-8"));
-                        } catch (UnsupportedEncodingException e) {
-                            Log.e(Constants.TAG, "UnsupportedEncodingException", e);
-                        }
-                        break;
-                    }
-                    case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED: {
-                        PendingIntent pi = result.getParcelable(OpenPgpConstants.RESULT_INTENT);
-                        try {
-                            OpenPgpProviderActivity.this.startIntentSenderForResult(pi.getIntentSender(),
-                                    REQUEST_CODE_SIGN, null, 0, 0, 0);
-                        } catch (IntentSender.SendIntentException e) {
-                            Log.e(Constants.TAG, "SendIntentException", e);
-                        }
-                        break;
-                    }
-                }
-            }
-        });
+        api.sign(params, is, os, new MyCallback(true, os, REQUEST_CODE_SIGN));
     }
 
     public void encrypt(Bundle params) {
@@ -186,34 +208,7 @@ public class OpenPgpProviderActivity extends Activity {
         final ByteArrayOutputStream os = new ByteArrayOutputStream();
 
         OpenPgpApi api = new OpenPgpApi(mCryptoServiceConnection.getService());
-        api.encrypt(params, is, os, new OpenPgpApi.IOpenPgpCallback() {
-            @Override
-            public void onReturn(Bundle result) {
-                switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
-                    case OpenPgpConstants.RESULT_CODE_SUCCESS: {
-                        try {
-                            Log.d(OpenPgpConstants.TAG, "result: " + os.toByteArray().length
-                                    + " str=" + os.toString("UTF-8"));
-
-                            mCiphertext.setText(os.toString("UTF-8"));
-                        } catch (UnsupportedEncodingException e) {
-                            Log.e(Constants.TAG, "UnsupportedEncodingException", e);
-                        }
-                        break;
-                    }
-                    case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED: {
-                        PendingIntent pi = result.getParcelable(OpenPgpConstants.RESULT_INTENT);
-                        try {
-                            OpenPgpProviderActivity.this.startIntentSenderForResult(pi.getIntentSender(),
-                                    REQUEST_CODE_ENCRYPT, null, 0, 0, 0);
-                        } catch (IntentSender.SendIntentException e) {
-                            Log.e(Constants.TAG, "SendIntentException", e);
-                        }
-                        break;
-                    }
-                }
-            }
-        });
+        api.encrypt(params, is, os, new MyCallback(true, os, REQUEST_CODE_ENCRYPT));
     }
 
     public void signAndEncrypt(Bundle params) {
@@ -224,34 +219,7 @@ public class OpenPgpProviderActivity extends Activity {
         final ByteArrayOutputStream os = new ByteArrayOutputStream();
 
         OpenPgpApi api = new OpenPgpApi(mCryptoServiceConnection.getService());
-        api.signAndEncrypt(params, is, os, new OpenPgpApi.IOpenPgpCallback() {
-            @Override
-            public void onReturn(Bundle result) {
-                switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
-                    case OpenPgpConstants.RESULT_CODE_SUCCESS: {
-                        try {
-                            Log.d(OpenPgpConstants.TAG, "result: " + os.toByteArray().length
-                                    + " str=" + os.toString("UTF-8"));
-
-                            mCiphertext.setText(os.toString("UTF-8"));
-                        } catch (UnsupportedEncodingException e) {
-                            Log.e(Constants.TAG, "UnsupportedEncodingException", e);
-                        }
-                        break;
-                    }
-                    case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED: {
-                        PendingIntent pi = result.getParcelable(OpenPgpConstants.RESULT_INTENT);
-                        try {
-                            OpenPgpProviderActivity.this.startIntentSenderForResult(pi.getIntentSender(),
-                                    REQUEST_CODE_SIGN_AND_ENCRYPT, null, 0, 0, 0);
-                        } catch (IntentSender.SendIntentException e) {
-                            Log.e(Constants.TAG, "SendIntentException", e);
-                        }
-                        break;
-                    }
-                }
-            }
-        });
+        api.signAndEncrypt(params, is, os, new MyCallback(true, os, REQUEST_CODE_SIGN_AND_ENCRYPT));
     }
 
     public void decryptAndVerify(Bundle params) {
@@ -261,34 +229,7 @@ public class OpenPgpProviderActivity extends Activity {
         final ByteArrayOutputStream os = new ByteArrayOutputStream();
 
         OpenPgpApi api = new OpenPgpApi(mCryptoServiceConnection.getService());
-        api.decryptAndVerify(params, is, os, new OpenPgpApi.IOpenPgpCallback() {
-            @Override
-            public void onReturn(Bundle result) {
-                switch (result.getInt(OpenPgpConstants.RESULT_CODE)) {
-                    case OpenPgpConstants.RESULT_CODE_SUCCESS: {
-                        try {
-                            Log.d(OpenPgpConstants.TAG, "result: " + os.toByteArray().length
-                                    + " str=" + os.toString("UTF-8"));
-
-                            mMessage.setText(os.toString("UTF-8"));
-                        } catch (UnsupportedEncodingException e) {
-                            Log.e(Constants.TAG, "UnsupportedEncodingException", e);
-                        }
-                        break;
-                    }
-                    case OpenPgpConstants.RESULT_CODE_USER_INTERACTION_REQUIRED: {
-                        PendingIntent pi = result.getParcelable(OpenPgpConstants.RESULT_INTENT);
-                        try {
-                            OpenPgpProviderActivity.this.startIntentSenderForResult(pi.getIntentSender(),
-                                    REQUEST_CODE_DECRYPT_AND_VERIFY, null, 0, 0, 0);
-                        } catch (IntentSender.SendIntentException e) {
-                            Log.e(Constants.TAG, "SendIntentException", e);
-                        }
-                        break;
-                    }
-                }
-            }
-        });
+        api.decryptAndVerify(params, is, os, new MyCallback(true, os, REQUEST_CODE_DECRYPT_AND_VERIFY));
     }
 
     @Override
diff --git a/OpenPGP-Keychain/src/main/java/org/sufficientlysecure/keychain/service/remote/RemoteServiceActivity.java b/OpenPGP-Keychain/src/main/java/org/sufficientlysecure/keychain/service/remote/RemoteServiceActivity.java
index 8f619f37e..669c5c28f 100644
--- a/OpenPGP-Keychain/src/main/java/org/sufficientlysecure/keychain/service/remote/RemoteServiceActivity.java
+++ b/OpenPGP-Keychain/src/main/java/org/sufficientlysecure/keychain/service/remote/RemoteServiceActivity.java
@@ -181,6 +181,7 @@ public class RemoteServiceActivity extends ActionBarActivity {
             ArrayList<String> dublicateUserIds = intent
                     .getStringArrayListExtra(EXTRA_DUBLICATE_USER_IDS);
 
+            // TODO: do this with spannable instead of HTML to prevent parsing failures with weird user ids
             String text = new String();
             text += "<b>" + getString(R.string.api_select_pub_keys_text) + "</b>";
             text += "<br/><br/>";
@@ -209,7 +210,7 @@ public class RemoteServiceActivity extends ActionBarActivity {
                     new View.OnClickListener() {
                         @Override
                         public void onClick(View v) {
-                            // sdd key ids to params Bundle for new request
+                            // add key ids to params Bundle for new request
                             Bundle params = extras.getBundle(OpenPgpConstants.PI_RESULT_PARAMS);
                             params.putLongArray(OpenPgpConstants.PARAMS_KEY_IDS,
                                     mSelectFragment.getSelectedMasterKeyIds());
@@ -297,12 +298,12 @@ public class RemoteServiceActivity extends ActionBarActivity {
                     // return given params again, for calling the service method again
                     Intent finishIntent = new Intent();
                     finishIntent.putExtra(OpenPgpConstants.PI_RESULT_PARAMS, params);
-                    RemoteServiceActivity.this.setResult(RESULT_OK, finishIntent);
+                    setResult(RESULT_OK, finishIntent);
                 } else {
-                    RemoteServiceActivity.this.setResult(RESULT_CANCELED);
+                    setResult(RESULT_CANCELED);
                 }
 
-                RemoteServiceActivity.this.finish();
+                finish();
             }
         };
 
@@ -318,7 +319,7 @@ public class RemoteServiceActivity extends ActionBarActivity {
             Log.d(Constants.TAG, "No passphrase for this secret key, encrypt directly!");
             // return given params again, for calling the service method again
             Intent finishIntent = new Intent();
-            finishIntent.putExtras(params);
+            finishIntent.putExtra(OpenPgpConstants.PI_RESULT_PARAMS, params);
             setResult(RESULT_OK, finishIntent);
             finish();
         }