Start reworking decrypt ui classes

3 files changed, 197 insertions, 172 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java
index c75e28145..ecc99b348 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java
@@ -39,6 +39,7 @@ import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentService.IOType;
 import org.sufficientlysecure.keychain.service.ServiceProgressHandler;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.dialog.DeleteFileDialogFragment;
 import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment;
 import org.sufficientlysecure.keychain.ui.util.Notify;
@@ -144,7 +145,7 @@ public class DecryptFilesFragment extends DecryptFragment {
             return;
         }
 
-        decryptOriginalFilename();
+//        decryptOriginalFilename();
     }
 
     private String removeEncryptedAppend(String name) {
@@ -174,82 +175,93 @@ public class DecryptFilesFragment extends DecryptFragment {
         }
     }
 
-    private void decryptOriginalFilename() {
-        Log.d(Constants.TAG, "decryptOriginalFilename");
 
-        Intent intent = new Intent(getActivity(), KeychainIntentService.class);
-
-        // fill values for this action
-        Bundle data = new Bundle();
-        intent.setAction(KeychainIntentService.ACTION_DECRYPT_METADATA);
-
-        // data
-        Log.d(Constants.TAG, "mInputUri=" + mInputUri + ", mOutputUri=" + mOutputUri);
-
-        data.putInt(KeychainIntentService.SOURCE, IOType.URI.ordinal());
-        data.putParcelable(KeychainIntentService.ENCRYPT_DECRYPT_INPUT_URI, mInputUri);
-
-        data.putInt(KeychainIntentService.TARGET, IOType.URI.ordinal());
-        data.putParcelable(KeychainIntentService.ENCRYPT_DECRYPT_OUTPUT_URI, mOutputUri);
-
-        data.putParcelable(KeychainIntentService.DECRYPT_PASSPHRASE, mPassphrase);
-        data.putByteArray(KeychainIntentService.DECRYPT_NFC_DECRYPTED_SESSION_KEY, mNfcDecryptedSessionKey);
-
-        intent.putExtra(KeychainIntentService.EXTRA_DATA, data);
-
-        // Message is received after decrypting is done in KeychainIntentService
-        ServiceProgressHandler saveHandler = new ServiceProgressHandler(
-                getActivity(),
-                getString(R.string.progress_decrypting),
-                ProgressDialog.STYLE_HORIZONTAL,
-                ProgressDialogFragment.ServiceType.KEYCHAIN_INTENT) {
-            public void handleMessage(Message message) {
-                // handle messages by standard KeychainIntentServiceHandler first
-                super.handleMessage(message);
-
-                if (message.arg1 == MessageStatus.OKAY.ordinal()) {
-                    // get returned data bundle
-                    Bundle returnData = message.getData();
-
-                    DecryptVerifyResult pgpResult =
-                            returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT);
-
-                    if (pgpResult.isPending()) {
-                        if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) ==
-                                DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) {
-                            startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
-                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) ==
-                                DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) {
-                            startPassphraseDialog(Constants.key.symmetric);
-                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_NFC) ==
-                                DecryptVerifyResult.RESULT_PENDING_NFC) {
-                            startNfcDecrypt(pgpResult.getNfcSubKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcEncryptedSessionKey());
-                        } else {
-                            throw new RuntimeException("Unhandled pending result!");
-                        }
-                    } else if (pgpResult.success()) {
-                        // go on...
-                        askForOutputFilename(pgpResult.getDecryptMetadata().getFilename());
-                    } else {
-                        pgpResult.createNotify(getActivity()).show();
-                    }
-                }
-            }
-        };
-
-        // Create a new Messenger for the communication back
-        Messenger messenger = new Messenger(saveHandler);
-        intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger);
-
-        // show progress dialog
-        saveHandler.showProgressDialog(getActivity());
-
-        // start service with intent
-        getActivity().startService(intent);
+    // TODO: also needs to use cryptoOperation!!! (switch between this and normal decrypt
+//    private void decryptOriginalFilename() {
+//        Log.d(Constants.TAG, "decryptOriginalFilename");
+//
+//        Intent intent = new Intent(getActivity(), KeychainIntentService.class);
+//
+//        // fill values for this action
+//        Bundle data = new Bundle();
+//        intent.setAction(KeychainIntentService.ACTION_DECRYPT_METADATA);
+//
+//        // data
+//        Log.d(Constants.TAG, "mInputUri=" + mInputUri + ", mOutputUri=" + mOutputUri);
+//
+//        data.putInt(KeychainIntentService.SOURCE, IOType.URI.ordinal());
+//        data.putParcelable(KeychainIntentService.ENCRYPT_DECRYPT_INPUT_URI, mInputUri);
+//
+//        data.putInt(KeychainIntentService.TARGET, IOType.URI.ordinal());
+//        data.putParcelable(KeychainIntentService.ENCRYPT_DECRYPT_OUTPUT_URI, mOutputUri);
+//
+//        data.putParcelable(KeychainIntentService.DECRYPT_PASSPHRASE, mPassphrase);
+//        data.putByteArray(KeychainIntentService.DECRYPT_NFC_DECRYPTED_SESSION_KEY, mNfcDecryptedSessionKey);
+//
+//        intent.putExtra(KeychainIntentService.EXTRA_DATA, data);
+//
+//        // Message is received after decrypting is done in KeychainIntentService
+//        ServiceProgressHandler saveHandler = new ServiceProgressHandler(
+//                getActivity(),
+//                getString(R.string.progress_decrypting),
+//                ProgressDialog.STYLE_HORIZONTAL,
+//                ProgressDialogFragment.ServiceType.KEYCHAIN_INTENT) {
+//            public void handleMessage(Message message) {
+//                // handle messages by standard KeychainIntentServiceHandler first
+//                super.handleMessage(message);
+//
+//    // handle pending messages
+//    if (handlePendingMessage(message)) {
+//        return;
+//    }
+//
+//                if (message.arg1 == MessageStatus.OKAY.ordinal()) {
+//                    // get returned data bundle
+//                    Bundle returnData = message.getData();
+//
+//                    DecryptVerifyResult pgpResult =
+//                            returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT);
+//
+//                    if (pgpResult.isPending()) {
+//                        if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) ==
+//                                DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) {
+//                            startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
+//                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) ==
+//                                DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) {
+//                            startPassphraseDialog(Constants.key.symmetric);
+//                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_NFC) ==
+//                                DecryptVerifyResult.RESULT_PENDING_NFC) {
+//                            startNfcDecrypt(pgpResult.getNfcSubKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcEncryptedSessionKey());
+//                        } else {
+//                            throw new RuntimeException("Unhandled pending result!");
+//                        }
+//                    } else if (pgpResult.success()) {
+//                        // go on...
+//                        askForOutputFilename(pgpResult.getDecryptMetadata().getFilename());
+//                    } else {
+//                        pgpResult.createNotify(getActivity()).show();
+//                    }
+//                }
+//            }
+//        };
+//
+//        // Create a new Messenger for the communication back
+//        Messenger messenger = new Messenger(saveHandler);
+//        intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger);
+//
+//        // show progress dialog
+//        saveHandler.showProgressDialog(getActivity());
+//
+//        // start service with intent
+//        getActivity().startService(intent);
+//    }
+
+    private void decryptStart() {
+        cryptoOperation(new CryptoInputParcel());
     }
 
     @Override
