PgpSignEncryptOperation refactoring

5 files changed, 49 insertions, 84 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BackupOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BackupOperation.java
index 7c2f9d6b2..0ea7e7e59 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BackupOperation.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BackupOperation.java
@@ -47,6 +47,7 @@ import org.sufficientlysecure.keychain.operations.results.OperationResult.LogTyp
 import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
 import org.sufficientlysecure.keychain.operations.results.PgpSignEncryptResult;
 import org.sufficientlysecure.keychain.pgp.CanonicalizedKeyRing;
+import org.sufficientlysecure.keychain.pgp.PgpSignEncryptData;
 import org.sufficientlysecure.keychain.pgp.PgpSignEncryptInputParcel;
 import org.sufficientlysecure.keychain.pgp.PgpSignEncryptOperation;
 import org.sufficientlysecure.keychain.pgp.Progressable;
@@ -151,10 +152,11 @@ public class BackupOperation extends BaseOperation<BackupKeyringParcel> {
 
             PgpSignEncryptOperation pseOp = new PgpSignEncryptOperation(mContext, mProviderHelper, mProgressable, mCancelled);
 
-            PgpSignEncryptInputParcel inputParcel = new PgpSignEncryptInputParcel();
-            inputParcel.setSymmetricPassphrase(cryptoInput.getPassphrase());
-            inputParcel.setEnableAsciiArmorOutput(true);
-            inputParcel.setAddBackupHeader(true);
+            PgpSignEncryptData data = new PgpSignEncryptData();
+            data.setSymmetricPassphrase(cryptoInput.getPassphrase());
+            data.setEnableAsciiArmorOutput(true);
+            data.setAddBackupHeader(true);
+            PgpSignEncryptInputParcel inputParcel = new PgpSignEncryptInputParcel(data);
 
             InputStream inStream = mContext.getContentResolver().openInputStream(plainUri);
 
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BenchmarkOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BenchmarkOperation.java
index 52deffeab..a179fa66a 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BenchmarkOperation.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BenchmarkOperation.java
@@ -43,6 +43,7 @@ import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyInputParcel;
 import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyOperation;
 import org.sufficientlysecure.keychain.pgp.PgpSecurityConstants;
 import org.sufficientlysecure.keychain.pgp.PgpSecurityConstants.OpenKeychainSymmetricKeyAlgorithmTags;
+import org.sufficientlysecure.keychain.pgp.PgpSignEncryptData;
 import org.sufficientlysecure.keychain.pgp.Progressable;
 import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
@@ -83,9 +84,10 @@ public class BenchmarkOperation extends BaseOperation<BenchmarkInputParcel> {
             SignEncryptOperation op =
                     new SignEncryptOperation(mContext, mProviderHelper,
                             new ProgressScaler(mProgressable, i*(50/numRepeats), (i+1)*(50/numRepeats), 100), mCancelled);
-            SignEncryptParcel input = new SignEncryptParcel();
-            input.setSymmetricPassphrase(passphrase);
-            input.setSymmetricEncryptionAlgorithm(OpenKeychainSymmetricKeyAlgorithmTags.AES_128);
+            PgpSignEncryptData data = new PgpSignEncryptData();
+            data.setSymmetricPassphrase(passphrase);
+            data.setSymmetricEncryptionAlgorithm(OpenKeychainSymmetricKeyAlgorithmTags.AES_128);
+            SignEncryptParcel input = new SignEncryptParcel(data);
             input.setBytes(buf);
             encryptResult = op.execute(input, new CryptoInputParcel());
             log.add(encryptResult, 1);
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java
index 5bca372cb..dedc03553 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java
@@ -18,15 +18,6 @@
 package org.sufficientlysecure.keychain.operations;
 
 
-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;
-
 import android.content.Context;
 import android.net.Uri;
 import android.support.annotation.NonNull;
@@ -36,6 +27,8 @@ import org.sufficientlysecure.keychain.operations.results.OperationResult.LogTyp
 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.PgpSignEncryptData;
+import org.sufficientlysecure.keychain.pgp.PgpSignEncryptInputParcel;
 import org.sufficientlysecure.keychain.pgp.PgpSignEncryptOperation;
 import org.sufficientlysecure.keychain.pgp.Progressable;
 import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
@@ -45,16 +38,18 @@ import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.service.input.RequiredInputParcel;
 import org.sufficientlysecure.keychain.service.input.RequiredInputParcel.SecurityTokenSignOperationsBuilder;
 import org.sufficientlysecure.keychain.service.input.RequiredInputParcel.RequiredInputType;
-import org.sufficientlysecure.keychain.util.FileHelper;
-import org.sufficientlysecure.keychain.util.InputData;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ProgressScaler;
 
+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.
- *
+ * <p/>
  * This operation is fail-fast: If any sign/encrypt sub-operation fails or returns
  * a pending result, it will terminate.
  */
@@ -75,20 +70,20 @@ public class SignEncryptOperation extends BaseOperation<SignEncryptParcel> {
         ArrayDeque<Uri> inputUris = new ArrayDeque<>(input.getInputUris());
         ArrayDeque<Uri> outputUris = new ArrayDeque<>(input.getOutputUris());
         byte[] inputBytes = input.getBytes();
-        byte[] outputBytes = null;
 
         int total = inputBytes != null ? 1 : inputUris.size(), count = 0;
         ArrayList<PgpSignEncryptResult> results = new ArrayList<>();
 
         SecurityTokenSignOperationsBuilder pendingInputBuilder = null;
 
+        PgpSignEncryptData data = input.getData();
         // if signing subkey has not explicitly been set, get first usable subkey capable of signing
-        if (input.getSignatureMasterKeyId() != Constants.key.none
-                && input.getSignatureSubKeyId() == null) {
+        if (data.getSignatureMasterKeyId() != Constants.key.none
+                && data.getSignatureSubKeyId() == null) {
             try {
                 long signKeyId = mProviderHelper.getCachedPublicKeyRing(
-                        input.getSignatureMasterKeyId()).getSecretSignId();
-                input.setSignatureSubKeyId(signKeyId);
+                        data.getSignatureMasterKeyId()).getSecretSignId();
+                data.setSignatureSubKeyId(signKeyId);
             } catch (PgpKeyNotFoundException e) {
                 Log.e(Constants.TAG, "Key not found", e);
                 return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
@@ -96,61 +91,22 @@ public class SignEncryptOperation extends BaseOperation<SignEncryptParcel> {
         }
 
         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 = FileHelper.openInputStreamSafe(mContext.getContentResolver(), 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(mProgressable, 100 * count / total, 100 * ++count / total, 100), mCancelled);
-            PgpSignEncryptResult result = op.execute(input, cryptoInput, inputData, outStream);
+            PgpSignEncryptInputParcel inputParcel = new PgpSignEncryptInputParcel(input.getData());
+            if (inputBytes != null) {
+                inputParcel.setInputBytes(inputBytes);
+            } else {
+                inputParcel.setInputUri(inputUris.removeFirst());
+            }
+            inputParcel.setOutputUri(outputUris.pollFirst());
+
+            PgpSignEncryptResult result = op.execute(inputParcel, cryptoInput);
             results.add(result);
             log.add(result, 2);
 
@@ -162,17 +118,12 @@ public class SignEncryptOperation extends BaseOperation<SignEncryptParcel> {
                 }
                 if (pendingInputBuilder == null) {
                     pendingInputBuilder = new SecurityTokenSignOperationsBuilder(requiredInput.mSignatureTime,
-                            input.getSignatureMasterKeyId(), input.getSignatureSubKeyId());
+                            data.getSignatureMasterKeyId(), data.getSignatureSubKeyId());
                 }
                 pendingInputBuilder.addAll(requiredInput);
             } else if (!result.success()) {
                 return new SignEncryptResult(SignEncryptResult.RESULT_ERROR, log, results);
             }
-
-            if (outStream instanceof ByteArrayOutputStream) {
-                outputBytes = ((ByteArrayOutputStream) outStream).toByteArray();
-            }
-
         } while (!inputUris.isEmpty());
 
         if (pendingInputBuilder != null && !pendingInputBuilder.isEmpty()) {
@@ -184,8 +135,8 @@ public class SignEncryptOperation extends BaseOperation<SignEncryptParcel> {
         }
 
         log.add(LogType.MSG_SE_SUCCESS, 1);
-        return new SignEncryptResult(SignEncryptResult.RESULT_OK, log, results, outputBytes);
-
+        return new SignEncryptResult(SignEncryptResult.RESULT_OK, log, results,
+                results.get(results.size() - 1).getOutputBytes());
     }
 
 }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/OperationResult.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/OperationResult.java
index d3d962808..be736d785 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/OperationResult.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/OperationResult.java
@@ -710,15 +710,15 @@ public abstract class OperationResult implements Parcelable {
 
         // signencrypt
         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_SUCCESS (LogLevel.OK, R.string.msg_se_success),
 
         // pgpsignencrypt
+        MSG_PSE_INPUT_BYTES (LogLevel.INFO, R.string.msg_se_input_bytes),
+        MSG_PSE_INPUT_URI (LogLevel.INFO, R.string.msg_se_input_uri),
+        MSG_PSE_ERROR_INPUT_URI_NOT_FOUND (LogLevel.ERROR, R.string.msg_se_error_input_uri_not_found),
+        MSG_PSE_ERROR_OUTPUT_URI_NOT_FOUND (LogLevel.ERROR, R.string.msg_se_error_output_uri_not_found),
         MSG_PSE_ASYMMETRIC (LogLevel.INFO, R.string.msg_pse_asymmetric),
         MSG_PSE_COMPRESSING (LogLevel.DEBUG, R.string.msg_pse_compressing),
         MSG_PSE_ENCRYPTING (LogLevel.DEBUG, R.string.msg_pse_encrypting),
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/PgpSignEncryptResult.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/PgpSignEncryptResult.java
index c4f66b950..2b9f149ed 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/PgpSignEncryptResult.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/results/PgpSignEncryptResult.java
@@ -25,6 +25,8 @@ import org.sufficientlysecure.keychain.service.input.RequiredInputParcel;
 
 public class PgpSignEncryptResult extends InputPendingResult {
 
+    byte[] mOutputBytes;
+
     byte[] mDetachedSignature;
     public long mOperationTime;
     // this is the micalg parameter used in PGP/MIME, see RFC3156:
@@ -53,6 +55,14 @@ public class PgpSignEncryptResult extends InputPendingResult {
         mDetachedSignature = source.readInt() != 0 ? source.createByteArray() : null;
     }
 
+    public void setOutputBytes(byte[] outputBytes) {
+        mOutputBytes = outputBytes;
+    }
+
+    public byte[] getOutputBytes() {
+        return mOutputBytes;
+    }
+
     public int describeContents() {
         return 0;
     }