rewrite PgpSignEncrypt data flow

- introduce high-level SignEncryptOperation for uri to uri signing/encryption
- use SignEncryptParcel for high-level operation parameters
- use PgpSignEncryptInput plus streams for low-level operation parameters
- get rid of all sign/encrypt logic in KeychainIntentService

OpenKeychain-Test/src/test/java/org/sufficientlysecure/keychain/pgp/PgpEncryptDecryptTest.java

@@ -29,13 +29,12 @@ import org.spongycastle.bcpg.sig.KeyFlags;
 import org.spongycastle.jce.provider.BouncyCastleProvider;
 import org.spongycastle.openpgp.PGPEncryptedData;
 import org.sufficientlysecure.keychain.operations.results.PgpEditKeyResult;
-import org.sufficientlysecure.keychain.pgp.PgpSignEncrypt.Builder;
+import org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRingData;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel.Algorithm;
 import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel.ChangeUnlockParcel;
 import org.sufficientlysecure.keychain.support.KeyringTestingHelper;
 import org.sufficientlysecure.keychain.util.InputData;
@@ -132,14 +131,14 @@ public class PgpEncryptDecryptTest {
             ByteArrayInputStream in = new ByteArrayInputStream(plaintext.getBytes());
 
             InputData data = new InputData(in, in.available());
-            Builder b = new PgpSignEncrypt.Builder(Robolectric.application,
+            Builder b = new PgpSignEncryptOperation.Builder(Robolectric.application,
                     new ProviderHelper(Robolectric.application),
                     null,
                     data, out);
 
             b.setSymmetricPassphrase(mPassphrase);
             b.setSymmetricEncryptionAlgorithm(PGPEncryptedData.AES_128);
-            SignEncryptResult result = b.build().execute();
+            PgpSignEncryptResult result = b.build().execute();
             Assert.assertTrue("encryption must succeed", result.success());
 
             ciphertext = out.toByteArray();
@@ -211,7 +210,7 @@ public class PgpEncryptDecryptTest {
             ByteArrayInputStream in = new ByteArrayInputStream(plaintext.getBytes());
 
             InputData data = new InputData(in, in.available());
-            Builder b = new PgpSignEncrypt.Builder(
+            Builder b = new PgpSignEncryptOperation.Builder(
                     Robolectric.application,
                     new ProviderHelper(Robolectric.application),
                     null, // new DummyPassphraseCache(mPassphrase, 0L),
@@ -219,7 +218,7 @@ public class PgpEncryptDecryptTest {
 
             b.setEncryptionMasterKeyIds(new long[]{ mStaticRing1.getMasterKeyId() });
             b.setSymmetricEncryptionAlgorithm(PGPEncryptedData.AES_128);
-            SignEncryptResult result = b.build().execute();
+            PgpSignEncryptResult result = b.build().execute();
             Assert.assertTrue("encryption must succeed", result.success());
 
             ciphertext = out.toByteArray();
@@ -287,7 +286,7 @@ public class PgpEncryptDecryptTest {
             ByteArrayInputStream in = new ByteArrayInputStream(plaintext.getBytes());
 
             InputData data = new InputData(in, in.available());
-            Builder b = new PgpSignEncrypt.Builder(
+            Builder b = new PgpSignEncryptOperation.Builder(
                     Robolectric.application,
                     new ProviderHelper(Robolectric.application),
                     null, // new DummyPassphraseCache(mPassphrase, 0L),
@@ -298,7 +297,7 @@ public class PgpEncryptDecryptTest {
                     mStaticRing2.getMasterKeyId()
             });
             b.setSymmetricEncryptionAlgorithm(PGPEncryptedData.AES_128);
-            SignEncryptResult result = b.build().execute();
+            PgpSignEncryptResult result = b.build().execute();
             Assert.assertTrue("encryption must succeed", result.success());
 
             ciphertext = out.toByteArray();
@@ -376,7 +375,7 @@ public class PgpEncryptDecryptTest {
             ByteArrayInputStream in = new ByteArrayInputStream(plaintext.getBytes());
 
             InputData data = new InputData(in, in.available());
-            Builder b = new PgpSignEncrypt.Builder(
+            Builder b = new PgpSignEncryptOperation.Builder(
                     Robolectric.application,
                     new ProviderHelper(Robolectric.application),
                     null, // new DummyPassphraseCache(mPassphrase, 0L),
@@ -390,7 +389,7 @@ public class PgpEncryptDecryptTest {
             b.setSignatureSubKeyId(KeyringTestingHelper.getSubkeyId(mStaticRing1, 1));
             b.setSignaturePassphrase(mKeyPhrase1);
             b.setSymmetricEncryptionAlgorithm(PGPEncryptedData.AES_128);
-            SignEncryptResult result = b.build().execute();
+            PgpSignEncryptResult result = b.build().execute();
             Assert.assertTrue("encryption must succeed", result.success());
 
             ciphertext = out.toByteArray();
@@ -454,7 +453,7 @@ public class PgpEncryptDecryptTest {
             ByteArrayInputStream in = new ByteArrayInputStream(plaindata);
 
             InputData data = new InputData(in, in.available());
-            Builder b = new PgpSignEncrypt.Builder(
+            Builder b = new PgpSignEncryptOperation.Builder(
                     Robolectric.application,
                     new ProviderHelper(Robolectric.application),
                     null, // new DummyPassphraseCache(mPassphrase, 0L),
@@ -465,7 +464,7 @@ public class PgpEncryptDecryptTest {
             // this only works with ascii armored output!
             b.setEnableAsciiArmorOutput(true);
             b.setCharset("iso-2022-jp");
-            SignEncryptResult result = b.build().execute();
+            PgpSignEncryptResult result = b.build().execute();
             Assert.assertTrue("encryption must succeed", result.success());
 
             ciphertext = out.toByteArray();

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

@@ -32,12 +32,12 @@ import android.provider.ContactsContract;
 import android.widget.Toast;
 
 import org.spongycastle.jce.provider.BouncyCastleProvider;
-import org.sufficientlysecure.keychain.util.Preferences;
-import org.sufficientlysecure.keychain.util.TlsHelper;
 import org.sufficientlysecure.keychain.provider.TemporaryStorageProvider;
 import org.sufficientlysecure.keychain.ui.ConsolidateDialogActivity;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.PRNGFixes;
+import org.sufficientlysecure.keychain.util.Preferences;
+import org.sufficientlysecure.keychain.util.TlsHelper;
 
 import java.security.Security;
 

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

@@ -17,8 +17,8 @@
 package org.sufficientlysecure.keychain.keyimport;
 
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.util.ArrayList;
 import java.util.Vector;

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

@@ -19,10 +19,10 @@
 package org.sufficientlysecure.keychain.keyimport;
 
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
-import org.sufficientlysecure.keychain.util.TlsHelper;
 import org.sufficientlysecure.keychain.pgp.PgpHelper;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.TlsHelper;
 
 import java.io.BufferedWriter;
 import java.io.IOException;

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

@@ -23,9 +23,9 @@ import android.os.Parcelable;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
 import org.sufficientlysecure.keychain.pgp.UncachedPublicKey;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 
 import java.io.Serializable;
 import java.util.ArrayList;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/CertifyOperation.java

@@ -5,6 +5,10 @@ import android.content.Context;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.keyimport.HkpKeyserver;
 import org.sufficientlysecure.keychain.keyimport.Keyserver.AddKeyException;
+import org.sufficientlysecure.keychain.operations.results.CertifyResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey.SecretKeyType;
@@ -16,10 +20,6 @@ import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
 import org.sufficientlysecure.keychain.service.CertifyActionsParcel;
 import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction;
-import org.sufficientlysecure.keychain.operations.results.CertifyResult;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
-import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.Log;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/EditKeyOperation.java

@@ -4,16 +4,16 @@ import android.content.Context;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
 import org.sufficientlysecure.keychain.operations.results.PgpEditKeyResult;
+import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpKeyOperation;
 import org.sufficientlysecure.keychain.pgp.Progressable;
 import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
-import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.service.ContactSyncAdapterService;
 import org.sufficientlysecure.keychain.service.PassphraseCacheService;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/ImportExportOperation.java

@@ -32,6 +32,10 @@ import org.sufficientlysecure.keychain.keyimport.Keyserver.AddKeyException;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
 import org.sufficientlysecure.keychain.operations.results.ExportResult;
+import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedKeyRing;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpHelper;
@@ -41,10 +45,6 @@ import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
-import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
-import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.service.ContactSyncAdapterService;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.FileHelper;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/PromoteKeyOperation.java

@@ -3,10 +3,10 @@ package org.sufficientlysecure.keychain.operations;
 import android.content.Context;
 
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.operations.results.PromoteKeyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
 import org.sufficientlysecure.keychain.operations.results.PgpEditKeyResult;
+import org.sufficientlysecure.keychain.operations.results.PromoteKeyResult;
 import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
 import org.sufficientlysecure.keychain.pgp.Progressable;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java

@@ -0,0 +1,136 @@
+package org.sufficientlysecure.keychain.operations;
+
+import android.content.Context;
+import android.net.Uri;
+
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult;
+import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
+import org.sufficientlysecure.keychain.pgp.PgpSignEncryptOperation;
+import org.sufficientlysecure.keychain.pgp.Progressable;
+import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.util.FileHelper;
+import org.sufficientlysecure.keychain.util.InputData;
+import org.sufficientlysecure.keychain.util.ProgressScaler;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/** This is a high-level operation, which encapsulates one or more sign/encrypt
+ * operations, using URIs or byte arrays as input and output.
+ *
+ * This operation is fail-fast: If any sign/encrypt sub-operation fails or returns
+ * a pending result, it will terminate.
+ *
+ */
+public class SignEncryptOperation extends BaseOperation {
+
+    public SignEncryptOperation(Context context, ProviderHelper providerHelper,
+                                Progressable progressable, AtomicBoolean cancelled) {
+        super(context, providerHelper, progressable, cancelled);
+    }
+
+    public SignEncryptResult execute(SignEncryptParcel input) {
+
+        OperationLog log = new OperationLog();
+        log.add(LogType.MSG_SE, 0);
+
+        ArrayDeque<Uri> inputUris = new ArrayDeque<>(input.getInputUris());
+        ArrayDeque<Uri> outputUris = new ArrayDeque<>(input.getOutputUris());
+        byte[] inputBytes = input.getBytes();
+        byte[] outputBytes = null;
+
+        ArrayList<PgpSignEncryptResult> results = new ArrayList<>();
+
+        do {
+
+            if (checkCancelled()) {
+                log.add(LogType.MSG_OPERATION_CANCELLED, 0);
+                return new SignEncryptResult(SignEncryptResult.RESULT_CANCELLED, log, results);
+            }
+
+            InputData inputData;
+            {
+                if (inputBytes != null) {
+                    log.add(LogType.MSG_SE_INPUT_BYTES, 1);
+                    InputStream is = new ByteArrayInputStream(inputBytes);
+                    inputData = new InputData(is, inputBytes.length);
+                    inputBytes = null;
+                } else {
+                    if (inputUris.isEmpty()) {
+                        log.add(LogType.MSG_SE_ERROR_NO_INPUT, 1);
+                        return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
+                    }
+
+                    log.add(LogType.MSG_SE_INPUT_URI, 1);
+                    Uri uri = inputUris.removeFirst();
+                    try {
+                        InputStream is = mContext.getContentResolver().openInputStream(uri);
+                        long fileSize = FileHelper.getFileSize(mContext, uri, 0);
+                        String filename = FileHelper.getFilename(mContext, uri);
+                        inputData = new InputData(is, fileSize, filename);
+                    } catch (FileNotFoundException e) {
+                        log.add(LogType.MSG_SE_ERROR_INPUT_URI_NOT_FOUND, 1);
+                        return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
+                    }
+                }
+            }
+
+            OutputStream outStream;
+            {
+                if (!outputUris.isEmpty()) {
+                    try {
+                        Uri outputUri = outputUris.removeFirst();
+                        outStream = mContext.getContentResolver().openOutputStream(outputUri);
+                    } catch (FileNotFoundException e) {
+                        log.add(LogType.MSG_SE_ERROR_OUTPUT_URI_NOT_FOUND, 1);
+                        return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
+                    }
+                } else {
+                    if (outputBytes != null) {
+                        log.add(LogType.MSG_SE_ERROR_TOO_MANY_INPUTS, 1);
+                        return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
+                    }
+                    outStream = new ByteArrayOutputStream();
+                }
+            }
+
+            PgpSignEncryptOperation op = new PgpSignEncryptOperation(mContext, mProviderHelper,
+                    new ProgressScaler(), mCancelled);
+            PgpSignEncryptResult result = op.execute(input, inputData, outStream);
+            results.add(result);
+            log.add(result, 2);
+
+            if (result.isPending()) {
+                return new SignEncryptResult(SignEncryptResult.RESULT_PENDING, log, results);
+            }
+
+            if (!result.success()) {
+                return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
+            }
+
+            if (outStream instanceof ByteArrayOutputStream) {
+                outputBytes = ((ByteArrayOutputStream) outStream).toByteArray();
+            }
+
+        } while (!inputUris.isEmpty());
+
+        if (!outputUris.isEmpty()) {
+            // Any output URIs left are indicative of a programming error
+            log.add(LogType.MSG_SE_WARN_OUTPUT_LEFT, 1);
+        }
+
+        log.add(LogType.MSG_SE_SUCCESS, 1);
+        return new SignEncryptResult(SignEncryptResult.RESULT_OK, log, results, outputBytes);
+
+    }
+
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/DeleteResult.java

@@ -21,8 +21,6 @@ package org.sufficientlysecure.keychain.operations.results;
 import android.app.Activity;
 import android.content.Intent;
 import android.os.Parcel;
-import android.os.Parcelable;
-import android.view.View;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.LogDisplayActivity;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/OperationResult.java

@@ -20,15 +20,8 @@ package org.sufficientlysecure.keychain.operations.results;
 
 import android.app.Activity;
 import android.content.Intent;
-import android.graphics.Color;
 import android.os.Parcel;
 import android.os.Parcelable;
-import android.view.View;
-
-import com.nispok.snackbar.Snackbar;
-import com.nispok.snackbar.Snackbar.SnackbarDuration;
-import com.nispok.snackbar.SnackbarManager;
-import com.nispok.snackbar.listeners.ActionClickListener;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
@@ -593,28 +586,42 @@ public abstract class OperationResult implements Parcelable {
         MSG_DC_UNLOCKING (LogLevel.INFO, R.string.msg_dc_unlocking),
 
         // signencrypt
-        MSG_SE_ASYMMETRIC (LogLevel.INFO, R.string.msg_se_asymmetric),
-        MSG_SE_CLEARSIGN_ONLY (LogLevel.DEBUG, R.string.msg_se_clearsign_only),
-        MSG_SE_COMPRESSING (LogLevel.DEBUG, R.string.msg_se_compressing),
-        MSG_SE_ENCRYPTING (LogLevel.DEBUG, R.string.msg_se_encrypting),
-        MSG_SE_ERROR_BAD_PASSPHRASE (LogLevel.ERROR, R.string.msg_se_error_bad_passphrase),
-        MSG_SE_ERROR_IO (LogLevel.ERROR, R.string.msg_se_error_io),
-        MSG_SE_ERROR_SIGN_KEY(LogLevel.ERROR, R.string.msg_se_error_sign_key),
-        MSG_SE_ERROR_KEY_SIGN (LogLevel.ERROR, R.string.msg_se_error_key_sign),
-        MSG_SE_ERROR_NFC (LogLevel.ERROR, R.string.msg_se_error_nfc),
-        MSG_SE_ERROR_PGP (LogLevel.ERROR, R.string.msg_se_error_pgp),
-        MSG_SE_ERROR_SIG (LogLevel.ERROR, R.string.msg_se_error_sig),
-        MSG_SE_ERROR_UNLOCK (LogLevel.ERROR, R.string.msg_se_error_unlock),
-        MSG_SE_KEY_OK (LogLevel.OK, R.string.msg_se_key_ok),
-        MSG_SE_KEY_UNKNOWN (LogLevel.DEBUG, R.string.msg_se_key_unknown),
-        MSG_SE_KEY_WARN (LogLevel.WARN, R.string.msg_se_key_warn),
-        MSG_SE_OK (LogLevel.OK, R.string.msg_se_ok),
-        MSG_SE_PENDING_NFC (LogLevel.INFO, R.string.msg_se_pending_nfc),
-        MSG_SE_PENDING_PASSPHRASE (LogLevel.INFO, R.string.msg_se_pending_passphrase),
-        MSG_SE (LogLevel.DEBUG, R.string.msg_se),
-        MSG_SE_SIGNING (LogLevel.DEBUG, R.string.msg_se_signing),
-        MSG_SE_SIGCRYPTING (LogLevel.DEBUG, R.string.msg_se_sigcrypting),
-        MSG_SE_SYMMETRIC (LogLevel.INFO, R.string.msg_se_symmetric),
+        MSG_SE (LogLevel.START, R.string.msg_se),
+        MSG_SE_INPUT_BYTES (LogLevel.INFO, R.string.msg_se_input_bytes),
+        MSG_SE_INPUT_URI (LogLevel.INFO, R.string.msg_se_input_uri),
+        MSG_SE_ERROR_NO_INPUT (LogLevel.DEBUG, R.string.msg_se_error_no_input),
+        MSG_SE_ERROR_INPUT_URI_NOT_FOUND (LogLevel.ERROR, R.string.msg_se_error_input_uri_not_found),
+        MSG_SE_ERROR_OUTPUT_URI_NOT_FOUND (LogLevel.ERROR, R.string.msg_se_error_output_uri_not_found),
+        MSG_SE_ERROR_TOO_MANY_INPUTS (LogLevel.ERROR, R.string.msg_se_error_too_many_inputs),
+        MSG_SE_WARN_OUTPUT_LEFT (LogLevel.WARN, R.string.msg_se_warn_output_left),
+        MSG_SE_SUCCESS (LogLevel.OK, R.string.msg_se_success),
+
+        // pgpsignencrypt
+        MSG_PSE_ASYMMETRIC (LogLevel.INFO, R.string.msg_pse_asymmetric),
+        MSG_PSE_CLEARSIGN_ONLY (LogLevel.DEBUG, R.string.msg_pse_clearsign_only),
+        MSG_PSE_COMPRESSING (LogLevel.DEBUG, R.string.msg_pse_compressing),
+        MSG_PSE_ENCRYPTING (LogLevel.DEBUG, R.string.msg_pse_encrypting),
+        MSG_PSE_ERROR_BAD_PASSPHRASE (LogLevel.ERROR, R.string.msg_pse_error_bad_passphrase),
+        MSG_PSE_ERROR_HASH_ALGO (LogLevel.ERROR, R.string.msg_pse_error_hash_algo),
+        MSG_PSE_ERROR_IO (LogLevel.ERROR, R.string.msg_pse_error_io),
+        MSG_PSE_ERROR_SIGN_KEY(LogLevel.ERROR, R.string.msg_pse_error_sign_key),
+        MSG_PSE_ERROR_KEY_SIGN (LogLevel.ERROR, R.string.msg_pse_error_key_sign),
+        MSG_PSE_ERROR_NFC (LogLevel.ERROR, R.string.msg_pse_error_nfc),
+        MSG_PSE_ERROR_PGP (LogLevel.ERROR, R.string.msg_pse_error_pgp),
+        MSG_PSE_ERROR_SIG (LogLevel.ERROR, R.string.msg_pse_error_sig),
+        MSG_PSE_ERROR_UNLOCK (LogLevel.ERROR, R.string.msg_pse_error_unlock),
+        MSG_PSE_KEY_OK (LogLevel.OK, R.string.msg_pse_key_ok),
+        MSG_PSE_KEY_UNKNOWN (LogLevel.DEBUG, R.string.msg_pse_key_unknown),
+        MSG_PSE_KEY_WARN (LogLevel.WARN, R.string.msg_pse_key_warn),
+        MSG_PSE_OK (LogLevel.OK, R.string.msg_pse_ok),
+        MSG_PSE_PENDING_NFC (LogLevel.INFO, R.string.msg_pse_pending_nfc),
+        MSG_PSE_PENDING_PASSPHRASE (LogLevel.INFO, R.string.msg_pse_pending_passphrase),
+        MSG_PSE (LogLevel.DEBUG, R.string.msg_pse),
+        MSG_PSE_SIGNING (LogLevel.DEBUG, R.string.msg_pse_signing),
+        MSG_PSE_SIGNING_CLEARTEXT (LogLevel.DEBUG, R.string.msg_pse_signing_cleartext),
+        MSG_PSE_SIGNING_DETACHED (LogLevel.DEBUG, R.string.msg_pse_signing_detached),
+        MSG_PSE_SIGCRYPTING (LogLevel.DEBUG, R.string.msg_pse_sigcrypting),
+        MSG_PSE_SYMMETRIC (LogLevel.INFO, R.string.msg_pse_symmetric),
 
         MSG_CRT_CERTIFYING (LogLevel.DEBUG, R.string.msg_crt_certifying),
         MSG_CRT_CERTIFY_ALL (LogLevel.DEBUG, R.string.msg_crt_certify_all),

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/PgpSignEncryptResult.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright (C) 2014 Vincent Breitmoser <v.breitmoser@mugenguild.com>
+ *
+ * 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.operations.results;
+
+import android.os.Parcel;
+
+import java.util.Date;
+
+public class PgpSignEncryptResult extends OperationResult {
+
+    // the fourth bit indicates a "data pending" result! (it's also a form of non-success)
+    public static final int RESULT_PENDING = RESULT_ERROR + 8;
+
+    // fifth to sixth bit in addition indicate specific type of pending
+    public static final int RESULT_PENDING_PASSPHRASE = RESULT_PENDING + 16;
+    public static final int RESULT_PENDING_NFC = RESULT_PENDING + 32;
+
+    long mKeyIdPassphraseNeeded;
+
+    long mNfcKeyId;
+    byte[] mNfcHash;
+    int mNfcAlgo;
+    Date mNfcTimestamp;
+    String mNfcPassphrase;
+    byte[] mDetachedSignature;
+
+    public long getKeyIdPassphraseNeeded() {
+        return mKeyIdPassphraseNeeded;
+    }
+
+    public void setKeyIdPassphraseNeeded(long keyIdPassphraseNeeded) {
+        mKeyIdPassphraseNeeded = keyIdPassphraseNeeded;
+    }
+
+    public void setNfcData(long nfcKeyId, byte[] nfcHash, int nfcAlgo, Date nfcTimestamp, String passphrase) {
+        mNfcKeyId = nfcKeyId;
+        mNfcHash = nfcHash;
+        mNfcAlgo = nfcAlgo;
+        mNfcTimestamp = nfcTimestamp;
+        mNfcPassphrase = passphrase;
+    }
+
+    public void setDetachedSignature(byte[] detachedSignature) {
+        mDetachedSignature = detachedSignature;
+    }
+
+    public long getNfcKeyId() {
+        return mNfcKeyId;
+    }
+
+    public byte[] getNfcHash() {
+        return mNfcHash;
+    }
+
+    public int getNfcAlgo() {
+        return mNfcAlgo;
+    }
+
+    public Date getNfcTimestamp() {
+        return mNfcTimestamp;
+    }
+
+    public String getNfcPassphrase() {
+        return mNfcPassphrase;
+    }
+
+    public byte[] getDetachedSignature() {
+        return mDetachedSignature;
+    }
+
+    public boolean isPending() {
+        return (mResult & RESULT_PENDING) == RESULT_PENDING;
+    }
+
+    public PgpSignEncryptResult(int result, OperationLog log) {
+        super(result, log);
+    }
+
+    public PgpSignEncryptResult(Parcel source) {
+        super(source);
+        mNfcHash = source.readInt() != 0 ? source.createByteArray() : null;
+        mNfcAlgo = source.readInt();
+        mNfcTimestamp = source.readInt() != 0 ? new Date(source.readLong()) : null;
+        mDetachedSignature = source.readInt() != 0 ? source.createByteArray() : null;
+    }
+
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
+        if (mNfcHash != null) {
+            dest.writeInt(1);
+            dest.writeByteArray(mNfcHash);
+        } else {
+            dest.writeInt(0);
+        }
+        dest.writeInt(mNfcAlgo);
+        if (mNfcTimestamp != null) {
+            dest.writeInt(1);
+            dest.writeLong(mNfcTimestamp.getTime());
+        } else {
+            dest.writeInt(0);
+        }
+        if (mDetachedSignature != null) {
+            dest.writeInt(1);
+            dest.writeByteArray(mDetachedSignature);
+        } else {
+            dest.writeInt(0);
+        }
+    }
+
+    public static final Creator<PgpSignEncryptResult> CREATOR = new Creator<PgpSignEncryptResult>() {
+        public PgpSignEncryptResult createFromParcel(final Parcel source) {
+            return new PgpSignEncryptResult(source);
+        }
+
+        public PgpSignEncryptResult[] newArray(final int size) {
+            return new PgpSignEncryptResult[size];
+        }
+    };
+
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/SignEncryptResult.java

@@ -19,84 +19,42 @@ package org.sufficientlysecure.keychain.operations.results;
 
 import android.os.Parcel;
 
-import java.util.Date;
+import java.util.ArrayList;
 
 public class SignEncryptResult extends OperationResult {
 
-    // the fourth bit indicates a "data pending" result! (it's also a form of non-success)
+    ArrayList<PgpSignEncryptResult> mResults;
+    byte[] mResultBytes;
+
     public static final int RESULT_PENDING = RESULT_ERROR + 8;
 
-    // fifth to sixth bit in addition indicate specific type of pending
-    public static final int RESULT_PENDING_PASSPHRASE = RESULT_PENDING + 16;
-    public static final int RESULT_PENDING_NFC = RESULT_PENDING + 32;
-
-    long mKeyIdPassphraseNeeded;
-
-    long mNfcKeyId;
-    byte[] mNfcHash;
-    int mNfcAlgo;
-    Date mNfcTimestamp;
-    String mNfcPassphrase;
-    byte[] mDetachedSignature;
-
-    public long getKeyIdPassphraseNeeded() {
-        return mKeyIdPassphraseNeeded;
+    public PgpSignEncryptResult getPending() {
+        for (PgpSignEncryptResult sub : mResults) {
+            if (sub.isPending()) {
+                return sub;
+            }
+        }
+        return null;
     }
 
-    public void setKeyIdPassphraseNeeded(long keyIdPassphraseNeeded) {
-        mKeyIdPassphraseNeeded = keyIdPassphraseNeeded;
-    }
-
-    public void setNfcData(long nfcKeyId, byte[] nfcHash, int nfcAlgo, Date nfcTimestamp, String passphrase) {
-        mNfcKeyId = nfcKeyId;
-        mNfcHash = nfcHash;
-        mNfcAlgo = nfcAlgo;
-        mNfcTimestamp = nfcTimestamp;
-        mNfcPassphrase = passphrase;
-    }
-
-    public void setDetachedSignature(byte[] detachedSignature) {
-        mDetachedSignature = detachedSignature;
-    }
-
-    public long getNfcKeyId() {
-        return mNfcKeyId;
-    }
-
-    public byte[] getNfcHash() {
-        return mNfcHash;
-    }
-
-    public int getNfcAlgo() {
-        return mNfcAlgo;
-    }
-
-    public Date getNfcTimestamp() {
-        return mNfcTimestamp;
-    }
-
-    public String getNfcPassphrase() {
-        return mNfcPassphrase;
-    }
-
-    public byte[] getDetachedSignature() {
-        return mDetachedSignature;
-    }
-
-    public boolean isPending() {
-        return (mResult & RESULT_PENDING) == RESULT_PENDING;
-    }
-
-    public SignEncryptResult(int result, OperationLog log) {
+    public SignEncryptResult(int result, OperationLog log, ArrayList<PgpSignEncryptResult> results) {
         super(result, log);
+        mResults = results;
+    }
+
+    public SignEncryptResult(int result, OperationLog log, ArrayList<PgpSignEncryptResult> results, byte[] resultBytes) {
+        super(result, log);
+        mResults = results;
+        mResultBytes = resultBytes;
     }
 
     public SignEncryptResult(Parcel source) {
         super(source);
-        mNfcHash = source.readInt() != 0 ? source.createByteArray() : null;
-        mNfcAlgo = source.readInt();
-        mNfcTimestamp = source.readInt() != 0 ? new Date(source.readLong()) : null;
-        mDetachedSignature = source.readInt() != 0 ? source.createByteArray() : null;
+        mResults = source.createTypedArrayList(PgpSignEncryptResult.CREATOR);
+    }
+
+    public byte[] getResultBytes() {
+        return mResultBytes;
     }
 
     public int describeContents() {
@@ -105,25 +63,7 @@ public class SignEncryptResult extends OperationResult {
 
     public void writeToParcel(Parcel dest, int flags) {
         super.writeToParcel(dest, flags);
-        if (mNfcHash != null) {
-            dest.writeInt(1);
-            dest.writeByteArray(mNfcHash);
-        } else {
-            dest.writeInt(0);
-        }
-        dest.writeInt(mNfcAlgo);
-        if (mNfcTimestamp != null) {
-            dest.writeInt(1);
-            dest.writeLong(mNfcTimestamp.getTime());
-        } else {
-            dest.writeInt(0);
-        }
-        if (mDetachedSignature != null) {
-            dest.writeInt(1);
-            dest.writeByteArray(mDetachedSignature);
-        } else {
-            dest.writeInt(0);
-        }
+        dest.writeTypedList(mResults);
     }
 
     public static final Creator<SignEncryptResult> CREATOR = new Creator<SignEncryptResult>() {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/SingletonResult.java

@@ -18,13 +18,8 @@
 
 package org.sufficientlysecure.keychain.operations.results;
 
-import android.app.Activity;
 import android.os.Parcel;
 
-import com.github.johnpersano.supertoasts.SuperCardToast;
-import com.github.johnpersano.supertoasts.SuperToast;
-import com.github.johnpersano.supertoasts.util.Style;
-
 /** This is a simple subclass meant to contain only a single log message. This log
  * message is also shown without a log button in the createNotify SuperToast. */
 public class SingletonResult extends OperationResult {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java

@@ -39,7 +39,6 @@ import org.spongycastle.openpgp.jcajce.JcaPGPObjectFactory;
 import org.spongycastle.openpgp.operator.PBEDataDecryptorFactory;
 import org.spongycastle.openpgp.operator.PGPDigestCalculatorProvider;
 import org.spongycastle.openpgp.operator.PublicKeyDataDecryptorFactory;
-import org.spongycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator;
 import org.spongycastle.openpgp.operator.jcajce.JcaPGPContentVerifierBuilderProvider;
 import org.spongycastle.openpgp.operator.jcajce.JcaPGPDigestCalculatorProviderBuilder;
 import org.spongycastle.openpgp.operator.jcajce.JcePBEDataDecryptorFactoryBuilder;
@@ -47,12 +46,12 @@ import org.spongycastle.openpgp.operator.jcajce.NfcSyncPublicKeyDataDecryptorFac
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.operations.BaseOperation;
-import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
-import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
-import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
+import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.InputData;
 import org.sufficientlysecure.keychain.util.Log;
@@ -616,6 +615,7 @@ public class PgpDecryptVerify extends BaseOperation {
             int length;
             byte[] buffer = new byte[1 << 16];
             while ((length = dataIn.read(buffer)) > 0) {
+                Log.d(Constants.TAG, "read bytes: " + length);
                 if (mOutStream != null) {
                     mOutStream.write(buffer, 0, length);
                 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpHelper.java

@@ -24,8 +24,8 @@ import android.content.pm.PackageManager.NameNotFoundException;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.io.File;
 import java.io.IOException;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInput.java

@@ -0,0 +1,176 @@
+package org.sufficientlysecure.keychain.pgp;
+
+import org.spongycastle.bcpg.CompressionAlgorithmTags;
+import org.sufficientlysecure.keychain.Constants;
+
+import java.util.Date;
+
+public class PgpSignEncryptInput {
+
+    protected String mVersionHeader = null;
+    protected boolean mEnableAsciiArmorOutput = false;
+    protected int mCompressionId = CompressionAlgorithmTags.UNCOMPRESSED;
+    protected long[] mEncryptionMasterKeyIds = null;
+    protected String mSymmetricPassphrase = null;
+    protected int mSymmetricEncryptionAlgorithm = 0;
+    protected long mSignatureMasterKeyId = Constants.key.none;
+    protected Long mSignatureSubKeyId = null;
+    protected int mSignatureHashAlgorithm = 0;
+    protected String mSignaturePassphrase = null;
+    protected long mAdditionalEncryptId = Constants.key.none;
+    protected byte[] mNfcSignedHash = null;
+    protected Date mNfcCreationTimestamp = null;
+    protected boolean mFailOnMissingEncryptionKeyIds = false;
+    protected String mCharset;
+    protected boolean mCleartextSignature;
+    protected boolean mDetachedSignature;
+
+    public String getCharset() {
+        return mCharset;
+    }
+
+    public void setCharset(String mCharset) {
+        this.mCharset = mCharset;
+    }
+
+    public boolean ismFailOnMissingEncryptionKeyIds() {
+        return mFailOnMissingEncryptionKeyIds;
+    }
+
+    public Date getNfcCreationTimestamp() {
+        return mNfcCreationTimestamp;
+    }
+
+    public byte[] getNfcSignedHash() {
+        return mNfcSignedHash;
+    }
+
+    public long getAdditionalEncryptId() {
+        return mAdditionalEncryptId;
+    }
+
+    public PgpSignEncryptInput setAdditionalEncryptId(long additionalEncryptId) {
+        mAdditionalEncryptId = additionalEncryptId;
+        return this;
+    }
+
+    public String getSignaturePassphrase() {
+        return mSignaturePassphrase;
+    }
+
+    public PgpSignEncryptInput setSignaturePassphrase(String signaturePassphrase) {
+        mSignaturePassphrase = signaturePassphrase;
+        return this;
+    }
+
+    public int getSignatureHashAlgorithm() {
+        return mSignatureHashAlgorithm;
+    }
+
+    public PgpSignEncryptInput setSignatureHashAlgorithm(int signatureHashAlgorithm) {
+        mSignatureHashAlgorithm = signatureHashAlgorithm;
+        return this;
+    }
+
+    public Long getSignatureSubKeyId() {
+        return mSignatureSubKeyId;
+    }
+
+    public PgpSignEncryptInput setSignatureSubKeyId(long signatureSubKeyId) {
+        mSignatureSubKeyId = signatureSubKeyId;
+        return this;
+    }
+
+    public long getSignatureMasterKeyId() {
+        return mSignatureMasterKeyId;
+    }
+
+    public PgpSignEncryptInput setSignatureMasterKeyId(long signatureMasterKeyId) {
+        mSignatureMasterKeyId = signatureMasterKeyId;
+        return this;
+    }
+
+    public int getSymmetricEncryptionAlgorithm() {
+        return mSymmetricEncryptionAlgorithm;
+    }
+
+    public PgpSignEncryptInput setSymmetricEncryptionAlgorithm(int symmetricEncryptionAlgorithm) {
+        mSymmetricEncryptionAlgorithm = symmetricEncryptionAlgorithm;
+        return this;
+    }
+
+    public String getSymmetricPassphrase() {
+        return mSymmetricPassphrase;
+    }
+
+    public PgpSignEncryptInput setSymmetricPassphrase(String symmetricPassphrase) {
+        mSymmetricPassphrase = symmetricPassphrase;
+        return this;
+    }
+
+    public long[] getEncryptionMasterKeyIds() {
+        return mEncryptionMasterKeyIds;
+    }
+
+    public PgpSignEncryptInput setEncryptionMasterKeyIds(long[] encryptionMasterKeyIds) {
+        mEncryptionMasterKeyIds = encryptionMasterKeyIds;
+        return this;
+    }
+
+    public int getCompressionId() {
+        return mCompressionId;
+    }
+
+    public PgpSignEncryptInput setCompressionId(int compressionId) {
+        mCompressionId = compressionId;
+        return this;
+    }
+
+    public boolean ismEnableAsciiArmorOutput() {
+        return mEnableAsciiArmorOutput;
+    }
+
+    public String getVersionHeader() {
+        return mVersionHeader;
+    }
+
+    public PgpSignEncryptInput setVersionHeader(String versionHeader) {
+        mVersionHeader = versionHeader;
+        return this;
+    }
+
+    public PgpSignEncryptInput setEnableAsciiArmorOutput(boolean enableAsciiArmorOutput) {
+        mEnableAsciiArmorOutput = enableAsciiArmorOutput;
+        return this;
+    }
+
+    public PgpSignEncryptInput setFailOnMissingEncryptionKeyIds(boolean failOnMissingEncryptionKeyIds) {
+        mFailOnMissingEncryptionKeyIds = failOnMissingEncryptionKeyIds;
+        return this;
+    }
+
+    public PgpSignEncryptInput setNfcState(byte[] signedHash, Date creationTimestamp) {
+        mNfcSignedHash = signedHash;
+        mNfcCreationTimestamp = creationTimestamp;
+        return this;
+    }
+
+    public PgpSignEncryptInput setCleartextSignature(boolean cleartextSignature) {
+        this.mCleartextSignature = cleartextSignature;
+        return this;
+    }
+
+    public boolean isCleartextSignature() {
+        return mCleartextSignature;
+    }
+
+    public PgpSignEncryptInput setDetachedSignature(boolean detachedSignature) {
+        this.mDetachedSignature = detachedSignature;
+        return this;
+    }
+
+    public boolean isDetachedSignature() {
+        return mDetachedSignature;
+    }
+}
+

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptOperation.java

@@ -25,6 +25,7 @@ import org.spongycastle.bcpg.ArmoredOutputStream;
 import org.spongycastle.bcpg.BCPGOutputStream;
 import org.spongycastle.bcpg.CompressionAlgorithmTags;
 import org.spongycastle.openpgp.PGPCompressedDataGenerator;
+import org.spongycastle.openpgp.PGPEncryptedData;
 import org.spongycastle.openpgp.PGPEncryptedDataGenerator;
 import org.spongycastle.openpgp.PGPException;
 import org.spongycastle.openpgp.PGPLiteralData;
@@ -37,13 +38,13 @@ import org.spongycastle.util.encoders.Hex;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.operations.BaseOperation;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.InputData;
 import org.sufficientlysecure.keychain.util.Log;
@@ -60,33 +61,23 @@ import java.security.SignatureException;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.LinkedList;
+import java.util.concurrent.atomic.AtomicBoolean;
 
-/**
- * This class uses a Builder pattern!
+/** This class supports a single, low-level, sign/encrypt operation.
+ *
+ * The operation of this class takes an Input- and OutputStream plus a
+ * PgpSignEncryptInput, and signs and/or encrypts the stream as
+ * parametrized in the PgpSignEncryptInput object. It returns its status
+ * and a possible detached signature as a SignEncryptResult.
+ *
+ * For a high-level operation based on URIs, see SignEncryptOperation.
+ *
+ * @see org.sufficientlysecure.keychain.pgp.PgpSignEncryptInput
+ * @see org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult
+ * @see org.sufficientlysecure.keychain.operations.SignEncryptOperation
+ *
  */
-public class PgpSignEncrypt extends BaseOperation {
-    private String mVersionHeader;
-    private InputData mData;
-    private OutputStream mOutStream;
-
-    private boolean mEnableAsciiArmorOutput;
-    private int mCompressionId;
-    private long[] mEncryptionMasterKeyIds;
-    private String mSymmetricPassphrase;
-    private int mSymmetricEncryptionAlgorithm;
-    private long mSignatureMasterKeyId;
-    private Long mSignatureSubKeyId;
-    private int mSignatureHashAlgorithm;
-    private String mSignaturePassphrase;
-    private long mAdditionalEncryptId;
-    private boolean mCleartextSignature;
-    private boolean mDetachedSignature;
-    private String mOriginalFilename;
-    private boolean mFailOnMissingEncryptionKeyIds;
-    private String mCharset;
-
-    private byte[] mNfcSignedHash = null;
-    private Date mNfcCreationTimestamp = null;
+public class PgpSignEncryptOperation extends BaseOperation {
 
     private static byte[] NEW_LINE;
 
@@ -98,253 +89,107 @@ public class PgpSignEncrypt extends BaseOperation {
         }
     }
 
-    protected PgpSignEncrypt(Builder builder) {
-        super(builder.mContext, builder.mProviderHelper, builder.mProgressable);
-
-        // private Constructor can only be called from Builder
-        this.mVersionHeader = builder.mVersionHeader;
-        this.mData = builder.mData;
-        this.mOutStream = builder.mOutStream;
-
-        this.mEnableAsciiArmorOutput = builder.mEnableAsciiArmorOutput;
-        this.mCompressionId = builder.mCompressionId;
-        this.mEncryptionMasterKeyIds = builder.mEncryptionMasterKeyIds;
-        this.mSymmetricPassphrase = builder.mSymmetricPassphrase;
-        this.mSymmetricEncryptionAlgorithm = builder.mSymmetricEncryptionAlgorithm;
-        this.mSignatureMasterKeyId = builder.mSignatureMasterKeyId;
-        this.mSignatureSubKeyId = builder.mSignatureSubKeyId;
-        this.mSignatureHashAlgorithm = builder.mSignatureHashAlgorithm;
-        this.mSignaturePassphrase = builder.mSignaturePassphrase;
-        this.mAdditionalEncryptId = builder.mAdditionalEncryptId;
-        this.mCleartextSignature = builder.mCleartextSignature;
-        this.mDetachedSignature = builder.mDetachedSignature;
-        this.mNfcSignedHash = builder.mNfcSignedHash;
-        this.mNfcCreationTimestamp = builder.mNfcCreationTimestamp;
-        this.mOriginalFilename = builder.mOriginalFilename;
-        this.mFailOnMissingEncryptionKeyIds = builder.mFailOnMissingEncryptionKeyIds;
-        this.mCharset = builder.mCharset;
+    public PgpSignEncryptOperation(Context context, ProviderHelper providerHelper, Progressable progressable, AtomicBoolean cancelled) {
+        super(context, providerHelper, progressable, cancelled);
     }
 
-    public static class Builder {
-        // mandatory parameter
-        private Context mContext;
-        private ProviderHelper mProviderHelper;
-        private Progressable mProgressable;
-        private InputData mData;
-        private OutputStream mOutStream;
-
-        // optional
-        private String mVersionHeader = null;
-        private boolean mEnableAsciiArmorOutput = false;
-        private int mCompressionId = CompressionAlgorithmTags.UNCOMPRESSED;
-        private long[] mEncryptionMasterKeyIds = null;
-        private String mSymmetricPassphrase = null;
-        private int mSymmetricEncryptionAlgorithm = 0;
-        private long mSignatureMasterKeyId = Constants.key.none;
-        private Long mSignatureSubKeyId = null;
-        private int mSignatureHashAlgorithm = 0;
-        private String mSignaturePassphrase = null;
-        private long mAdditionalEncryptId = Constants.key.none;
-        private boolean mCleartextSignature = false;
-        private boolean mDetachedSignature = false;
-        private String mOriginalFilename = "";
-        private byte[] mNfcSignedHash = null;
-        private Date mNfcCreationTimestamp = null;
-        private boolean mFailOnMissingEncryptionKeyIds = false;
-        private String mCharset = null;
-
-        public Builder(Context context, ProviderHelper providerHelper, Progressable progressable,
-                       InputData data, OutputStream outStream) {
-            mContext = context;
-            mProviderHelper = providerHelper;
-            mProgressable = progressable;
-
-            mData = data;
-            mOutStream = outStream;
-        }
-
-        public Builder setVersionHeader(String versionHeader) {
-            mVersionHeader = versionHeader;
-            return this;
-        }
-
-        public Builder setEnableAsciiArmorOutput(boolean enableAsciiArmorOutput) {
-            mEnableAsciiArmorOutput = enableAsciiArmorOutput;
-            return this;
-        }
-
-        public Builder setCompressionId(int compressionId) {
-            mCompressionId = compressionId;
-            return this;
-        }
-
-        public Builder setEncryptionMasterKeyIds(long[] encryptionMasterKeyIds) {
-            mEncryptionMasterKeyIds = encryptionMasterKeyIds;
-            return this;
-        }
-
-        public Builder setSymmetricPassphrase(String symmetricPassphrase) {
-            mSymmetricPassphrase = symmetricPassphrase;
-            return this;
-        }
-
-        public Builder setSymmetricEncryptionAlgorithm(int symmetricEncryptionAlgorithm) {
-            mSymmetricEncryptionAlgorithm = symmetricEncryptionAlgorithm;
-            return this;
-        }
-
-        public Builder setSignatureMasterKeyId(long signatureMasterKeyId) {
-            mSignatureMasterKeyId = signatureMasterKeyId;
-            return this;
-        }
-
-        public Builder setSignatureSubKeyId(long signatureSubKeyId) {
-            mSignatureSubKeyId = signatureSubKeyId;
-            return this;
-        }
-
-        public Builder setSignatureHashAlgorithm(int signatureHashAlgorithm) {
-            mSignatureHashAlgorithm = signatureHashAlgorithm;
-            return this;
-        }
-
-        public Builder setSignaturePassphrase(String signaturePassphrase) {
-            mSignaturePassphrase = signaturePassphrase;
-            return this;
-        }
-
-        public Builder setFailOnMissingEncryptionKeyIds(boolean failOnMissingEncryptionKeyIds) {
-            mFailOnMissingEncryptionKeyIds = failOnMissingEncryptionKeyIds;
-            return this;
-        }
-
-        public Builder setCharset(String charset) {
-            mCharset = charset;
-            return this;
-        }
-
-        /**
-         * Also encrypt with the signing keyring
-         *
-         * @param additionalEncryptId
-         * @return
-         */
-        public Builder setAdditionalEncryptId(long additionalEncryptId) {
-            mAdditionalEncryptId = additionalEncryptId;
-            return this;
-        }
-
-        public Builder setCleartextSignature(boolean cleartextSignature) {
-            mCleartextSignature = cleartextSignature;
-            return this;
-        }
-
-        public Builder setDetachedSignature(boolean detachedSignature) {
-            mDetachedSignature = detachedSignature;
-            return this;
-        }
-
-        public Builder setOriginalFilename(String originalFilename) {
-            mOriginalFilename = originalFilename;
-            return this;
-        }
-
-        public Builder setNfcState(byte[] signedHash, Date creationTimestamp) {
-            mNfcSignedHash = signedHash;
-            mNfcCreationTimestamp = creationTimestamp;
-            return this;
-        }
-
-        public PgpSignEncrypt build() {
-            return new PgpSignEncrypt(this);
-        }
+    public PgpSignEncryptOperation(Context context, ProviderHelper providerHelper, Progressable progressable) {
+        super(context, providerHelper, progressable);
     }
 
     /**
      * Signs and/or encrypts data based on parameters of class
      */
-    public SignEncryptResult execute() {
+    public PgpSignEncryptResult execute(PgpSignEncryptInput input,
+                                     InputData inputData, OutputStream outputStream) {
 
         int indent = 0;
         OperationLog log = new OperationLog();
 
-        log.add(LogType.MSG_SE, indent);
+        log.add(LogType.MSG_PSE, indent);
         indent += 1;
 
-        boolean enableSignature = mSignatureMasterKeyId != Constants.key.none;
-        boolean enableEncryption = ((mEncryptionMasterKeyIds != null && mEncryptionMasterKeyIds.length > 0)
-                || mSymmetricPassphrase != null);
-        boolean enableCompression = (mCompressionId != CompressionAlgorithmTags.UNCOMPRESSED);
+        boolean enableSignature = input.getSignatureMasterKeyId() != Constants.key.none;
+        boolean enableEncryption = ((input.getEncryptionMasterKeyIds() != null && input.getEncryptionMasterKeyIds().length > 0)
+                || input.getSymmetricPassphrase() != null);
+        boolean enableCompression = (input.getCompressionId() != CompressionAlgorithmTags.UNCOMPRESSED);
 
         Log.d(Constants.TAG, "enableSignature:" + enableSignature
                 + "\nenableEncryption:" + enableEncryption
                 + "\nenableCompression:" + enableCompression
-                + "\nenableAsciiArmorOutput:" + mEnableAsciiArmorOutput);
+                + "\nenableAsciiArmorOutput:" + input.ismEnableAsciiArmorOutput());
 
         // add additional key id to encryption ids (mostly to do self-encryption)
-        if (enableEncryption && mAdditionalEncryptId != Constants.key.none) {
-            mEncryptionMasterKeyIds = Arrays.copyOf(mEncryptionMasterKeyIds, mEncryptionMasterKeyIds.length + 1);
-            mEncryptionMasterKeyIds[mEncryptionMasterKeyIds.length - 1] = mAdditionalEncryptId;
+        if (enableEncryption && input.getAdditionalEncryptId() != Constants.key.none) {
+            input.setEncryptionMasterKeyIds(Arrays.copyOf(input.getEncryptionMasterKeyIds(), input.getEncryptionMasterKeyIds().length + 1));
+            input.getEncryptionMasterKeyIds()[input.getEncryptionMasterKeyIds().length - 1] = input.getAdditionalEncryptId();
         }
 
         ArmoredOutputStream armorOut = null;
         OutputStream out;
-        if (mEnableAsciiArmorOutput) {
-            armorOut = new ArmoredOutputStream(mOutStream);
-            if (mVersionHeader != null) {
-                armorOut.setHeader("Version", mVersionHeader);
+        if (input.ismEnableAsciiArmorOutput()) {
+            armorOut = new ArmoredOutputStream(outputStream);
+            if (input.getVersionHeader() != null) {
+                armorOut.setHeader("Version", input.getVersionHeader());
             }
             // if we have a charset, put it in the header
-            if (mCharset != null) {
-                armorOut.setHeader("Charset", mCharset);
+            if (input.getCharset() != null) {
+                armorOut.setHeader("Charset", input.getCharset());
             }
             out = armorOut;
         } else {
-            out = mOutStream;
+            out = outputStream;
         }
 
         /* Get keys for signature generation for later usage */
         CanonicalizedSecretKey signingKey = null;
-        long signKeyId;
         if (enableSignature) {
 
             try {
                 // fetch the indicated master key id (the one whose name we sign in)
                 CanonicalizedSecretKeyRing signingKeyRing =
-                        mProviderHelper.getCanonicalizedSecretKeyRing(mSignatureMasterKeyId);
+                        mProviderHelper.getCanonicalizedSecretKeyRing(input.getSignatureMasterKeyId());
+
+                long signKeyId;
+                // use specified signing subkey, or find the one to use
+                if (input.getSignatureSubKeyId() == null) {
+                    signKeyId = signingKeyRing.getSecretSignId();
+                } else {
+                    signKeyId = input.getSignatureSubKeyId();
+                }
+
                 // fetch the specific subkey to sign with, or just use the master key if none specified
-                signKeyId = mSignatureSubKeyId != null ? mSignatureSubKeyId : mSignatureMasterKeyId;
                 signingKey = signingKeyRing.getSecretKey(signKeyId);
-                // make sure it's a signing key alright!
-            } catch (ProviderHelper.NotFoundException e) {
-                log.add(LogType.MSG_SE_ERROR_SIGN_KEY, indent);
-                return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+
+            } catch (ProviderHelper.NotFoundException | PgpGeneralException e) {
+                log.add(LogType.MSG_PSE_ERROR_SIGN_KEY, indent);
+                return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
             }
 
             // Make sure we are allowed to sign here!
             if (!signingKey.canSign()) {
-                log.add(LogType.MSG_SE_ERROR_KEY_SIGN, indent);
-                return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                log.add(LogType.MSG_PSE_ERROR_KEY_SIGN, indent);
+                return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
             }
 
             // if no passphrase was explicitly set try to get it from the cache service
-            if (mSignaturePassphrase == null) {
+            if (input.getSignaturePassphrase() == null) {
                 try {
                     // returns "" if key has no passphrase
-                    mSignaturePassphrase = getCachedPassphrase(signKeyId);
+                    input.setSignaturePassphrase(getCachedPassphrase(signingKey.getKeyId()));
                     // TODO
 //                    log.add(LogType.MSG_DC_PASS_CACHED, indent + 1);
                 } catch (PassphraseCacheInterface.NoSecretKeyException e) {
                     // TODO
 //                    log.add(LogType.MSG_DC_ERROR_NO_KEY, indent + 1);
-                    return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                    return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
                 }
 
                 // if passphrase was not cached, return here indicating that a passphrase is missing!
-                if (mSignaturePassphrase == null) {
-                    log.add(LogType.MSG_SE_PENDING_PASSPHRASE, indent + 1);
-                    SignEncryptResult result = new SignEncryptResult(SignEncryptResult.RESULT_PENDING_PASSPHRASE, log);
-                    result.setKeyIdPassphraseNeeded(signKeyId);
+                if (input.getSignaturePassphrase() == null) {
+                    log.add(LogType.MSG_PSE_PENDING_PASSPHRASE, indent + 1);
+                    PgpSignEncryptResult result = new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE, log);
+                    result.setKeyIdPassphraseNeeded(signingKey.getKeyId());
                     return result;
                 }
             }
@@ -352,20 +197,24 @@ public class PgpSignEncrypt extends BaseOperation {
             updateProgress(R.string.progress_extracting_signature_key, 0, 100);
 
             try {
-                if (!signingKey.unlock(mSignaturePassphrase)) {
-                    log.add(LogType.MSG_SE_ERROR_BAD_PASSPHRASE, indent);
-                    return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                if (!signingKey.unlock(input.getSignaturePassphrase())) {
+                    log.add(LogType.MSG_PSE_ERROR_BAD_PASSPHRASE, indent);
+                    return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
                 }
             } catch (PgpGeneralException e) {
-                log.add(LogType.MSG_SE_ERROR_UNLOCK, indent);
-                return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                log.add(LogType.MSG_PSE_ERROR_UNLOCK, indent);
+                return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
             }
 
             // check if hash algo is supported
+            int requestedAlgorithm = input.getSignatureHashAlgorithm();
             LinkedList<Integer> supported = signingKey.getSupportedHashAlgorithms();
-            if (!supported.contains(mSignatureHashAlgorithm)) {
+            if (requestedAlgorithm == 0) {
                 // get most preferred
-                mSignatureHashAlgorithm = supported.getLast();
+                input.setSignatureHashAlgorithm(supported.getLast());
+            } else if (!supported.contains(requestedAlgorithm)) {
+                log.add(LogType.MSG_PSE_ERROR_HASH_ALGO, indent);
+                return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
             }
         }
         updateProgress(R.string.progress_preparing_streams, 2, 100);
@@ -373,44 +222,48 @@ public class PgpSignEncrypt extends BaseOperation {
         /* Initialize PGPEncryptedDataGenerator for later usage */
         PGPEncryptedDataGenerator cPk = null;
         if (enableEncryption) {
+            int algo = input.getSymmetricEncryptionAlgorithm();
+            if (algo == 0) {
+                algo = PGPEncryptedData.AES_128;
+            }
             // has Integrity packet enabled!
             JcePGPDataEncryptorBuilder encryptorBuilder =
-                    new JcePGPDataEncryptorBuilder(mSymmetricEncryptionAlgorithm)
+                    new JcePGPDataEncryptorBuilder(algo)
                             .setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME)
                             .setWithIntegrityPacket(true);
 
             cPk = new PGPEncryptedDataGenerator(encryptorBuilder);
 
-            if (mSymmetricPassphrase != null) {
+            if (input.getSymmetricPassphrase() != null) {
                 // Symmetric encryption
-                log.add(LogType.MSG_SE_SYMMETRIC, indent);
+                log.add(LogType.MSG_PSE_SYMMETRIC, indent);
 
                 JcePBEKeyEncryptionMethodGenerator symmetricEncryptionGenerator =
-                        new JcePBEKeyEncryptionMethodGenerator(mSymmetricPassphrase.toCharArray());
+                        new JcePBEKeyEncryptionMethodGenerator(input.getSymmetricPassphrase().toCharArray());
                 cPk.addMethod(symmetricEncryptionGenerator);
             } else {
-                log.add(LogType.MSG_SE_ASYMMETRIC, indent);
+                log.add(LogType.MSG_PSE_ASYMMETRIC, indent);
 
                 // Asymmetric encryption
-                for (long id : mEncryptionMasterKeyIds) {
+                for (long id : input.getEncryptionMasterKeyIds()) {
                     try {
                         CanonicalizedPublicKeyRing keyRing = mProviderHelper.getCanonicalizedPublicKeyRing(
                                 KeyRings.buildUnifiedKeyRingUri(id));
                         CanonicalizedPublicKey key = keyRing.getEncryptionSubKey();
                         cPk.addMethod(key.getPubKeyEncryptionGenerator());
-                        log.add(LogType.MSG_SE_KEY_OK, indent + 1,
+                        log.add(LogType.MSG_PSE_KEY_OK, indent + 1,
                                 KeyFormattingUtils.convertKeyIdToHex(id));
                     } catch (PgpKeyNotFoundException e) {
-                        log.add(LogType.MSG_SE_KEY_WARN, indent + 1,
+                        log.add(LogType.MSG_PSE_KEY_WARN, indent + 1,
                                 KeyFormattingUtils.convertKeyIdToHex(id));
-                        if (mFailOnMissingEncryptionKeyIds) {
-                            return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                        if (input.ismFailOnMissingEncryptionKeyIds()) {
+                            return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
                         }
                     } catch (ProviderHelper.NotFoundException e) {
-                        log.add(LogType.MSG_SE_KEY_UNKNOWN, indent + 1,
+                        log.add(LogType.MSG_PSE_KEY_UNKNOWN, indent + 1,
                                 KeyFormattingUtils.convertKeyIdToHex(id));
-                        if (mFailOnMissingEncryptionKeyIds) {
-                            return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                        if (input.ismFailOnMissingEncryptionKeyIds()) {
+                            return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
                         }
                     }
                 }
@@ -423,12 +276,12 @@ public class PgpSignEncrypt extends BaseOperation {
             updateProgress(R.string.progress_preparing_signature, 4, 100);
 
             try {
-                boolean cleartext = mCleartextSignature && mEnableAsciiArmorOutput && !enableEncryption;
+                boolean cleartext = input.isCleartextSignature() && input.ismEnableAsciiArmorOutput() && !enableEncryption;
                 signatureGenerator = signingKey.getSignatureGenerator(
-                        mSignatureHashAlgorithm, cleartext, mNfcSignedHash, mNfcCreationTimestamp);
+                        input.getSignatureHashAlgorithm(), cleartext, input.getNfcSignedHash(), input.getNfcCreationTimestamp());
             } catch (PgpGeneralException e) {
-                log.add(LogType.MSG_SE_ERROR_NFC, indent);
-                return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+                log.add(LogType.MSG_PSE_ERROR_NFC, indent);
+                return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
             }
         }
 
@@ -449,8 +302,8 @@ public class PgpSignEncrypt extends BaseOperation {
                 /* actual encryption */
                 updateProgress(R.string.progress_encrypting, 8, 100);
                 log.add(enableSignature
-                                ? LogType.MSG_SE_SIGCRYPTING
-                                : LogType.MSG_SE_ENCRYPTING,
+                                ? LogType.MSG_PSE_SIGCRYPTING
+                                : LogType.MSG_PSE_ENCRYPTING,
                         indent
                 );
                 indent += 1;
@@ -458,8 +311,8 @@ public class PgpSignEncrypt extends BaseOperation {
                 encryptionOut = cPk.open(out, new byte[1 << 16]);
 
                 if (enableCompression) {
-                    log.add(LogType.MSG_SE_COMPRESSING, indent);
-                    compressGen = new PGPCompressedDataGenerator(mCompressionId);
+                    log.add(LogType.MSG_PSE_COMPRESSING, indent);
+                    compressGen = new PGPCompressedDataGenerator(input.getCompressionId());
                     bcpgOut = new BCPGOutputStream(compressGen.open(encryptionOut));
                 } else {
                     bcpgOut = new BCPGOutputStream(encryptionOut);
@@ -471,18 +324,18 @@ public class PgpSignEncrypt extends BaseOperation {
 
                 PGPLiteralDataGenerator literalGen = new PGPLiteralDataGenerator();
                 char literalDataFormatTag;
-                if (mCleartextSignature) {
+                if (input.isCleartextSignature()) {
                     literalDataFormatTag = PGPLiteralData.UTF8;
                 } else {
                     literalDataFormatTag = PGPLiteralData.BINARY;
                 }
-                pOut = literalGen.open(bcpgOut, literalDataFormatTag, mOriginalFilename, new Date(),
-                        new byte[1 << 16]);
+                pOut = literalGen.open(bcpgOut, literalDataFormatTag,
+                        inputData.getOriginalFilename(), new Date(), new byte[1 << 16]);
 
                 long alreadyWritten = 0;
                 int length;
                 byte[] buffer = new byte[1 << 16];
-                InputStream in = mData.getInputStream();
+                InputStream in = inputData.getInputStream();
                 while ((length = in.read(buffer)) > 0) {
                     pOut.write(buffer, 0, length);
 
@@ -492,8 +345,8 @@ public class PgpSignEncrypt extends BaseOperation {
                     }
 
                     alreadyWritten += length;
-                    if (mData.getSize() > 0) {
-                        long progress = 100 * alreadyWritten / mData.getSize();
+                    if (inputData.getSize() > 0) {
+                        long progress = 100 * alreadyWritten / inputData.getSize();
                         progressScaler.setProgress((int) progress, 100);
                     }
                 }
@@ -501,16 +354,16 @@ public class PgpSignEncrypt extends BaseOperation {
                 literalGen.close();
                 indent -= 1;
 
-            } else if (enableSignature && mCleartextSignature && mEnableAsciiArmorOutput) {
+            } else if (enableSignature && input.isCleartextSignature() && input.ismEnableAsciiArmorOutput()) {
                 /* cleartext signature: sign-only of ascii text */
 
                 updateProgress(R.string.progress_signing, 8, 100);
-                log.add(LogType.MSG_SE_SIGNING, indent);
+                log.add(LogType.MSG_PSE_SIGNING_CLEARTEXT, indent);
 
                 // write -----BEGIN PGP SIGNED MESSAGE-----
-                armorOut.beginClearText(mSignatureHashAlgorithm);
+                armorOut.beginClearText(input.getSignatureHashAlgorithm());
 
-                InputStream in = mData.getInputStream();
+                InputStream in = inputData.getInputStream();
                 final BufferedReader reader = new BufferedReader(new InputStreamReader(in));
 
                 // update signature buffer with first line
@@ -536,21 +389,21 @@ public class PgpSignEncrypt extends BaseOperation {
                 armorOut.endClearText();
 
                 pOut = new BCPGOutputStream(armorOut);
-            } else if (enableSignature && mDetachedSignature) {
+            } else if (enableSignature && input.isDetachedSignature()) {
                 /* detached signature */
 
                 updateProgress(R.string.progress_signing, 8, 100);
-                log.add(LogType.MSG_SE_SIGNING, indent);
+                log.add(LogType.MSG_PSE_SIGNING_DETACHED, indent);
 
-                InputStream in = mData.getInputStream();
+                InputStream in = inputData.getInputStream();
 
                 // handle output stream separately for detached signatures
                 detachedByteOut = new ByteArrayOutputStream();
                 OutputStream detachedOut = detachedByteOut;
-                if (mEnableAsciiArmorOutput) {
+                if (input.ismEnableAsciiArmorOutput()) {
                     detachedArmorOut = new ArmoredOutputStream(detachedOut);
-                    if (mVersionHeader != null) {
-                        detachedArmorOut.setHeader("Version", mVersionHeader);
+                    if (input.getVersionHeader() != null) {
+                        detachedArmorOut.setHeader("Version", input.getVersionHeader());
                     }
 
                     detachedOut = detachedArmorOut;
@@ -566,23 +419,23 @@ public class PgpSignEncrypt extends BaseOperation {
                     signatureGenerator.update(buffer, 0, length);
 
                     alreadyWritten += length;
-                    if (mData.getSize() > 0) {
-                        long progress = 100 * alreadyWritten / mData.getSize();
+                    if (inputData.getSize() > 0) {
+                        long progress = 100 * alreadyWritten / inputData.getSize();
                         progressScaler.setProgress((int) progress, 100);
                     }
                 }
 
                 pOut = null;
-            } else if (enableSignature && !mCleartextSignature && !mDetachedSignature) {
+            } else if (enableSignature && !input.isCleartextSignature() && !input.isDetachedSignature()) {
                 /* sign-only binary (files/data stream) */
 
                 updateProgress(R.string.progress_signing, 8, 100);
-                log.add(LogType.MSG_SE_SIGNING, indent);
+                log.add(LogType.MSG_PSE_SIGNING, indent);
 
-                InputStream in = mData.getInputStream();
+                InputStream in = inputData.getInputStream();
 
                 if (enableCompression) {
-                    compressGen = new PGPCompressedDataGenerator(mCompressionId);
+                    compressGen = new PGPCompressedDataGenerator(input.getCompressionId());
                     bcpgOut = new BCPGOutputStream(compressGen.open(out));
                 } else {
                     bcpgOut = new BCPGOutputStream(out);
@@ -591,7 +444,8 @@ public class PgpSignEncrypt extends BaseOperation {
                 signatureGenerator.generateOnePassVersion(false).encode(bcpgOut);
 
                 PGPLiteralDataGenerator literalGen = new PGPLiteralDataGenerator();
-                pOut = literalGen.open(bcpgOut, PGPLiteralData.BINARY, mOriginalFilename, new Date(),
+                pOut = literalGen.open(bcpgOut, PGPLiteralData.BINARY,
+                        inputData.getOriginalFilename(), new Date(),
                         new byte[1 << 16]);
 
                 long alreadyWritten = 0;
@@ -603,8 +457,8 @@ public class PgpSignEncrypt extends BaseOperation {
                     signatureGenerator.update(buffer, 0, length);
 
                     alreadyWritten += length;
-                    if (mData.getSize() > 0) {
-                        long progress = 100 * alreadyWritten / mData.getSize();
+                    if (inputData.getSize() > 0) {
+                        long progress = 100 * alreadyWritten / inputData.getSize();
                         progressScaler.setProgress((int) progress, 100);
                     }
                 }
@@ -613,7 +467,7 @@ public class PgpSignEncrypt extends BaseOperation {
             } else {
                 pOut = null;
                 // TODO: Is this log right?
-                log.add(LogType.MSG_SE_CLEARSIGN_ONLY, indent);
+                log.add(LogType.MSG_PSE_CLEARSIGN_ONLY, indent);
             }
 
             if (enableSignature) {
@@ -626,12 +480,12 @@ public class PgpSignEncrypt extends BaseOperation {
                     }
                 } catch (NfcSyncPGPContentSignerBuilder.NfcInteractionNeeded e) {
                     // this secret key diverts to a OpenPGP card, throw exception with hash that will be signed
-                    log.add(LogType.MSG_SE_PENDING_NFC, indent);
-                    SignEncryptResult result =
-                            new SignEncryptResult(SignEncryptResult.RESULT_PENDING_NFC, log);
+                    log.add(LogType.MSG_PSE_PENDING_NFC, indent);
+                    PgpSignEncryptResult result =
+                            new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_PENDING_NFC, log);
                     // Note that the checked key here is the master key, not the signing key
                     // (although these are always the same on Yubikeys)
-                    result.setNfcData(mSignatureSubKeyId, e.hashToSign, e.hashAlgo, e.creationTimestamp, mSignaturePassphrase);
+                    result.setNfcData(input.getSignatureSubKeyId(), e.hashToSign, e.hashAlgo, e.creationTimestamp, input.getSignaturePassphrase());
                     Log.d(Constants.TAG, "e.hashToSign" + Hex.toHexString(e.hashToSign));
                     return result;
                 }
@@ -661,25 +515,25 @@ public class PgpSignEncrypt extends BaseOperation {
             if (out != null) {
                 out.close();
             }
-            if (mOutStream != null) {
-                mOutStream.close();
+            if (outputStream != null) {
+                outputStream.close();
             }
 
         } catch (SignatureException e) {
-            log.add(LogType.MSG_SE_ERROR_SIG, indent);
-            return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+            log.add(LogType.MSG_PSE_ERROR_SIG, indent);
+            return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
         } catch (PGPException e) {
-            log.add(LogType.MSG_SE_ERROR_PGP, indent);
-            return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+            log.add(LogType.MSG_PSE_ERROR_PGP, indent);
+            return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
         } catch (IOException e) {
-            log.add(LogType.MSG_SE_ERROR_IO, indent);
-            return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log);
+            log.add(LogType.MSG_PSE_ERROR_IO, indent);
+            return new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_ERROR, log);
         }
 
         updateProgress(R.string.progress_done, 100, 100);
 
-        log.add(LogType.MSG_SE_OK, indent);
-        SignEncryptResult result = new SignEncryptResult(SignEncryptResult.RESULT_OK, log);
+        log.add(LogType.MSG_PSE_OK, indent);
+        PgpSignEncryptResult result = new PgpSignEncryptResult(PgpSignEncryptResult.RESULT_OK, log);
         if (detachedByteOut != null) {
             try {
                 detachedByteOut.flush();

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/SignEncryptParcel.java

@@ -0,0 +1,135 @@
+package org.sufficientlysecure.keychain.pgp;
+
+import android.net.Uri;
+import android.os.Parcel;
+import android.os.Parcelable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+/** This parcel stores the input of one or more PgpSignEncrypt operations.
+ * All operations will use the same general paramters, differing only in
+ * input and output. Each input/output set depends on the paramters:
+ *
+ * - Each input uri is individually encrypted/signed
+ * - If a byte array is supplied, it is treated as an input before uris are processed
+ * - The number of output uris must match the number of input uris, plus one more
+ *   if there is a byte array present.
+ * - Once the output uris are empty, there must be exactly one input (uri xor bytes)
+ *   left, which will be returned in a byte array as part of the result parcel.
+ *
+ */
+public class SignEncryptParcel extends PgpSignEncryptInput implements Parcelable {
+
+    public ArrayList<Uri> mInputUris = new ArrayList<>();
+    public ArrayList<Uri> mOutputUris = new ArrayList<>();
+    public byte[] mBytes;
+
+    public SignEncryptParcel() {
+        super();
+    }
+
+    public SignEncryptParcel(Parcel src) {
+
+        // we do all of those here, so the PgpSignEncryptInput class doesn't have to be parcelable
+        mVersionHeader = src.readString();
+        mEnableAsciiArmorOutput  = src.readInt() == 1;
+        mCompressionId = src.readInt();
+        mEncryptionMasterKeyIds = src.createLongArray();
+        mSymmetricPassphrase = src.readString();
+        mSymmetricEncryptionAlgorithm = src.readInt();
+        mSignatureMasterKeyId = src.readLong();
+        mSignatureSubKeyId = src.readInt() == 1 ? src.readLong() : null;
+        mSignatureHashAlgorithm = src.readInt();
+        mSignaturePassphrase = src.readString();
+        mAdditionalEncryptId = src.readLong();
+        mNfcSignedHash = src.createByteArray();
+        mNfcCreationTimestamp = src.readInt() == 1 ? new Date(src.readLong()) : null;
+        mFailOnMissingEncryptionKeyIds = src.readInt() == 1;
+        mCharset = src.readString();
+        mCleartextSignature = src.readInt() == 1;
+        mDetachedSignature = src.readInt() == 1;
+
+        mInputUris = src.createTypedArrayList(Uri.CREATOR);
+        mOutputUris = src.createTypedArrayList(Uri.CREATOR);
+        mBytes = src.createByteArray();
+
+    }
+
+    public byte[] getBytes() {
+        return mBytes;
+    }
+
+    public void setBytes(byte[] bytes) {
+        mBytes = bytes;
+    }
+
+    public List<Uri> getInputUris() {
+        return Collections.unmodifiableList(mInputUris);
+    }
+
+    public void addInputUris(Collection<Uri> inputUris) {
+        mInputUris.addAll(inputUris);
+    }
+
+    public List<Uri> getOutputUris() {
+        return Collections.unmodifiableList(mOutputUris);
+    }
+
+    public void addOutputUris(ArrayList<Uri> outputUris) {
+        mOutputUris.addAll(outputUris);
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(mVersionHeader);
+        dest.writeInt(mEnableAsciiArmorOutput ? 1 : 0);
+        dest.writeInt(mCompressionId);
+        dest.writeLongArray(mEncryptionMasterKeyIds);
+        dest.writeString(mSymmetricPassphrase);
+        dest.writeInt(mSymmetricEncryptionAlgorithm);
+        dest.writeLong(mSignatureMasterKeyId);
+        if (mSignatureSubKeyId != null) {
+            dest.writeInt(1);
+            dest.writeLong(mSignatureSubKeyId);
+        } else {
+            dest.writeInt(0);
+        }
+        dest.writeInt(mSignatureHashAlgorithm);
+        dest.writeString(mSignaturePassphrase);
+        dest.writeLong(mAdditionalEncryptId);
+        dest.writeByteArray(mNfcSignedHash);
+        if (mNfcCreationTimestamp != null) {
+            dest.writeInt(1);
+            dest.writeLong(mNfcCreationTimestamp.getTime());
+        } else {
+            dest.writeInt(0);
+        }
+        dest.writeInt(mFailOnMissingEncryptionKeyIds ? 1 : 0);
+        dest.writeString(mCharset);
+        dest.writeInt(mCleartextSignature ? 1 : 0);
+        dest.writeInt(mDetachedSignature ? 1 : 0);
+
+        dest.writeTypedList(mInputUris);
+        dest.writeTypedList(mOutputUris);
+        dest.writeByteArray(mBytes);
+    }
+
+    public static final Creator<SignEncryptParcel> CREATOR = new Creator<SignEncryptParcel>() {
+        public SignEncryptParcel createFromParcel(final Parcel source) {
+            return new SignEncryptParcel(source);
+        }
+
+        public SignEncryptParcel[] newArray(final int size) {
+            return new SignEncryptParcel[size];
+        }
+    };
+
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/UncachedKeyRing.java

@@ -35,9 +35,9 @@ import org.spongycastle.openpgp.PGPUserAttributeSubpacketVector;
 import org.spongycastle.openpgp.PGPUtil;
 import org.spongycastle.openpgp.operator.jcajce.JcaKeyFingerprintCalculator;
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.IterableIterator;
 import org.sufficientlysecure.keychain.util.Log;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/WrappedUserAttribute.java

@@ -32,7 +32,6 @@ import java.io.IOException;
 import java.io.ObjectStreamException;
 import java.io.Serializable;
 import java.util.ArrayList;
-import java.util.Arrays;
 
 public class WrappedUserAttribute implements Serializable {
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/KeychainDatabase.java

@@ -28,8 +28,8 @@ import android.provider.BaseColumns;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
-import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAppsAllowedKeysColumns;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAppsAccountsColumns;
+import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAppsAllowedKeysColumns;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAppsColumns;
 import org.sufficientlysecure.keychain.provider.KeychainContract.CertsColumns;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRingsColumns;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/KeychainProvider.java

@@ -31,8 +31,8 @@ import android.net.Uri;
 import android.text.TextUtils;
 
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAllowedKeys;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAccounts;
+import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAllowedKeys;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiApps;
 import org.sufficientlysecure.keychain.provider.KeychainContract.Certs;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRingData;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/provider/ProviderHelper.java

@@ -30,13 +30,13 @@ import android.support.v4.util.LongSparseArray;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
-import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
-import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
-import org.sufficientlysecure.keychain.util.ParcelableFileCache.IteratorWithSize;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
+import org.sufficientlysecure.keychain.operations.ImportExportOperation;
+import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
+import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
+import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKey;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey;
@@ -44,11 +44,11 @@ import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey.SecretKeyType;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKeyRing;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpHelper;
-import org.sufficientlysecure.keychain.operations.ImportExportOperation;
 import org.sufficientlysecure.keychain.pgp.Progressable;
 import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
 import org.sufficientlysecure.keychain.pgp.UncachedPublicKey;
 import org.sufficientlysecure.keychain.pgp.WrappedSignature;
+import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAllowedKeys;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiApps;
@@ -56,15 +56,15 @@ import org.sufficientlysecure.keychain.provider.KeychainContract.Certs;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRingData;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.KeychainContract.Keys;
+import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
 import org.sufficientlysecure.keychain.remote.AccountSettings;
 import org.sufficientlysecure.keychain.remote.AppSettings;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
-import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
-import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
-import org.sufficientlysecure.keychain.util.ParcelableFileCache;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.IterableIterator;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.ParcelableFileCache;
+import org.sufficientlysecure.keychain.util.ParcelableFileCache.IteratorWithSize;
+import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.ProgressFixedScaler;
 import org.sufficientlysecure.keychain.util.ProgressScaler;
 import org.sufficientlysecure.keychain.util.Utf8Util;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/OpenPgpService.java

@@ -26,30 +26,28 @@ import android.os.ParcelFileDescriptor;
 import android.text.TextUtils;
 
 import org.openintents.openpgp.IOpenPgpService;
-import org.openintents.openpgp.OpenPgpMetadata;
 import org.openintents.openpgp.OpenPgpError;
+import org.openintents.openpgp.OpenPgpMetadata;
 import org.openintents.openpgp.OpenPgpSignatureResult;
 import org.openintents.openpgp.util.OpenPgpApi;
 import org.spongycastle.util.encoders.Hex;
-import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
-import org.sufficientlysecure.keychain.ui.NfcActivity;
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.pgp.PgpDecryptVerify;
-import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing;
-import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
 import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult.LogEntryParcel;
+import org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult;
+import org.sufficientlysecure.keychain.pgp.PgpDecryptVerify;
 import org.sufficientlysecure.keychain.pgp.PgpHelper;
-import org.sufficientlysecure.keychain.pgp.PgpSignEncrypt;
+import org.sufficientlysecure.keychain.pgp.PgpSignEncryptInput;
+import org.sufficientlysecure.keychain.pgp.PgpSignEncryptOperation;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.ApiAccounts;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
+import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.remote.ui.RemoteServiceActivity;
-import org.sufficientlysecure.keychain.service.PassphraseCacheService;
-import org.sufficientlysecure.keychain.operations.results.OperationResult.LogEntryParcel;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
 import org.sufficientlysecure.keychain.ui.ImportKeysActivity;
+import org.sufficientlysecure.keychain.ui.NfcActivity;
 import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity;
 import org.sufficientlysecure.keychain.ui.ViewKeyActivity;
 import org.sufficientlysecure.keychain.util.InputData;
@@ -255,60 +253,26 @@ public class OpenPgpService extends RemoteService {
             long inputLength = is.available();
             InputData inputData = new InputData(is, inputLength);
 
-            // Find the appropriate subkey to sign with
-            long sigSubKeyId;
-            try {
-                CachedPublicKeyRing signingRing =
-                        new ProviderHelper(this).getCachedPublicKeyRing(accSettings.getKeyId());
-                sigSubKeyId = signingRing.getSecretSignId();
-            } catch (PgpKeyNotFoundException e) {
-                // secret key that is set for this account is deleted?
-                // show account config again!
-                return getCreateAccountIntent(data, getAccountName(data));
-            }
-
-            // get passphrase from cache, if key has "no" passphrase, this returns an empty String
-            String passphrase;
-            if (data.hasExtra(OpenPgpApi.EXTRA_PASSPHRASE)) {
-                passphrase = data.getStringExtra(OpenPgpApi.EXTRA_PASSPHRASE);
-            } else {
-                try {
-                    passphrase = PassphraseCacheService.getCachedPassphrase(getContext(),
-                            accSettings.getKeyId(), sigSubKeyId);
-                } catch (PassphraseCacheService.KeyNotFoundException e) {
-                    // should happen earlier, but return again here if it happens
-                    return getCreateAccountIntent(data, getAccountName(data));
-                }
-            }
-            if (passphrase == null) {
-                // get PendingIntent for passphrase input, add it to given params and return to client
-                return getPassphraseIntent(data, sigSubKeyId);
-            }
-
             // sign-only
-            PgpSignEncrypt.Builder builder = new PgpSignEncrypt.Builder(
-                    this, new ProviderHelper(getContext()), null,
-                    inputData, os
-            );
-            builder.setEnableAsciiArmorOutput(asciiArmor)
+            PgpSignEncryptInput pseInput = new PgpSignEncryptInput()
+                    .setEnableAsciiArmorOutput(asciiArmor)
                     .setCleartextSignature(cleartextSign)
                     .setDetachedSignature(!cleartextSign)
                     .setVersionHeader(PgpHelper.getVersionForHeader(this))
                     .setSignatureHashAlgorithm(accSettings.getHashAlgorithm())
                     .setSignatureMasterKeyId(accSettings.getKeyId())
-                    .setSignatureSubKeyId(sigSubKeyId)
-                    .setSignaturePassphrase(passphrase)
                     .setNfcState(nfcSignedHash, nfcCreationDate);
 
             // execute PGP operation!
-            SignEncryptResult pgpResult = builder.build().execute();
+            PgpSignEncryptOperation pse = new PgpSignEncryptOperation(this, new ProviderHelper(getContext()), null);
+            PgpSignEncryptResult pgpResult = pse.execute(pseInput, inputData, os);
 
             if (pgpResult.isPending()) {
-                if ((pgpResult.getResult() & SignEncryptResult.RESULT_PENDING_PASSPHRASE) ==
-                        SignEncryptResult.RESULT_PENDING_PASSPHRASE) {
+                if ((pgpResult.getResult() & PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE) ==
+                        PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE) {
                     return getPassphraseIntent(data, pgpResult.getKeyIdPassphraseNeeded());
-                } else if ((pgpResult.getResult() & SignEncryptResult.RESULT_PENDING_NFC) ==
-                        SignEncryptResult.RESULT_PENDING_NFC) {
+                } else if ((pgpResult.getResult() & PgpSignEncryptResult.RESULT_PENDING_NFC) ==
+                        PgpSignEncryptResult.RESULT_PENDING_NFC) {
                     // return PendingIntent to execute NFC activity
                     // pass through the signature creation timestamp to be used again on second execution
                     // of PgpSignEncrypt when we have the signed hash!
@@ -388,46 +352,19 @@ public class OpenPgpService extends RemoteService {
             os = new ParcelFileDescriptor.AutoCloseOutputStream(output);
 
             long inputLength = is.available();
-            InputData inputData = new InputData(is, inputLength);
+            InputData inputData = new InputData(is, inputLength, originalFilename);
 
-            PgpSignEncrypt.Builder builder = new PgpSignEncrypt.Builder(
-                    this, new ProviderHelper(getContext()), null, inputData, os
-            );
-            builder.setEnableAsciiArmorOutput(asciiArmor)
+            PgpSignEncryptInput pseInput = new PgpSignEncryptInput();
+            pseInput.setEnableAsciiArmorOutput(asciiArmor)
                     .setVersionHeader(PgpHelper.getVersionForHeader(this))
                     .setCompressionId(accSettings.getCompression())
                     .setSymmetricEncryptionAlgorithm(accSettings.getEncryptionAlgorithm())
                     .setEncryptionMasterKeyIds(keyIds)
                     .setFailOnMissingEncryptionKeyIds(true)
-                    .setOriginalFilename(originalFilename)
                     .setAdditionalEncryptId(accSettings.getKeyId()); // add acc key for encryption
 
             if (sign) {
 
-                // Find the appropriate subkey to sign with
-                long sigSubKeyId;
-                try {
-                    CachedPublicKeyRing signingRing =
-                            new ProviderHelper(this).getCachedPublicKeyRing(accSettings.getKeyId());
-                    sigSubKeyId = signingRing.getSecretSignId();
-                } catch (PgpKeyNotFoundException e) {
-                    // secret key that is set for this account is deleted?
-                    // show account config again!
-                    return getCreateAccountIntent(data, getAccountName(data));
-                }
-
-                String passphrase;
-                if (data.hasExtra(OpenPgpApi.EXTRA_PASSPHRASE)) {
-                    passphrase = data.getStringExtra(OpenPgpApi.EXTRA_PASSPHRASE);
-                } else {
-                    passphrase = PassphraseCacheService.getCachedPassphrase(getContext(),
-                            accSettings.getKeyId(), sigSubKeyId);
-                }
-                if (passphrase == null) {
-                    // get PendingIntent for passphrase input, add it to given params and return to client
-                    return getPassphraseIntent(data, sigSubKeyId);
-                }
-
                 byte[] nfcSignedHash = data.getByteArrayExtra(OpenPgpApi.EXTRA_NFC_SIGNED_HASH);
                 // carefully: only set if timestamp exists
                 Date nfcCreationDate = null;
@@ -437,22 +374,22 @@ public class OpenPgpService extends RemoteService {
                 }
 
                 // sign and encrypt
-                builder.setSignatureHashAlgorithm(accSettings.getHashAlgorithm())
+                pseInput.setSignatureHashAlgorithm(accSettings.getHashAlgorithm())
                         .setSignatureMasterKeyId(accSettings.getKeyId())
-                        .setSignatureSubKeyId(sigSubKeyId)
-                        .setSignaturePassphrase(passphrase)
                         .setNfcState(nfcSignedHash, nfcCreationDate);
             }
 
+            PgpSignEncryptOperation op = new PgpSignEncryptOperation(this, new ProviderHelper(getContext()), null);
+
             // execute PGP operation!
-            SignEncryptResult pgpResult = builder.build().execute();
+            PgpSignEncryptResult pgpResult = op.execute(pseInput, inputData, os);
 
             if (pgpResult.isPending()) {
-                if ((pgpResult.getResult() & SignEncryptResult.RESULT_PENDING_PASSPHRASE) ==
-                        SignEncryptResult.RESULT_PENDING_PASSPHRASE) {
+                if ((pgpResult.getResult() & PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE) ==
+                        PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE) {
                     return getPassphraseIntent(data, pgpResult.getKeyIdPassphraseNeeded());
-                } else if ((pgpResult.getResult() & SignEncryptResult.RESULT_PENDING_NFC) ==
-                        SignEncryptResult.RESULT_PENDING_NFC) {
+                } else if ((pgpResult.getResult() & PgpSignEncryptResult.RESULT_PENDING_NFC) ==
+                        PgpSignEncryptResult.RESULT_PENDING_NFC) {
                     // return PendingIntent to execute NFC activity
                     // pass through the signature creation timestamp to be used again on second execution
                     // of PgpSignEncrypt when we have the signed hash!

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/AccountSettingsActivity.java

@@ -26,12 +26,12 @@ import android.view.View;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.ui.BaseActivity;
-import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.remote.AccountSettings;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
 import org.sufficientlysecure.keychain.operations.results.SingletonResult;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.remote.AccountSettings;
+import org.sufficientlysecure.keychain.ui.BaseActivity;
 import org.sufficientlysecure.keychain.util.Log;
 
 public class AccountSettingsActivity extends BaseActivity {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/AccountSettingsFragment.java

@@ -31,10 +31,10 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.remote.AccountSettings;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.remote.AccountSettings;
 import org.sufficientlysecure.keychain.ui.CreateKeyActivity;
 import org.sufficientlysecure.keychain.ui.adapter.KeyValueSpinnerAdapter;
 import org.sufficientlysecure.keychain.ui.widget.KeySpinner;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/AppSettingsActivity.java

@@ -28,10 +28,10 @@ import android.view.View;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.remote.AppSettings;
-import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.ui.BaseActivity;
 import org.sufficientlysecure.keychain.util.Log;
 

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

@@ -53,7 +53,7 @@ public class ContactSyncAdapterService extends Service {
 //                    new Handler.Callback() {
 //                        @Override
 //                        public boolean handleMessage(Message msg) {
-//                            Bundle data = msg.getData();
+//                            Bundle data = msg.getInputData();
 //                            switch (msg.arg1) {
 //                                case KeychainIntentServiceHandler.MESSAGE_OKAY:
 //                                    Log.d(Constants.TAG, "Syncing... Done.");

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

@@ -27,40 +27,36 @@ import android.os.Messenger;
 import android.os.RemoteException;
 
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.operations.CertifyOperation;
-import org.sufficientlysecure.keychain.operations.DeleteOperation;
-import org.sufficientlysecure.keychain.operations.EditKeyOperation;
-import org.sufficientlysecure.keychain.operations.PromoteKeyOperation;
-import org.sufficientlysecure.keychain.operations.results.DeleteResult;
-import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
-import org.sufficientlysecure.keychain.operations.results.ExportResult;
-import org.sufficientlysecure.keychain.operations.results.PromoteKeyResult;
-import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
-import org.sufficientlysecure.keychain.operations.results.CertifyResult;
-import org.sufficientlysecure.keychain.util.FileHelper;
-import org.sufficientlysecure.keychain.util.ParcelableFileCache.IteratorWithSize;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.keyimport.HkpKeyserver;
 import org.sufficientlysecure.keychain.keyimport.Keyserver;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
+import org.sufficientlysecure.keychain.operations.CertifyOperation;
+import org.sufficientlysecure.keychain.operations.DeleteOperation;
+import org.sufficientlysecure.keychain.operations.EditKeyOperation;
+import org.sufficientlysecure.keychain.operations.ImportExportOperation;
+import org.sufficientlysecure.keychain.operations.PromoteKeyOperation;
+import org.sufficientlysecure.keychain.operations.SignEncryptOperation;
+import org.sufficientlysecure.keychain.operations.results.CertifyResult;
+import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
+import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
+import org.sufficientlysecure.keychain.operations.results.DeleteResult;
+import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
+import org.sufficientlysecure.keychain.operations.results.ExportResult;
+import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult;
+import org.sufficientlysecure.keychain.operations.results.PromoteKeyResult;
+import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpDecryptVerify;
-import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
-import org.sufficientlysecure.keychain.pgp.PgpHelper;
-import org.sufficientlysecure.keychain.operations.ImportExportOperation;
-import org.sufficientlysecure.keychain.pgp.PgpSignEncrypt;
 import org.sufficientlysecure.keychain.pgp.Progressable;
+import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralMsgIdException;
-import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.operations.results.OperationResult;
-import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
-import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
-import org.sufficientlysecure.keychain.util.ParcelableFileCache;
+import org.sufficientlysecure.keychain.util.FileHelper;
 import org.sufficientlysecure.keychain.util.InputData;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.ParcelableFileCache;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
@@ -68,8 +64,6 @@ import java.io.FileNotFoundException;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.util.ArrayList;
-import java.util.Date;
-import java.util.Iterator;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 /**
@@ -115,24 +109,11 @@ public class KeychainIntentService extends IntentService implements Progressable
     // possible targets:
     public static final int IO_BYTES = 1;
     public static final int IO_URI = 2;
-    public static final int IO_URIS = 3;
-
-    public static final String SELECTED_URI = "selected_uri";
 
     // encrypt
-    public static final String ENCRYPT_SIGNATURE_MASTER_ID = "secret_key_id";
-    public static final String ENCRYPT_SIGNATURE_KEY_PASSPHRASE = "secret_key_passphrase";
-    public static final String ENCRYPT_SIGNATURE_NFC_TIMESTAMP = "signature_nfc_timestamp";
-    public static final String ENCRYPT_SIGNATURE_NFC_HASH = "signature_nfc_hash";
-    public static final String ENCRYPT_USE_ASCII_ARMOR = "use_ascii_armor";
-    public static final String ENCRYPT_ENCRYPTION_KEYS_IDS = "encryption_keys_ids";
-    public static final String ENCRYPT_COMPRESSION_ID = "compression_id";
-    public static final String ENCRYPT_MESSAGE_BYTES = "message_bytes";
     public static final String ENCRYPT_DECRYPT_INPUT_URI = "input_uri";
-    public static final String ENCRYPT_INPUT_URIS = "input_uris";
     public static final String ENCRYPT_DECRYPT_OUTPUT_URI = "output_uri";
-    public static final String ENCRYPT_OUTPUT_URIS = "output_uris";
-    public static final String ENCRYPT_SYMMETRIC_PASSPHRASE = "passphrase";
+    public static final String SIGN_ENCRYPT_PARCEL = "sign_encrypt_parcel";
 
     // decrypt/verify
     public static final String DECRYPT_CIPHERTEXT_BYTES = "ciphertext_bytes";
@@ -176,9 +157,6 @@ public class KeychainIntentService extends IntentService implements Progressable
      * possible data keys as result send over messenger
      */
 
-    // encrypt
-    public static final String RESULT_BYTES = "encrypted_data";
-
     // decrypt/verify
     public static final String RESULT_DECRYPTED_BYTES = "decrypted_data";
 
@@ -427,83 +405,19 @@ public class KeychainIntentService extends IntentService implements Progressable
             }
             case ACTION_SIGN_ENCRYPT:
 
-                try {
-                    /* Input */
-                    int source = data.get(SOURCE) != null ? data.getInt(SOURCE) : data.getInt(TARGET);
-                    Bundle resultData = new Bundle();
+                // Input
+                SignEncryptParcel inputParcel = data.getParcelable(SIGN_ENCRYPT_PARCEL);
 
-                    long sigMasterKeyId = data.getLong(ENCRYPT_SIGNATURE_MASTER_ID);
-                    String sigKeyPassphrase = data.getString(ENCRYPT_SIGNATURE_KEY_PASSPHRASE);
+                // Operation
+                SignEncryptOperation op = new SignEncryptOperation(
+                        this, new ProviderHelper(this), this, mActionCanceled);
+                SignEncryptResult result = op.execute(inputParcel);
 
-                    byte[] nfcHash = data.getByteArray(ENCRYPT_SIGNATURE_NFC_HASH);
-                    Date nfcTimestamp = (Date) data.getSerializable(ENCRYPT_SIGNATURE_NFC_TIMESTAMP);
-
-                    String symmetricPassphrase = data.getString(ENCRYPT_SYMMETRIC_PASSPHRASE);
-
-                    boolean useAsciiArmor = data.getBoolean(ENCRYPT_USE_ASCII_ARMOR);
-                    long encryptionKeyIds[] = data.getLongArray(ENCRYPT_ENCRYPTION_KEYS_IDS);
-                    int compressionId = data.getInt(ENCRYPT_COMPRESSION_ID);
-                    int urisCount = data.containsKey(ENCRYPT_INPUT_URIS) ? data.getParcelableArrayList(ENCRYPT_INPUT_URIS).size() : 1;
-                    for (int i = 0; i < urisCount; i++) {
-                        data.putInt(SELECTED_URI, i);
-                        InputData inputData = createEncryptInputData(data);
-                        OutputStream outStream = createCryptOutputStream(data);
-                        String originalFilename = getOriginalFilename(data);
-
-                        /* Operation */
-                        PgpSignEncrypt.Builder builder = new PgpSignEncrypt.Builder(
-                                this, new ProviderHelper(this), this, inputData, outStream
-                        );
-                        builder.setEnableAsciiArmorOutput(useAsciiArmor)
-                                .setCleartextSignature(true)
-                                .setVersionHeader(PgpHelper.getVersionForHeader(this))
-                                .setCompressionId(compressionId)
-                                .setSymmetricEncryptionAlgorithm(
-                                        Preferences.getPreferences(this).getDefaultEncryptionAlgorithm())
-                                .setEncryptionMasterKeyIds(encryptionKeyIds)
-                                .setSymmetricPassphrase(symmetricPassphrase)
-                                .setOriginalFilename(originalFilename);
-
-                        try {
-
-                            // Find the appropriate subkey to sign with
-                            CachedPublicKeyRing signingRing =
-                                    new ProviderHelper(this).getCachedPublicKeyRing(sigMasterKeyId);
-                            long sigSubKeyId = signingRing.getSecretSignId();
-
-                            // Set signature settings
-                            builder.setSignatureMasterKeyId(sigMasterKeyId)
-                                    .setSignatureSubKeyId(sigSubKeyId)
-                                    .setSignaturePassphrase(sigKeyPassphrase)
-                                    .setSignatureHashAlgorithm(
-                                            Preferences.getPreferences(this).getDefaultHashAlgorithm())
-                                    .setAdditionalEncryptId(sigMasterKeyId);
-                            if (nfcHash != null && nfcTimestamp != null) {
-                                builder.setNfcState(nfcHash, nfcTimestamp);
-                            }
-
-                        } catch (PgpKeyNotFoundException e) {
-                            // encrypt-only
-                            // TODO Just silently drop the requested signature? Shouldn't we throw here?
-                        }
-
-                        SignEncryptResult result = builder.build().execute();
-                        resultData.putParcelable(SignEncryptResult.EXTRA_RESULT, result);
-
-                        outStream.close();
-
-                        /* Output */
-                        finalizeEncryptOutputStream(data, resultData, outStream);
-                    }
-
-                    Log.logDebugBundle(resultData, "resultData");
-
-                    sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, resultData);
-                } catch (Exception e) {
-                    sendErrorToHandler(e);
-                }
+                // Result
+                sendMessageToHandler(KeychainIntentServiceHandler.MESSAGE_OKAY, result);
 
                 break;
+
             case ACTION_UPLOAD_KEYRING:
 
                 try {
@@ -620,10 +534,6 @@ public class KeychainIntentService extends IntentService implements Progressable
         return createCryptInputData(data, DECRYPT_CIPHERTEXT_BYTES);
     }
 
-    private InputData createEncryptInputData(Bundle data) throws IOException, PgpGeneralException {
-        return createCryptInputData(data, ENCRYPT_MESSAGE_BYTES);
-    }
-
     private InputData createCryptInputData(Bundle data, String bytesName) throws PgpGeneralException, IOException {
         int source = data.get(SOURCE) != null ? data.getInt(SOURCE) : data.getInt(TARGET);
         switch (source) {
@@ -637,33 +547,6 @@ public class KeychainIntentService extends IntentService implements Progressable
                 // InputStream
                 return new InputData(getContentResolver().openInputStream(providerUri), FileHelper.getFileSize(this, providerUri, 0));
 
-            case IO_URIS:
-                providerUri = data.<Uri>getParcelableArrayList(ENCRYPT_INPUT_URIS).get(data.getInt(SELECTED_URI));
-
-                // InputStream
-                return new InputData(getContentResolver().openInputStream(providerUri), FileHelper.getFileSize(this, providerUri, 0));
-
-            default:
-                throw new PgpGeneralException("No target choosen!");
-        }
-    }
-
-    private String getOriginalFilename(Bundle data) throws PgpGeneralException, FileNotFoundException {
-        int target = data.getInt(TARGET);
-        switch (target) {
-            case IO_BYTES:
-                return "";
-
-            case IO_URI:
-                Uri providerUri = data.getParcelable(ENCRYPT_DECRYPT_INPUT_URI);
-
-                return FileHelper.getFilename(this, providerUri);
-
-            case IO_URIS:
-                providerUri = data.<Uri>getParcelableArrayList(ENCRYPT_INPUT_URIS).get(data.getInt(SELECTED_URI));
-
-                return FileHelper.getFilename(this, providerUri);
-
             default:
                 throw new PgpGeneralException("No target choosen!");
         }
@@ -680,20 +563,11 @@ public class KeychainIntentService extends IntentService implements Progressable
 
                 return getContentResolver().openOutputStream(providerUri);
 
-            case IO_URIS:
-                providerUri = data.<Uri>getParcelableArrayList(ENCRYPT_OUTPUT_URIS).get(data.getInt(SELECTED_URI));
-
-                return getContentResolver().openOutputStream(providerUri);
-
             default:
                 throw new PgpGeneralException("No target choosen!");
         }
     }
 
-    private void finalizeEncryptOutputStream(Bundle data, Bundle resultData, OutputStream outStream) {
-        finalizeCryptOutputStream(data, resultData, outStream, RESULT_BYTES);
-    }
-
     private void finalizeDecryptOutputStream(Bundle data, Bundle resultData, OutputStream outStream) {
         finalizeCryptOutputStream(data, resultData, outStream, RESULT_DECRYPTED_BYTES);
     }
@@ -706,7 +580,6 @@ public class KeychainIntentService extends IntentService implements Progressable
                 resultData.putByteArray(bytesName, output);
                 break;
             case IO_URI:
-            case IO_URIS:
                 // nothing, output was written, just send okay and verification bundle
 
                 break;

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

@@ -27,8 +27,8 @@ import android.support.v4.app.FragmentManager;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment;
-import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.Log;
 
 public class KeychainIntentServiceHandler extends Handler {
 

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

@@ -39,11 +39,11 @@ import android.support.v4.util.LongSparseArray;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey.SecretKeyType;
 import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.util.Date;
 

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

@@ -22,6 +22,7 @@ import android.os.Parcel;
 import android.os.Parcelable;
 
 import org.sufficientlysecure.keychain.pgp.WrappedUserAttribute;
+
 import java.io.Serializable;
 import java.util.ArrayList;
 

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

@@ -61,7 +61,7 @@ public class ConsolidateDialogActivity extends FragmentActivity {
                     /* don't care about the results (for now?)
 
                     // get returned data bundle
-                    Bundle returnData = message.getData();
+                    Bundle returnData = message.getInputData();
                     if (returnData == null) {
                         return;
                     }

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

@@ -35,16 +35,16 @@ import org.spongycastle.bcpg.sig.KeyFlags;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.operations.results.EditKeyResult;
-import org.sufficientlysecure.keychain.service.SaveKeyringParcel.ChangeUnlockParcel;
-import org.sufficientlysecure.keychain.util.Preferences;
+import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
-import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel.Algorithm;
+import org.sufficientlysecure.keychain.service.SaveKeyringParcel.ChangeUnlockParcel;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 public class CreateKeyFinalFragment extends Fragment {
 

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

@@ -88,7 +88,7 @@ public class DecryptFilesActivity extends BaseActivity {
             loadFragment(savedInstanceState, null, true);
         } else if (ACTION_DECRYPT_DATA.equals(action)) {
             Log.e(Constants.TAG,
-                    "Include an Uri with setData() in your Intent!");
+                    "Include an Uri with setInputData() in your Intent!");
         }
     }
 

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

@@ -35,13 +35,13 @@ import android.widget.TextView;
 import org.openintents.openpgp.util.OpenPgpApi;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.FileHelper;
 import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
 import org.sufficientlysecure.keychain.ui.dialog.DeleteFileDialogFragment;
-import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.FileHelper;
+import org.sufficientlysecure.keychain.util.Log;
 
 import java.io.File;
 
@@ -310,7 +310,7 @@ public class DecryptFilesFragment extends DecryptFragment {
                         // A future open after decryption feature
                         if () {
                             Intent viewFile = new Intent(Intent.ACTION_VIEW);
-                            viewFile.setData(mOutputUri);
+                            viewFile.setInputData(mOutputUri);
                             startActivity(viewFile);
                         }
                         */

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

@@ -27,9 +27,9 @@ import android.widget.TextView;
 
 import org.openintents.openpgp.OpenPgpSignatureResult;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
-import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 
 public abstract class DecryptFragment extends Fragment {

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

@@ -26,11 +26,11 @@ import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.api.OpenKeychainIntents;
 import org.sufficientlysecure.keychain.compatibility.ClipboardReflection;
-import org.sufficientlysecure.keychain.pgp.PgpHelper;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.operations.results.SingletonResult;
-import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.pgp.PgpHelper;
 import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.Log;
 
 import java.util.regex.Matcher;
 

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

@@ -34,9 +34,9 @@ import org.openintents.openpgp.util.OpenPgpApi;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.compatibility.ClipboardReflection;
+import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
-import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ShareHelper;

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

@@ -8,9 +8,11 @@ import android.os.Messenger;
 
 import org.openintents.openpgp.util.OpenPgpApi;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult;
+import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
+import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
 
 import java.util.Date;
 
@@ -82,7 +84,10 @@ public abstract class EncryptActivity extends BaseActivity {
         // Send all information needed to service to edit key in other thread
         Intent intent = new Intent(this, KeychainIntentService.class);
         intent.setAction(KeychainIntentService.ACTION_SIGN_ENCRYPT);
-        intent.putExtra(KeychainIntentService.EXTRA_DATA, createEncryptBundle());
+
+        Bundle data = new Bundle();
+        data.putParcelable(KeychainIntentService.SIGN_ENCRYPT_PARCEL, createEncryptBundle());
+        intent.putExtra(KeychainIntentService.EXTRA_DATA, data);
 
         // Message is received after encrypting is done in KeychainIntentService
         KeychainIntentServiceHandler serviceHandler = new KeychainIntentServiceHandler(this,
@@ -92,28 +97,31 @@ public abstract class EncryptActivity extends BaseActivity {
                 super.handleMessage(message);
 
                 if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) {
-                    SignEncryptResult pgpResult =
+                    SignEncryptResult result =
                             message.getData().getParcelable(SignEncryptResult.EXTRA_RESULT);
 
-                    if (pgpResult.isPending()) {
-                        if ((pgpResult.getResult() & SignEncryptResult.RESULT_PENDING_PASSPHRASE) ==
-                                SignEncryptResult.RESULT_PENDING_PASSPHRASE) {
+                    PgpSignEncryptResult pgpResult = result.getPending();
+
+                    if (pgpResult != null && pgpResult.isPending()) {
+                        if ((pgpResult.getResult() & PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE) ==
+                                PgpSignEncryptResult.RESULT_PENDING_PASSPHRASE) {
                             startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
-                        } else if ((pgpResult.getResult() & SignEncryptResult.RESULT_PENDING_NFC) ==
-                                SignEncryptResult.RESULT_PENDING_NFC) {
+                        } else if ((pgpResult.getResult() & PgpSignEncryptResult.RESULT_PENDING_NFC) ==
+                                PgpSignEncryptResult.RESULT_PENDING_NFC) {
 
                             mNfcTimestamp = pgpResult.getNfcTimestamp();
-                            startNfcSign(pgpResult.getNfcKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcHash(), pgpResult.getNfcAlgo());
+                            startNfcSign(pgpResult.getNfcKeyId(), pgpResult.getNfcPassphrase(),
+                                    pgpResult.getNfcHash(), pgpResult.getNfcAlgo());
                         } else {
                             throw new RuntimeException("Unhandled pending result!");
                         }
                         return;
                     }
 
-                    if (pgpResult.success()) {
-                        onEncryptSuccess(message, pgpResult);
+                    if (result.success()) {
+                        onEncryptSuccess(result);
                     } else {
-                        pgpResult.createNotify(EncryptActivity.this).show();
+                        result.createNotify(EncryptActivity.this).show();
                     }
 
                     // no matter the result, reset parameters
@@ -136,8 +144,8 @@ public abstract class EncryptActivity extends BaseActivity {
 
     protected abstract boolean inputIsValid();
 
-    protected abstract void onEncryptSuccess(Message message, SignEncryptResult result);
+    protected abstract void onEncryptSuccess(SignEncryptResult result);
 
-    protected abstract Bundle createEncryptBundle();
+    protected abstract SignEncryptParcel createEncryptBundle();
 
 }

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

@@ -21,7 +21,6 @@ package org.sufficientlysecure.keychain.ui;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
-import android.os.Message;
 import android.support.v4.app.Fragment;
 import android.view.Menu;
 import android.view.MenuItem;
@@ -29,14 +28,14 @@ import android.view.MenuItem;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.api.OpenKeychainIntents;
+import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
+import org.sufficientlysecure.keychain.ui.dialog.DeleteFileDialogFragment;
+import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.ShareHelper;
-import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.service.KeychainIntentService;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
-import org.sufficientlysecure.keychain.ui.dialog.DeleteFileDialogFragment;
-import org.sufficientlysecure.keychain.util.Log;
-import org.sufficientlysecure.keychain.ui.util.Notify;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -170,7 +169,7 @@ public class EncryptFilesActivity extends EncryptActivity implements EncryptActi
     }
 
     @Override
-    public void onEncryptSuccess(Message message, SignEncryptResult pgpResult) {
+    public void onEncryptSuccess(SignEncryptResult result) {
         if (mDeleteAfterEncrypt) {
             for (Uri inputUri : mInputUris) {
                 DeleteFileDialogFragment deleteFileDialog = DeleteFileDialogFragment.newInstance(inputUri);
@@ -182,29 +181,25 @@ public class EncryptFilesActivity extends EncryptActivity implements EncryptActi
 
         if (mShareAfterEncrypt) {
             // Share encrypted message/file
-            startActivity(sendWithChooserExcludingEncrypt(message));
+            startActivity(sendWithChooserExcludingEncrypt());
         } else {
             // Save encrypted file
-            pgpResult.createNotify(EncryptFilesActivity.this).show();
+            result.createNotify(EncryptFilesActivity.this).show();
         }
     }
 
     @Override
-    protected Bundle createEncryptBundle() {
+    protected SignEncryptParcel createEncryptBundle() {
         // fill values for this action
-        Bundle data = new Bundle();
+        SignEncryptParcel data = new SignEncryptParcel();
 
-        data.putInt(KeychainIntentService.SOURCE, KeychainIntentService.IO_URIS);
-        data.putParcelableArrayList(KeychainIntentService.ENCRYPT_INPUT_URIS, mInputUris);
+        data.addInputUris(mInputUris);
+        data.addOutputUris(mOutputUris);
 
-        data.putInt(KeychainIntentService.TARGET, KeychainIntentService.IO_URIS);
-        data.putParcelableArrayList(KeychainIntentService.ENCRYPT_OUTPUT_URIS, mOutputUris);
-
-        data.putInt(KeychainIntentService.ENCRYPT_COMPRESSION_ID,
-                Preferences.getPreferences(this).getDefaultFileCompression());
+        data.setCompressionId(Preferences.getPreferences(this).getDefaultMessageCompression());
 
         // Always use armor for messages
-        data.putBoolean(KeychainIntentService.ENCRYPT_USE_ASCII_ARMOR, mUseArmor);
+        data.setEnableAsciiArmorOutput(mUseArmor);
 
         if (isModeSymmetric()) {
             Log.d(Constants.TAG, "Symmetric encryption enabled!");
@@ -212,13 +207,12 @@ public class EncryptFilesActivity extends EncryptActivity implements EncryptActi
             if (passphrase.length() == 0) {
                 passphrase = null;
             }
-            data.putString(KeychainIntentService.ENCRYPT_SYMMETRIC_PASSPHRASE, passphrase);
+            data.setSymmetricPassphrase(passphrase);
         } else {
-            data.putLong(KeychainIntentService.ENCRYPT_SIGNATURE_MASTER_ID, mSigningKeyId);
-            data.putLongArray(KeychainIntentService.ENCRYPT_ENCRYPTION_KEYS_IDS, mEncryptionKeyIds);
-            data.putString(KeychainIntentService.ENCRYPT_SIGNATURE_KEY_PASSPHRASE, mSigningKeyPassphrase);
-            data.putSerializable(KeychainIntentService.ENCRYPT_SIGNATURE_NFC_TIMESTAMP, mNfcTimestamp);
-            data.putByteArray(KeychainIntentService.ENCRYPT_SIGNATURE_NFC_HASH, mNfcHash);
+            data.setEncryptionMasterKeyIds(mEncryptionKeyIds);
+            data.setSignatureMasterKeyId(mSigningKeyId);
+            data.setSignaturePassphrase(mSigningKeyPassphrase);
+            data.setNfcState(mNfcHash, mNfcTimestamp);
         }
         return data;
     }
@@ -226,8 +220,8 @@ public class EncryptFilesActivity extends EncryptActivity implements EncryptActi
     /**
      * Create Intent Chooser but exclude OK's EncryptActivity.
      */
-    private Intent sendWithChooserExcludingEncrypt(Message message) {
-        Intent prototype = createSendIntent(message);
+    private Intent sendWithChooserExcludingEncrypt() {
+        Intent prototype = createSendIntent();
         String title = getString(R.string.title_share_file);
 
         // we don't want to encrypt the encrypted, no inception ;)
@@ -239,7 +233,7 @@ public class EncryptFilesActivity extends EncryptActivity implements EncryptActi
         return new ShareHelper(this).createChooserExcluding(prototype, title, blacklist);
     }
 
-    private Intent createSendIntent(Message message) {
+    private Intent createSendIntent() {
         Intent sendIntent;
         // file
         if (mOutputUris.size() == 1) {

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

@@ -36,10 +36,10 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.provider.TemporaryStorageProvider;
 import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.util.FileHelper;
-import org.sufficientlysecure.keychain.provider.TemporaryStorageProvider;
 
 import java.io.File;
 import java.util.HashMap;

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

@@ -21,7 +21,6 @@ package org.sufficientlysecure.keychain.ui;
 import android.content.Intent;
 import android.net.Uri;
 import android.os.Bundle;
-import android.os.Message;
 import android.support.v4.app.Fragment;
 import android.view.Menu;
 import android.view.MenuItem;
@@ -30,13 +29,13 @@ import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.api.OpenKeychainIntents;
 import org.sufficientlysecure.keychain.compatibility.ClipboardReflection;
+import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
+import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.ShareHelper;
-import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.service.KeychainIntentService;
-import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
-import org.sufficientlysecure.keychain.util.Log;
-import org.sufficientlysecure.keychain.ui.util.Notify;
 
 import java.util.ArrayList;
 import java.util.HashSet;
@@ -169,32 +168,31 @@ public class EncryptTextActivity extends EncryptActivity implements EncryptActiv
     }
 
     @Override
-    protected void onEncryptSuccess(Message message, SignEncryptResult pgpResult) {
+    protected void onEncryptSuccess(SignEncryptResult result) {
         if (mShareAfterEncrypt) {
             // Share encrypted message/file
-            startActivity(sendWithChooserExcludingEncrypt(message));
+            startActivity(sendWithChooserExcludingEncrypt(result.getResultBytes()));
         } else {
             // Copy to clipboard
-            copyToClipboard(message);
-            pgpResult.createNotify(EncryptTextActivity.this).show();
+            copyToClipboard(result.getResultBytes());
+            result.createNotify(EncryptTextActivity.this).show();
             // Notify.showNotify(EncryptTextActivity.this,
             // R.string.encrypt_sign_clipboard_successful, Notify.Style.INFO);
         }
     }
 
     @Override
-    protected Bundle createEncryptBundle() {
+    protected SignEncryptParcel createEncryptBundle() {
         // fill values for this action
-        Bundle data = new Bundle();
+        SignEncryptParcel data = new SignEncryptParcel();
 
-        data.putInt(KeychainIntentService.TARGET, KeychainIntentService.IO_BYTES);
-        data.putByteArray(KeychainIntentService.ENCRYPT_MESSAGE_BYTES, mMessage.getBytes());
+        data.setBytes(mMessage.getBytes());
+        data.setCleartextSignature(true);
 
-        data.putInt(KeychainIntentService.ENCRYPT_COMPRESSION_ID,
-                Preferences.getPreferences(this).getDefaultMessageCompression());
+        data.setCompressionId(Preferences.getPreferences(this).getDefaultMessageCompression());
 
         // Always use armor for messages
-        data.putBoolean(KeychainIntentService.ENCRYPT_USE_ASCII_ARMOR, true);
+        data.setEnableAsciiArmorOutput(true);
 
         if (isModeSymmetric()) {
             Log.d(Constants.TAG, "Symmetric encryption enabled!");
@@ -202,26 +200,25 @@ public class EncryptTextActivity extends EncryptActivity implements EncryptActiv
             if (passphrase.length() == 0) {
                 passphrase = null;
             }
-            data.putString(KeychainIntentService.ENCRYPT_SYMMETRIC_PASSPHRASE, passphrase);
+            data.setSymmetricPassphrase(passphrase);
         } else {
-            data.putLong(KeychainIntentService.ENCRYPT_SIGNATURE_MASTER_ID, mSigningKeyId);
-            data.putLongArray(KeychainIntentService.ENCRYPT_ENCRYPTION_KEYS_IDS, mEncryptionKeyIds);
-            data.putString(KeychainIntentService.ENCRYPT_SIGNATURE_KEY_PASSPHRASE, mSigningKeyPassphrase);
-            data.putSerializable(KeychainIntentService.ENCRYPT_SIGNATURE_NFC_TIMESTAMP, mNfcTimestamp);
-            data.putByteArray(KeychainIntentService.ENCRYPT_SIGNATURE_NFC_HASH, mNfcHash);
+            data.setEncryptionMasterKeyIds(mEncryptionKeyIds);
+            data.setSignatureMasterKeyId(mSigningKeyId);
+            data.setSignaturePassphrase(mSigningKeyPassphrase);
+            data.setNfcState(mNfcHash, mNfcTimestamp);
         }
         return data;
     }
 
-    private void copyToClipboard(Message message) {
-        ClipboardReflection.copyToClipboard(this, new String(message.getData().getByteArray(KeychainIntentService.RESULT_BYTES)));
+    private void copyToClipboard(byte[] resultBytes) {
+        ClipboardReflection.copyToClipboard(this, new String(resultBytes));
     }
 
     /**
      * Create Intent Chooser but exclude OK's EncryptActivity.
      */
-    private Intent sendWithChooserExcludingEncrypt(Message message) {
-        Intent prototype = createSendIntent(message);
+    private Intent sendWithChooserExcludingEncrypt(byte[] resultBytes) {
+        Intent prototype = createSendIntent(resultBytes);
         String title = getString(R.string.title_share_message);
 
         // we don't want to encrypt the encrypted, no inception ;)
@@ -233,11 +230,11 @@ public class EncryptTextActivity extends EncryptActivity implements EncryptActiv
         return new ShareHelper(this).createChooserExcluding(prototype, title, blacklist);
     }
 
-    private Intent createSendIntent(Message message) {
+    private Intent createSendIntent(byte[] resultBytes) {
         Intent sendIntent;
         sendIntent = new Intent(Intent.ACTION_SEND);
         sendIntent.setType("text/plain");
-        sendIntent.putExtra(Intent.EXTRA_TEXT, new String(message.getData().getByteArray(KeychainIntentService.RESULT_BYTES)));
+        sendIntent.putExtra(Intent.EXTRA_TEXT, new String(resultBytes));
 
         if (!isModeSymmetric() && mEncryptionUserIds != null) {
             Set<String> users = new HashSet<>();

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

@@ -25,8 +25,8 @@ import android.view.Window;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 public class FirstTimeActivity extends BaseActivity {
 

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

@@ -36,8 +36,8 @@ import android.widget.TextView;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.util.ContactHelper;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.util.List;
 

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

@@ -61,19 +61,19 @@ import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
 import org.sufficientlysecure.keychain.operations.results.DeleteResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
+import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.KeychainDatabase;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
-import org.sufficientlysecure.keychain.util.ExportHelper;
-import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
 import org.sufficientlysecure.keychain.ui.dialog.DeleteKeyDialogFragment;
-import org.sufficientlysecure.keychain.ui.widget.ListAwareSwipeRefreshLayout;
 import org.sufficientlysecure.keychain.ui.util.Highlighter;
-import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.ui.widget.ListAwareSwipeRefreshLayout;
+import org.sufficientlysecure.keychain.util.ExportHelper;
+import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.io.IOException;

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

@@ -19,8 +19,6 @@ package org.sufficientlysecure.keychain.ui;
 
 import android.content.Intent;
 import android.os.Bundle;
-import android.view.LayoutInflater;
-import android.view.View;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.remote.ui.AppsListFragment;

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

@@ -21,8 +21,8 @@ import android.widget.Toast;
 import org.spongycastle.util.encoders.Hex;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.Iso7816TLV;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
+import org.sufficientlysecure.keychain.util.Iso7816TLV;
 import org.sufficientlysecure.keychain.util.Log;
 
 import java.io.IOException;

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

@@ -26,13 +26,13 @@ import android.widget.ImageView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.ui.util.Notify.Style;
 import org.sufficientlysecure.keychain.ui.util.QrCodeUtils;
+import org.sufficientlysecure.keychain.util.Log;
 
 public class QrCodeViewActivity extends BaseActivity {
 

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

@@ -33,12 +33,12 @@ import android.widget.Toast;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 /**
  * Sends the selected public key to a keyserver

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

@@ -34,13 +34,13 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.pgp.WrappedSignature;
 import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
+import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
 import org.sufficientlysecure.keychain.provider.KeychainContract.Certs;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.Log;
 
 import java.util.Date;

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

@@ -37,16 +37,16 @@ import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.compatibility.DialogFragmentWorkaround;
 import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
-import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
+import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException;
 import org.sufficientlysecure.keychain.ui.adapter.UserIdsAdapter;
 import org.sufficientlysecure.keychain.ui.dialog.UserIdInfoDialogFragment;
-import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.Log;
 
 import java.util.Date;
 

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

@@ -21,13 +21,13 @@ import android.content.Context;
 import android.support.v4.content.AsyncTaskLoader;
 
 import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.keyimport.CloudSearch;
+import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
 import org.sufficientlysecure.keychain.keyimport.Keyserver;
 import org.sufficientlysecure.keychain.operations.results.GetKeyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
-import org.sufficientlysecure.keychain.util.Preferences;
-import org.sufficientlysecure.keychain.keyimport.CloudSearch;
-import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
 import org.sufficientlysecure.keychain.util.Log;
+import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.util.ArrayList;
 

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

@@ -24,9 +24,9 @@ import android.support.v4.util.LongSparseArray;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
-import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
 import org.sufficientlysecure.keychain.operations.results.GetKeyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
+import org.sufficientlysecure.keychain.pgp.UncachedKeyRing;
 import org.sufficientlysecure.keychain.pgp.UncachedKeyRing.IteratorWithIOThrow;
 import org.sufficientlysecure.keychain.util.InputData;
 import org.sufficientlysecure.keychain.util.Log;

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

@@ -21,13 +21,13 @@ import android.content.Context;
 import android.database.Cursor;
 import android.os.Parcel;
 import android.support.v4.util.LongSparseArray;
+import android.support.v4.widget.CursorAdapter;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
 import android.widget.CheckBox;
 import android.widget.CompoundButton;
-import android.support.v4.widget.CursorAdapter;
 import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.R;

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

@@ -30,9 +30,9 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.ui.util.Highlighter;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 
 
 /**

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

@@ -35,11 +35,11 @@ import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.service.SaveKeyringParcel.SubkeyChange;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedSecretKey.SecretKeyType;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.provider.KeychainContract.Keys;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
+import org.sufficientlysecure.keychain.service.SaveKeyringParcel.SubkeyChange;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 
 import java.util.Calendar;
 import java.util.Date;

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

@@ -31,8 +31,8 @@ import android.widget.TextView;
 
 import org.spongycastle.bcpg.sig.KeyFlags;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 
 import java.util.Calendar;
 import java.util.Date;

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

@@ -31,9 +31,9 @@ import android.widget.ImageView;
 import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.provider.KeychainContract.Certs;
+import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/AddUserIdDialogFragment.java

@@ -45,8 +45,8 @@ import android.widget.TextView.OnEditorActionListener;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.util.ContactHelper;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.util.ContactHelper;
 import org.sufficientlysecure.keychain.util.Log;
 
 import java.util.regex.Matcher;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/FileDialogFragment.java

@@ -37,9 +37,9 @@ import android.widget.TextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.util.FileHelper;
 import org.sufficientlysecure.keychain.util.Log;
-import org.sufficientlysecure.keychain.ui.util.Notify;
 
 import java.io.File;
 

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

@@ -41,13 +41,13 @@ import com.tokenautocomplete.TokenCompleteTextView;
 
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
-import org.sufficientlysecure.keychain.util.ContactHelper;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException;
 import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
+import org.sufficientlysecure.keychain.util.ContactHelper;
 import org.sufficientlysecure.keychain.util.Log;
 
 import java.util.ArrayList;

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

@@ -37,8 +37,8 @@ import android.widget.TextView;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
-import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.util.Log;
 
 public abstract class KeySpinner extends Spinner implements LoaderManager.LoaderCallbacks<Cursor> {

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

@@ -35,9 +35,9 @@ import android.util.Patterns;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.UserPackets;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
-import org.sufficientlysecure.keychain.provider.KeychainContract;
 
 import java.io.InputStream;
 import java.util.ArrayList;

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/InputData.java

@@ -25,16 +25,28 @@ import java.io.InputStream;
 public class InputData {
     private PositionAwareInputStream mInputStream;
     private long mSize;
+    String mOriginalFilename;
+
+    public InputData(InputStream inputStream, long size, String originalFilename) {
+        mInputStream = new PositionAwareInputStream(inputStream);
+        mSize = size;
+        mOriginalFilename = originalFilename;
+    }
 
     public InputData(InputStream inputStream, long size) {
         mInputStream = new PositionAwareInputStream(inputStream);
         mSize = size;
+        mOriginalFilename = "";
     }
 
     public InputStream getInputStream() {
         return mInputStream;
     }
 
+    public String getOriginalFilename () {
+        return mOriginalFilename;
+    }
+
     public long getSize() {
         return mSize;
     }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/TlsHelper.java

@@ -20,7 +20,6 @@ package org.sufficientlysecure.keychain.util;
 import android.content.res.AssetManager;
 
 import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.util.Log;
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;

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

@@ -963,29 +963,43 @@
     <string name="msg_dc_unlocking">"Unlocking secret key"</string>
 
     <!-- Messages for SignEncrypt operation -->
-    <string name="msg_se_asymmetric">"Preparing public keys for encryption"</string>
-    <string name="msg_se_clearsign_only">"Signing of cleartext input not supported!"</string>
-    <string name="msg_se_compressing">"Preparing compression"</string>
-    <string name="msg_se_encrypting">"Encrypting data"</string>
-    <string name="msg_se_error_bad_passphrase">"Bad passphrase!"</string>
-    <string name="msg_se_error_io">"Encountered IO Exception during operation!"</string>
-    <string name="msg_se_error_key_sign">"Selected signing key cannot sign data!"</string>
-    <string name="msg_se_error_sign_key">"Error fetching signing key!"</string>
-    <string name="msg_se_error_nfc">"NFC data error!"</string>
-    <string name="msg_se_error_no_passphrase">"No passphrase provided!"</string>
-    <string name="msg_se_error_pgp">"Internal OpenPGP error!"</string>
-    <string name="msg_se_error_sig">"Encountered OpenPGP signature exception!"</string>
-    <string name="msg_se_error_unlock">"Unknown error unlocking key!"</string>
-    <string name="msg_se_key_ok">"Encrypting for key: %s"</string>
-    <string name="msg_se_key_unknown">"Missing key for encryption: %s"</string>
-    <string name="msg_se_key_warn">"Bad key for encryption: %s"</string>
-    <string name="msg_se_ok">"Sign/Encrypt operation successful!"</string>
-    <string name="msg_se_pending_nfc">"NFC token required, requesting user input…"</string>
-    <string name="msg_se_pending_passphrase">"Passphrase required, requesting user input…"</string>
-    <string name="msg_se_signing">"Signing data (without encryption)"</string>
-    <string name="msg_se_sigcrypting">"Encrypting data with signature"</string>
-    <string name="msg_se">"Starting sign and/or encrypt operation"</string>
-    <string name="msg_se_symmetric">"Preparing symmetric encryption"</string>
+    <string name="msg_se">"Starting sign/encrypt operation"</string>
+    <string name="msg_se_input_bytes">"Processing input from byte array"</string>
+    <string name="msg_se_input_uri">"Processing input from uri"</string>
+    <string name="msg_se_error_no_input">"No input given!"</string>
+    <string name="msg_se_error_input_uri_not_found">"Error opening Uri for reading!"</string>
+    <string name="msg_se_error_output_uri_not_found">"Error opening Uri for writing!"</string>
+    <string name="msg_se_error_too_many_inputs">"More inputs than outputs specified! This is probably a programming error, please report!"</string>
+    <string name="msg_se_warn_output_left">"Got outputs left but no inputs. This is probably a programming error, please report!"</string>
+    <string name="msg_se_success">"Sign/encrypt operation successful"</string>
+
+    <!-- Messages for PgpSignEncrypt operation -->
+    <string name="msg_pse_asymmetric">"Preparing public keys for encryption"</string>
+    <string name="msg_pse_clearsign_only">"Signing of cleartext input not supported!"</string>
+    <string name="msg_pse_compressing">"Preparing compression"</string>
+    <string name="msg_pse_encrypting">"Encrypting data"</string>
+    <string name="msg_pse_error_bad_passphrase">"Bad passphrase!"</string>
+    <string name="msg_pse_error_hash_algo">"Requested hashing algorithm is not supported by this key!"</string>
+    <string name="msg_pse_error_io">"Encountered IO Exception during operation!"</string>
+    <string name="msg_pse_error_key_sign">"Selected signing key cannot sign data!"</string>
+    <string name="msg_pse_error_sign_key">"Error fetching signing key!"</string>
+    <string name="msg_pse_error_nfc">"NFC data error!"</string>
+    <string name="msg_pse_error_no_passphrase">"No passphrase provided!"</string>
+    <string name="msg_pse_error_pgp">"Internal OpenPGP error!"</string>
+    <string name="msg_pse_error_sig">"Encountered OpenPGP signature exception!"</string>
+    <string name="msg_pse_error_unlock">"Unknown error unlocking key!"</string>
+    <string name="msg_pse_key_ok">"Encrypting for key: %s"</string>
+    <string name="msg_pse_key_unknown">"Missing key for encryption: %s"</string>
+    <string name="msg_pse_key_warn">"Bad key for encryption: %s"</string>
+    <string name="msg_pse_ok">"Sign/Encrypt operation successful!"</string>
+    <string name="msg_pse_pending_nfc">"NFC token required, requesting user input…"</string>
+    <string name="msg_pse_pending_passphrase">"Passphrase required, requesting user input…"</string>
+    <string name="msg_pse_signing">"Signing data (without encryption)"</string>
+    <string name="msg_pse_signing_cleartext">"Creating cleartext signature"</string>
+    <string name="msg_pse_signing_detached">"Creating detached signature"</string>
+    <string name="msg_pse_sigcrypting">"Encrypting data with signature"</string>
+    <string name="msg_pse">"Starting sign and/or encrypt operation"</string>
+    <string name="msg_pse_symmetric">"Preparing symmetric encryption"</string>
 
     <string name="msg_crt_certifying">"Generating certifications"</string>
     <string name="msg_crt_certify_all">"Certifying all user IDs for key %s"</string>