-    protected void decryptStart() {
+    protected void cryptoOperation(CryptoInputParcel cryptoInput) {
         Log.d(Constants.TAG, "decryptStart");
 
         // Send all information needed to service to decrypt in other thread
@@ -284,6 +296,11 @@ public class DecryptFilesFragment extends DecryptFragment {
                 // handle messages by standard KeychainIntentServiceHandler first
                 super.handleMessage(message);
 
+                // handle pending messages
+                if (handlePendingMessage(message)) {
+                    return;
+                }
+
                 if (message.arg1 == MessageStatus.OKAY.ordinal()) {
                     // get returned data bundle
                     Bundle returnData = message.getData();
@@ -291,20 +308,21 @@ public class DecryptFilesFragment extends DecryptFragment {
                     DecryptVerifyResult pgpResult =
                             returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT);
 
-                    if (pgpResult.isPending()) {
-                        if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) ==
-                                DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) {
-                            startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
-                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) ==
-                                DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) {
-                            startPassphraseDialog(Constants.key.symmetric);
-                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_NFC) ==
-                                DecryptVerifyResult.RESULT_PENDING_NFC) {
-                            startNfcDecrypt(pgpResult.getNfcSubKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcEncryptedSessionKey());
-                        } else {
-                            throw new RuntimeException("Unhandled pending result!");
-                        }
-                    } else if (pgpResult.success()) {
+//                    if (pgpResult.isPending()) {
+//                        if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) ==
+//                                DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) {
+//                            startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
+//                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) ==
+//                                DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) {
+//                            startPassphraseDialog(Constants.key.symmetric);
+//                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_NFC) ==
+//                                DecryptVerifyResult.RESULT_PENDING_NFC) {
+//                            startNfcDecrypt(pgpResult.getNfcSubKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcEncryptedSessionKey());
+//                        } else {
+//                            throw new RuntimeException("Unhandled pending result!");
+//                        }
+
+                    if (pgpResult.success()) {
 
                         // display signature result in activity
                         onResult(pgpResult);
@@ -346,21 +364,21 @@ public class DecryptFilesFragment extends DecryptFragment {
     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
         switch (requestCode) {
-            case REQUEST_CODE_PASSPHRASE: {
-                if (resultCode == Activity.RESULT_OK && data != null) {
-                    mPassphrase = data.getParcelableExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE);
-                    decryptOriginalFilename();
-                }
-                return;
-            }
-
-            case REQUEST_CODE_NFC_DECRYPT: {
-                if (resultCode == Activity.RESULT_OK && data != null) {
-                    mNfcDecryptedSessionKey = data.getByteArrayExtra(OpenPgpApi.EXTRA_NFC_DECRYPTED_SESSION_KEY);
-                    decryptOriginalFilename();
-                }
-                return;
-            }
+//            case REQUEST_CODE_PASSPHRASE: {
+//                if (resultCode == Activity.RESULT_OK && data != null) {
+//                    mPassphrase = data.getParcelableExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE);
+////                    decryptOriginalFilename();
+//                }
+//                return;
+//            }
+//
+//            case REQUEST_CODE_NFC_DECRYPT: {
+//                if (resultCode == Activity.RESULT_OK && data != null) {
+//                    mNfcDecryptedSessionKey = data.getByteArrayExtra(OpenPgpApi.EXTRA_NFC_DECRYPTED_SESSION_KEY);
+////                    decryptOriginalFilename();
+//                }
+//                return;
+//            }
 
             case REQUEST_CODE_INPUT: {
                 if (resultCode == Activity.RESULT_OK && data != null) {
@@ -383,4 +401,5 @@ public class DecryptFilesFragment extends DecryptFragment {
             }
         }
     }
+
 }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java
index 63508e530..f00136d5b 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java
@@ -34,11 +34,11 @@ import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State;
 import org.sufficientlysecure.keychain.util.Passphrase;
 
-public abstract class DecryptFragment extends Fragment {
+public abstract class DecryptFragment extends CryptoOperationFragment {
     private static final int RESULT_CODE_LOOKUP_KEY = 0x00007006;
 
-    public static final int REQUEST_CODE_PASSPHRASE = 0x00008001;
-    public static final int REQUEST_CODE_NFC_DECRYPT = 0x00008002;
+//    public static final int REQUEST_CODE_PASSPHRASE = 0x00008001;
+//    public static final int REQUEST_CODE_NFC_DECRYPT = 0x00008002;
 
     protected long mSignatureKeyId = 0;
 
@@ -95,24 +95,24 @@ public abstract class DecryptFragment extends Fragment {
         startActivity(viewKeyIntent);
     }
 
-    protected void startPassphraseDialog(long subkeyId) {
-        Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class);
-        intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, subkeyId);
-        startActivityForResult(intent, REQUEST_CODE_PASSPHRASE);
-    }
-
-    protected void startNfcDecrypt(long subKeyId, Passphrase pin, byte[] encryptedSessionKey) {
-        // build PendingIntent for Yubikey NFC operations
-        Intent intent = new Intent(getActivity(), NfcActivity.class);
-        intent.setAction(NfcActivity.ACTION_DECRYPT_SESSION_KEY);
-        intent.putExtra(NfcActivity.EXTRA_DATA, new Intent()); // not used, only relevant to OpenPgpService
-        intent.putExtra(NfcActivity.EXTRA_KEY_ID, subKeyId);
-        intent.putExtra(NfcActivity.EXTRA_PIN, pin);
-
-        intent.putExtra(NfcActivity.EXTRA_NFC_ENC_SESSION_KEY, encryptedSessionKey);
-
-        startActivityForResult(intent, REQUEST_CODE_NFC_DECRYPT);
-    }
+//    protected void startPassphraseDialog(long subkeyId) {
+//        Intent intent = new Intent(getActivity(), PassphraseDialogActivity.class);
+//        intent.putExtra(PassphraseDialogActivity.EXTRA_SUBKEY_ID, subkeyId);
+//        startActivityForResult(intent, REQUEST_CODE_PASSPHRASE);
+//    }
+//
+//    protected void startNfcDecrypt(long subKeyId, Passphrase pin, byte[] encryptedSessionKey) {
+//        // build PendingIntent for Yubikey NFC operations
+//        Intent intent = new Intent(getActivity(), NfcActivity.class);
+//        intent.setAction(NfcActivity.ACTION_DECRYPT_SESSION_KEY);
+//        intent.putExtra(NfcActivity.EXTRA_DATA, new Intent()); // not used, only relevant to OpenPgpService
+//        intent.putExtra(NfcActivity.EXTRA_KEY_ID, subKeyId);
+//        intent.putExtra(NfcActivity.EXTRA_PIN, pin);
+//
+//        intent.putExtra(NfcActivity.EXTRA_NFC_ENC_SESSION_KEY, encryptedSessionKey);
+//
+//        startActivityForResult(intent, REQUEST_CODE_NFC_DECRYPT);
+//    }
 
     /**
      *
@@ -253,9 +253,4 @@ public abstract class DecryptFragment extends Fragment {
         });
     }
 
-    /**
-     * Should be overridden by MessageFragment and FileFragment to start actual decryption
-     */
-    protected abstract void decryptStart();
-
 }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java
index f6e21937d..523b24fd7 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java
@@ -38,6 +38,7 @@ import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.service.KeychainIntentService;
 import org.sufficientlysecure.keychain.service.KeychainIntentService.IOType;
 import org.sufficientlysecure.keychain.service.ServiceProgressHandler;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.util.Log;
@@ -147,8 +148,13 @@ public class DecryptTextFragment extends DecryptFragment {
         }
     }
 
+    private void decryptStart() {
+        cryptoOperation(new CryptoInputParcel());
+    }
+
     @Override
-    protected void decryptStart() {
+    protected void cryptoOperation(CryptoInputParcel cryptoInput) {
+
         Log.d(Constants.TAG, "decryptStart");
 
         // Send all information needed to service to decrypt in other thread
@@ -177,6 +183,11 @@ public class DecryptTextFragment extends DecryptFragment {
                 // handle messages by standard KeychainIntentServiceHandler first
                 super.handleMessage(message);
 
+                // handle pending messages
+                if (handlePendingMessage(message)) {
+                    return;
+                }
+
                 if (message.arg1 == MessageStatus.OKAY.ordinal()) {
                     // get returned data bundle
                     Bundle returnData = message.getData();
@@ -184,20 +195,20 @@ public class DecryptTextFragment extends DecryptFragment {
                     DecryptVerifyResult pgpResult =
                             returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT);
 
-                    if (pgpResult.isPending()) {
-                        if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) ==
-                                DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) {
-                            startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
-                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) ==
-                                DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) {
-                            startPassphraseDialog(Constants.key.symmetric);
-                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_NFC) ==
-                                DecryptVerifyResult.RESULT_PENDING_NFC) {
-                            startNfcDecrypt(pgpResult.getNfcSubKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcEncryptedSessionKey());
-                        } else {
-                            throw new RuntimeException("Unhandled pending result!");
-                        }
-                    } else if (pgpResult.success()) {
+//                    if (pgpResult.isPending()) {
+//                        if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) ==
+//                                DecryptVerifyResult.RESULT_PENDING_ASYM_PASSPHRASE) {
+//                            startPassphraseDialog(pgpResult.getKeyIdPassphraseNeeded());
+//                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) ==
+//                                DecryptVerifyResult.RESULT_PENDING_SYM_PASSPHRASE) {
+//                            startPassphraseDialog(Constants.key.symmetric);
+//                        } else if ((pgpResult.getResult() & DecryptVerifyResult.RESULT_PENDING_NFC) ==
+//                                DecryptVerifyResult.RESULT_PENDING_NFC) {
+//                            startNfcDecrypt(pgpResult.getNfcSubKeyId(), pgpResult.getNfcPassphrase(), pgpResult.getNfcEncryptedSessionKey());
+//                        } else {
+//                            throw new RuntimeException("Unhandled pending result!");
+//                        }
+                    if (pgpResult.success()) {
 
                         byte[] decryptedMessage = returnData
                                 .getByteArray(KeychainIntentService.RESULT_DECRYPTED_BYTES);
@@ -245,34 +256,34 @@ public class DecryptTextFragment extends DecryptFragment {
         getActivity().startService(intent);
     }
 
-    @Override
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        switch (requestCode) {
-
-            case REQUEST_CODE_PASSPHRASE: {
-                if (resultCode == Activity.RESULT_OK && data != null) {
-                    mPassphrase = data.getParcelableExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE);
-                    decryptStart();
-                } else {
-                    getActivity().finish();
-                }
-                return;
-            }
-
-            case REQUEST_CODE_NFC_DECRYPT: {
-                if (resultCode == Activity.RESULT_OK && data != null) {
-                    mNfcDecryptedSessionKey = data.getByteArrayExtra(OpenPgpApi.EXTRA_NFC_DECRYPTED_SESSION_KEY);
-                    decryptStart();
-                } else {
-                    getActivity().finish();
-                }
-                return;
-            }
-
-            default: {
-                super.onActivityResult(requestCode, resultCode, data);
-            }
-        }
-    }
+//    @Override
+//    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+//        switch (requestCode) {
+//
+//            case REQUEST_CODE_PASSPHRASE: {
+//                if (resultCode == Activity.RESULT_OK && data != null) {
+//                    mPassphrase = data.getParcelableExtra(PassphraseDialogActivity.MESSAGE_DATA_PASSPHRASE);
+//                    decryptStart();
+//                } else {
+//                    getActivity().finish();
+//                }
+//                return;
+//            }
+//
+//            case REQUEST_CODE_NFC_DECRYPT: {
+//                if (resultCode == Activity.RESULT_OK && data != null) {
+//                    mNfcDecryptedSessionKey = data.getByteArrayExtra(OpenPgpApi.EXTRA_NFC_DECRYPTED_SESSION_KEY);
+//                    decryptStart();
+//                } else {
+//                    getActivity().finish();
+//                }
+//                return;
+//            }
+//
+//            default: {
+//                super.onActivityResult(requestCode, resultCode, data);
+//            }
+//        }
+//    }
 
 }