Merge remote-tracking branch 'origin/master'

14 files changed, 719 insertions, 342 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java
index 467eab785..65baf0593 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java
@@ -49,6 +49,7 @@ import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.service.CertifyActionsParcel;
 import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.adapter.MultiUserIdsAdapter;
 import org.sufficientlysecure.keychain.ui.base.CachingCryptoOperationFragment;
 import org.sufficientlysecure.keychain.ui.util.Notify;
@@ -57,6 +58,7 @@ import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Preferences;
 
 import java.util.ArrayList;
+import java.util.Date;
 
 public class CertifyKeyFragment
         extends CachingCryptoOperationFragment<CertifyActionsParcel, CertifyResult>
@@ -165,7 +167,7 @@ public class CertifyKeyFragment
                     Notify.create(getActivity(), getString(R.string.select_key_to_certify),
                             Notify.Style.ERROR).show();
                 } else {
-                    cryptoOperation();
+                    cryptoOperation(new CryptoInputParcel(new Date()));
                 }
             }
         });
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java
index 65bdca5c4..739eb3e35 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java
@@ -18,6 +18,7 @@
 package org.sufficientlysecure.keychain.ui;
 
 
+import java.util.Date;
 import java.util.Iterator;
 
 import android.app.Activity;
@@ -47,6 +48,7 @@ import org.sufficientlysecure.keychain.service.ExportKeyringParcel;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel.Algorithm;
 import org.sufficientlysecure.keychain.service.SaveKeyringParcel.ChangeUnlockParcel;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.CreateKeyActivity.FragAction;
 import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
 import org.sufficientlysecure.keychain.util.Log;
@@ -393,7 +395,7 @@ public class CreateKeyFinalFragment extends Fragment {
 
 
         mMoveToCardOpHelper = new CryptoOperationHelper<>(2, this, callback, R.string.progress_modify);
-        mMoveToCardOpHelper.cryptoOperation();
+        mMoveToCardOpHelper.cryptoOperation(new CryptoInputParcel(new Date()));
     }
 
     private void uploadKey(final EditKeyResult saveKeyResult) {
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DeleteKeyDialogActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DeleteKeyDialogActivity.java
new file mode 100644
index 000000000..4c1dbd1ee
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DeleteKeyDialogActivity.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright (C) 2013-2015 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2015 Vincent Breitmoser <v.breitmoser@mugenguild.com>
+ * Copyright (C) 2015 Adithya Abraham Philip <adithyaphilip@gmail.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.ui;
+
+import android.app.Activity;
+import android.support.v7.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import android.view.ContextThemeWrapper;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.Spinner;
+import android.widget.TextView;
+
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.operations.results.DeleteResult;
+import org.sufficientlysecure.keychain.operations.results.OperationResult;
+import org.sufficientlysecure.keychain.operations.results.RevokeResult;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
+import org.sufficientlysecure.keychain.provider.KeychainContract;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.service.DeleteKeyringParcel;
+import org.sufficientlysecure.keychain.service.RevokeKeyringParcel;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
+import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
+import org.sufficientlysecure.keychain.ui.dialog.CustomAlertDialogBuilder;
+import org.sufficientlysecure.keychain.ui.util.Notify;
+import org.sufficientlysecure.keychain.util.Log;
+
+import java.util.Date;
+import java.util.HashMap;
+
+public class DeleteKeyDialogActivity extends FragmentActivity {
+    public static final String EXTRA_DELETE_MASTER_KEY_IDS = "extra_delete_master_key_ids";
+    public static final String EXTRA_HAS_SECRET = "extra_has_secret";
+    public static final String EXTRA_KEYSERVER = "extra_keyserver";
+
+    private CryptoOperationHelper<DeleteKeyringParcel, DeleteResult> mDeleteOpHelper;
+    private CryptoOperationHelper<RevokeKeyringParcel, RevokeResult> mRevokeOpHelper;
+
+    private long[] mMasterKeyIds;
+    private boolean mHasSecret;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        mDeleteOpHelper = new CryptoOperationHelper<>(1, DeleteKeyDialogActivity.this,
+                getDeletionCallback(), R.string.progress_deleting);
+
+        mRevokeOpHelper = new CryptoOperationHelper<>(2, this,
+                getRevocationCallback(), R.string.progress_revoking_uploading);
+
+        mMasterKeyIds = getIntent().getLongArrayExtra(EXTRA_DELETE_MASTER_KEY_IDS);
+        mHasSecret = getIntent().getBooleanExtra(EXTRA_HAS_SECRET, false);
+
+        if (mMasterKeyIds.length > 1 && mHasSecret) {
+            // secret keys can only be deleted individually
+            OperationResult.OperationLog log = new OperationResult.OperationLog();
+            log.add(OperationResult.LogType.MSG_DEL_ERROR_MULTI_SECRET, 0);
+            returnResult(new DeleteResult(OperationResult.RESULT_ERROR, log, 0,
+                    mMasterKeyIds.length));
+        }
+
+        if (mMasterKeyIds.length == 1 && mHasSecret) {
+            // if mMasterKeyIds.length == 0 we let the DeleteOperation respond
+            try {
+                HashMap<String, Object> data = new ProviderHelper(this).getUnifiedData(
+                        mMasterKeyIds[0], new String[]{
+                                KeychainContract.KeyRings.USER_ID,
+                                KeychainContract.KeyRings.IS_REVOKED
+                        }, new int[]{
+                                ProviderHelper.FIELD_TYPE_STRING,
+                                ProviderHelper.FIELD_TYPE_INTEGER
+                        }
+                );
+
+                String name;
+                KeyRing.UserId mainUserId = KeyRing.splitUserId(
+                        (String) data.get(KeychainContract.KeyRings.USER_ID));
+                if (mainUserId.name != null) {
+                    name = mainUserId.name;
+                } else {
+                    name = getString(R.string.user_id_no_name);
+                }
+
+                if ((long) data.get(KeychainContract.KeyRings.IS_REVOKED) > 0) {
+                    showNormalDeleteDialog();
+                } else {
+                    showRevokeDeleteDialog(name);
+                }
+            } catch (ProviderHelper.NotFoundException e) {
+                Log.e(Constants.TAG,
+                        "Secret key to delete not found at DeleteKeyDialogActivity for "
+                                + mMasterKeyIds[0], e);
+                finish();
+            }
+        } else {
+            showNormalDeleteDialog();
+        }
+    }
+
+    private void showNormalDeleteDialog() {
+
+        DeleteKeyDialogFragment deleteKeyDialogFragment
+                = DeleteKeyDialogFragment.newInstance(mMasterKeyIds, mHasSecret);
+
+        deleteKeyDialogFragment.show(getSupportFragmentManager(), "deleteKeyDialog");
+
+    }
+
+    private void showRevokeDeleteDialog(String keyname) {
+
+        RevokeDeleteDialogFragment fragment = RevokeDeleteDialogFragment.newInstance(keyname);
+        fragment.show(getSupportFragmentManager(), "deleteRevokeDialog");
+    }
+
+    private void startRevocationOperation() {
+        mRevokeOpHelper.cryptoOperation(new CryptoInputParcel(new Date(), false));
+    }
+
+    private void startDeletionOperation() {
+        mDeleteOpHelper.cryptoOperation();
+    }
+
+    private CryptoOperationHelper.Callback<RevokeKeyringParcel, RevokeResult> getRevocationCallback() {
+
+        return new CryptoOperationHelper.Callback<RevokeKeyringParcel, RevokeResult>() {
+            @Override
+            public RevokeKeyringParcel createOperationInput() {
+                return new RevokeKeyringParcel(mMasterKeyIds[0], true,
+                        getIntent().getStringExtra(EXTRA_KEYSERVER));
+            }
+
+            @Override
+            public void onCryptoOperationSuccess(RevokeResult result) {
+                returnResult(result);
+            }
+
+            @Override
+            public void onCryptoOperationCancelled() {
+                setResult(RESULT_CANCELED);
+                finish();
+            }
+
+            @Override
+            public void onCryptoOperationError(RevokeResult result) {
+                returnResult(result);
+            }
+
+            @Override
+            public boolean onCryptoSetProgress(String msg, int progress, int max) {
+                return false;
+            }
+        };
+    }
+
+    private CryptoOperationHelper.Callback<DeleteKeyringParcel, DeleteResult> getDeletionCallback() {
+
+        return new CryptoOperationHelper.Callback<DeleteKeyringParcel, DeleteResult>() {
+            @Override
+            public DeleteKeyringParcel createOperationInput() {
+                return new DeleteKeyringParcel(mMasterKeyIds, mHasSecret);
+            }
+
+            @Override
+            public void onCryptoOperationSuccess(DeleteResult result) {
+                returnResult(result);
+            }
+
+            @Override
+            public void onCryptoOperationCancelled() {
+                setResult(RESULT_CANCELED);
+                finish();
+            }
+
+            @Override
+            public void onCryptoOperationError(DeleteResult result) {
+                returnResult(result);
+            }
+
+            @Override
+            public boolean onCryptoSetProgress(String msg, int progress, int max) {
+                return false;
+            }
+        };
+    }
+
+    private void returnResult(OperationResult result) {
+        Intent intent = new Intent();
+        intent.putExtra(OperationResult.EXTRA_RESULT, result);
+        setResult(RESULT_OK, intent);
+        finish();
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        mDeleteOpHelper.handleActivityResult(requestCode, resultCode, data);
+        mRevokeOpHelper.handleActivityResult(requestCode, resultCode, data);
+    }
+
+    public static class DeleteKeyDialogFragment extends DialogFragment {
+
+        private static final String ARG_DELETE_MASTER_KEY_IDS = "delete_master_key_ids";
+        private static final String ARG_HAS_SECRET = "has_secret";
+
+        private TextView mMainMessage;
+        private View mInflateView;
+
+        /**
+         * Creates new instance of this delete file dialog fragment
+         */
+        public static DeleteKeyDialogFragment newInstance(long[] masterKeyIds, boolean hasSecret) {
+            DeleteKeyDialogFragment frag = new DeleteKeyDialogFragment();
+            Bundle args = new Bundle();
+
+            args.putLongArray(ARG_DELETE_MASTER_KEY_IDS, masterKeyIds);
+            args.putBoolean(ARG_HAS_SECRET, hasSecret);
+
+            frag.setArguments(args);
+
+            return frag;
+        }
+
+        @NonNull
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            final FragmentActivity activity = getActivity();
+
+            final long[] masterKeyIds = getArguments().getLongArray(ARG_DELETE_MASTER_KEY_IDS);
+            final boolean hasSecret = getArguments().getBoolean(ARG_HAS_SECRET);
+
+            ContextThemeWrapper theme = new ContextThemeWrapper(activity,
+                    R.style.Theme_AppCompat_Light_Dialog);
+
+            CustomAlertDialogBuilder builder = new CustomAlertDialogBuilder(theme);
+
+            // Setup custom View to display in AlertDialog
+            LayoutInflater inflater = LayoutInflater.from(theme);
+            mInflateView = inflater.inflate(R.layout.view_key_delete_fragment, null);
+            builder.setView(mInflateView);
+
+            mMainMessage = (TextView) mInflateView.findViewById(R.id.mainMessage);
+
+            // If only a single key has been selected
+            if (masterKeyIds.length == 1) {
+                long masterKeyId = masterKeyIds[0];
+
+                try {
+                    HashMap<String, Object> data = new ProviderHelper(activity).getUnifiedData(
+                            masterKeyId, new String[]{
+                                    KeychainContract.KeyRings.USER_ID,
+                                    KeychainContract.KeyRings.HAS_ANY_SECRET
+                            }, new int[]{
+                                    ProviderHelper.FIELD_TYPE_STRING,
+                                    ProviderHelper.FIELD_TYPE_INTEGER
+                            }
+                    );
+                    String name;
+                    KeyRing.UserId mainUserId = KeyRing.splitUserId((String) data.get(KeychainContract.KeyRings.USER_ID));
+                    if (mainUserId.name != null) {
+                        name = mainUserId.name;
+                    } else {
+                        name = getString(R.string.user_id_no_name);
+                    }
+
+                    if (hasSecret) {
+                        // show title only for secret key deletions,
+                        // see http://www.google.com/design/spec/components/dialogs.html#dialogs-behavior
+                        builder.setTitle(getString(R.string.title_delete_secret_key, name));
+                        mMainMessage.setText(getString(R.string.secret_key_deletion_confirmation, name));
+                    } else {
+                        mMainMessage.setText(getString(R.string.public_key_deletetion_confirmation, name));
+                    }
+                } catch (ProviderHelper.NotFoundException e) {
+                    dismiss();
+                    return null;
+                }
+            } else {
+                mMainMessage.setText(R.string.key_deletion_confirmation_multi);
+            }
+
+            builder.setPositiveButton(R.string.btn_delete, new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+
+                    ((DeleteKeyDialogActivity) getActivity()).startDeletionOperation();
+                }
+            });
+
+            builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+
+                @Override
+                public void onClick(DialogInterface dialog, int id) {
+                    dialog.cancel();
+                }
+            });
+
+            return builder.show();
+        }
+
+        @Override
+        public void onCancel(DialogInterface dialog) {
+            super.onCancel(dialog);
+            getActivity().setResult(RESULT_CANCELED);
+            getActivity().finish();
+        }
+    }
+
+    public static class RevokeDeleteDialogFragment extends DialogFragment {
+
+        public static final String ARG_KEY_NAME = "arg_key_name";
+
+        public static RevokeDeleteDialogFragment newInstance(String keyName) {
+            Bundle args = new Bundle();
+            args.putString(ARG_KEY_NAME, keyName);
+            RevokeDeleteDialogFragment frag = new RevokeDeleteDialogFragment();
+            frag.setArguments(args);
+            return frag;
+        }
+
+        @NonNull
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            final Activity activity = getActivity();
+
+            final String CHOICE_REVOKE = getString(R.string.del_rev_dialog_choice_rev_upload);
+            final String CHOICE_DELETE = getString(R.string.del_rev_dialog_choice_delete);
+
+            // if the dialog is displayed from the application class, design is missing
+            // hack to get holo design (which is not automatically applied due to activity's Theme.NoDisplay
+            ContextThemeWrapper theme = new ContextThemeWrapper(activity,
+                    R.style.Theme_AppCompat_Light_Dialog);
+
+            CustomAlertDialogBuilder builder = new CustomAlertDialogBuilder(theme);
+            builder.setTitle(getString(R.string.del_rev_dialog_title,
+                    getArguments().get(ARG_KEY_NAME)));
+
+            LayoutInflater inflater = LayoutInflater.from(theme);
+            View view = inflater.inflate(R.layout.del_rev_dialog, null);
+            builder.setView(view);
+
+            final Spinner spinner = (Spinner) view.findViewById(R.id.spinner);
+
+            builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+
+                @Override
+                public void onClick(DialogInterface dialog, int id) {
+                    dialog.cancel();
+                }
+            });
+
+            builder.setPositiveButton(R.string.del_rev_dialog_btn_revoke,
+                    new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int which) {
+
+                            String choice = spinner.getSelectedItem().toString();
+                            if (choice.equals(CHOICE_REVOKE)) {
+                                ((DeleteKeyDialogActivity) activity)
+                                        .startRevocationOperation();
+                            } else if (choice.equals(CHOICE_DELETE)) {
+                                ((DeleteKeyDialogActivity) activity)
+                                        .showNormalDeleteDialog();
+                            } else {
+                                throw new AssertionError(
+                                        "Unsupported delete type in RevokeDeleteDialogFragment");
+                            }
+                        }
+                    });
+
+            final AlertDialog alertDialog = builder.show();
+
+            spinner.setOnItemSelectedListener(new AdapterView.OnItemSelectedListener() {
+                public void onItemSelected(AdapterView<?> parent, View view, int pos, long id) {
+
+                    String choice = parent.getItemAtPosition(pos).toString();
+
+                    if (choice.equals(CHOICE_REVOKE)) {
+                        alertDialog.getButton(AlertDialog.BUTTON_POSITIVE)
+                                .setText(R.string.del_rev_dialog_btn_revoke);
+                    } else if (choice.equals(CHOICE_DELETE)) {
+                        alertDialog.getButton(AlertDialog.BUTTON_POSITIVE)
+                                .setText(R.string.del_rev_dialog_btn_delete);
+                    } else {
+                        throw new AssertionError(
+                                "Unsupported delete type in RevokeDeleteDialogFragment");
+                    }
+                }
+
+                public void onNothingSelected(AdapterView<?> parent) {
+                }
+            });
+
+            return alertDialog;
+        }
+
+        @Override
+        public void onCancel(DialogInterface dialog) {
+            super.onCancel(dialog);
+            getActivity().setResult(RESULT_CANCELED);
+            getActivity().finish();
+        }
+    }
+
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java
index 4e9c5a836..4769e68d8 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java
@@ -68,6 +68,8 @@ import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.Passphrase;
 
+import java.util.Date;
+
 public class EditKeyFragment extends QueueingCryptoOperationFragment<SaveKeyringParcel, OperationResult>
         implements LoaderManager.LoaderCallbacks<Cursor> {
 
@@ -151,7 +153,7 @@ public class EditKeyFragment extends QueueingCryptoOperationFragment<SaveKeyring
                         if (mDataUri == null) {
                             returnKeyringParcel();
                         } else {
-                            cryptoOperation(new CryptoInputParcel());
+                            cryptoOperation(new CryptoInputParcel(new Date()));
                         }
                     }
                 }, new OnClickListener() {
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java
index 84315860c..3dc93872d 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java
@@ -21,6 +21,7 @@ package org.sufficientlysecure.keychain.ui;
 import java.io.File;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Date;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -57,6 +58,7 @@ import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpConstants;
 import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
 import org.sufficientlysecure.keychain.provider.TemporaryStorageProvider;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.adapter.SpacesItemDecoration;
 import org.sufficientlysecure.keychain.ui.base.CachingCryptoOperationFragment;
 import org.sufficientlysecure.keychain.ui.dialog.DeleteFileDialogFragment;
@@ -279,19 +281,19 @@ public class EncryptFilesFragment
             case R.id.encrypt_save: {
                 hideKeyboard();
                 mAfterEncryptAction = AfterEncryptAction.SAVE;
-                cryptoOperation();
+                cryptoOperation(new CryptoInputParcel(new Date()));
                 break;
             }
             case R.id.encrypt_share: {
                 hideKeyboard();
                 mAfterEncryptAction = AfterEncryptAction.SHARE;
-                cryptoOperation();
+                cryptoOperation(new CryptoInputParcel(new Date()));
                 break;
             }
             case R.id.encrypt_copy: {
                 hideKeyboard();
                 mAfterEncryptAction = AfterEncryptAction.COPY;
-                cryptoOperation();
+                cryptoOperation(new CryptoInputParcel(new Date()));
                 break;
             }
             case R.id.check_use_armor: {
@@ -666,7 +668,7 @@ public class EncryptFilesFragment
                     mOutputUris.add(data.getData());
                     // make sure this is correct at this point
                     mAfterEncryptAction = AfterEncryptAction.SAVE;
-                    cryptoOperation();
+                    cryptoOperation(new CryptoInputParcel(new Date()));
                 }
                 return;
             }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java
index 7f49b14f8..32257eba5 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java
@@ -40,6 +40,7 @@ import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
 import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.pgp.PgpConstants;
 import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.ui.base.CachingCryptoOperationFragment;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.ui.util.Notify.ActionListener;
@@ -48,6 +49,7 @@ import org.sufficientlysecure.keychain.util.Passphrase;
 import org.sufficientlysecure.keychain.util.Preferences;
 import org.sufficientlysecure.keychain.util.ShareHelper;
 
+import java.util.Date;
 import java.util.HashSet;
 import java.util.Set;
 
@@ -168,13 +170,13 @@ public class EncryptTextFragment
             case R.id.encrypt_copy: {
                 hideKeyboard();
                 mShareAfterEncrypt = false;
-                cryptoOperation();
+                cryptoOperation(new CryptoInputParcel(new Date()));
                 break;
             }
             case R.id.encrypt_share: {
                 hideKeyboard();
                 mShareAfterEncrypt = true;
-                cryptoOperation();
+                cryptoOperation(new CryptoInputParcel(new Date()));
                 break;
             }
             default: {
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java
index ee1c8460c..95e047b0f 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java
@@ -33,9 +33,6 @@ import android.graphics.Color;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
-import android.os.Handler;
-import android.os.Message;
-import android.os.Messenger;
 import android.support.v4.app.LoaderManager;
 import android.support.v4.content.CursorLoader;
 import android.support.v4.content.Loader;
@@ -60,7 +57,6 @@ import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
 import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
-import org.sufficientlysecure.keychain.operations.results.DeleteResult;
 import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
 import org.sufficientlysecure.keychain.operations.results.OperationResult;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
@@ -71,7 +67,6 @@ import org.sufficientlysecure.keychain.service.ConsolidateInputParcel;
 import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
 import org.sufficientlysecure.keychain.ui.adapter.KeyAdapter;
 import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
-import org.sufficientlysecure.keychain.ui.dialog.DeleteKeyDialogFragment;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.Notify;
 import org.sufficientlysecure.keychain.ui.util.Notify.Style;
@@ -91,6 +86,8 @@ public class KeyListFragment extends LoaderFragment
         CryptoOperationHelper.Callback<ImportKeyringParcel, ImportKeyResult> {
 
     static final int REQUEST_ACTION = 1;
+    private static final int REQUEST_DELETE = 2;
+    private static final int REQUEST_VIEW_KEY = 3;
 
     private KeyListAdapter mAdapter;
     private StickyListHeadersListView mStickyList;
@@ -220,7 +217,7 @@ public class KeyListFragment extends LoaderFragment
                     }
                     case R.id.menu_key_list_multi_delete: {
                         ids = mAdapter.getCurrentSelectedMasterKeyIds();
-                        showDeleteKeyDialog(mode, ids, mAdapter.isAnySecretSelected());
+                        showDeleteKeyDialog(ids, mAdapter.isAnySecretSelected());
                         break;
                     }
                 }
@@ -336,7 +333,7 @@ public class KeyListFragment extends LoaderFragment
         Intent viewIntent = new Intent(getActivity(), ViewKeyActivity.class);
         viewIntent.setData(
                 KeyRings.buildGenericKeyRingUri(mAdapter.getMasterKeyId(position)));
-        startActivity(viewIntent);
+        startActivityForResult(viewIntent, REQUEST_VIEW_KEY);
     }
 
     protected void encrypt(ActionMode mode, long[] masterKeyIds) {
@@ -354,38 +351,15 @@ public class KeyListFragment extends LoaderFragment
      *
      * @param hasSecret must contain whether the list of masterKeyIds contains a secret key or not
      */
-    public void showDeleteKeyDialog(final ActionMode mode, long[] masterKeyIds, boolean hasSecret) {
-        // Can only work on singular secret keys
-        if (hasSecret && masterKeyIds.length > 1) {
-            Notify.create(getActivity(), R.string.secret_cannot_multiple,
-                    Notify.Style.ERROR).show();
-            return;
+    public void showDeleteKeyDialog(long[] masterKeyIds, boolean hasSecret) {
+        Intent intent = new Intent(getActivity(), DeleteKeyDialogActivity.class);
+        intent.putExtra(DeleteKeyDialogActivity.EXTRA_DELETE_MASTER_KEY_IDS, masterKeyIds);
+        intent.putExtra(DeleteKeyDialogActivity.EXTRA_HAS_SECRET, hasSecret);
+        if (hasSecret) {
+            intent.putExtra(DeleteKeyDialogActivity.EXTRA_KEYSERVER,
+                    Preferences.getPreferences(getActivity()).getPreferredKeyserver());
         }
-
-        // Message is received after key is deleted
-        Handler returnHandler = new Handler() {
-            @Override
-            public void handleMessage(Message message) {
-                if (message.arg1 == DeleteKeyDialogFragment.MESSAGE_OKAY) {
-                    Bundle data = message.getData();
-                    if (data != null) {
-                        DeleteResult result = data.getParcelable(DeleteResult.EXTRA_RESULT);
-                        if (result != null) {
-                            result.createNotify(getActivity()).show();
-                        }
-                    }
-                    mode.finish();
-                }
-            }
-        };
-
-        // Create a new Messenger for the communication back
-        Messenger messenger = new Messenger(returnHandler);
-
-        DeleteKeyDialogFragment deleteKeyDialog = DeleteKeyDialogFragment.newInstance(messenger,
-                masterKeyIds);
-
-        deleteKeyDialog.show(getActivity().getSupportFragmentManager(), "deleteKeyDialog");
+        startActivityForResult(intent, REQUEST_DELETE);
     }
 
 
@@ -620,14 +594,37 @@ public class KeyListFragment extends LoaderFragment
             mConsolidateOpHelper.handleActivityResult(requestCode, resultCode, data);
         }
 
-        if (requestCode == REQUEST_ACTION) {
-            // if a result has been returned, display a notify
-            if (data != null && data.hasExtra(OperationResult.EXTRA_RESULT)) {
-                OperationResult result = data.getParcelableExtra(OperationResult.EXTRA_RESULT);
-                result.createNotify(getActivity()).show();
-            } else {
-                super.onActivityResult(requestCode, resultCode, data);
-            }
+        switch (requestCode) {
+            case REQUEST_DELETE:
+                if (mActionMode != null) {
+                    mActionMode.finish();
+                }
+                if (data != null && data.hasExtra(OperationResult.EXTRA_RESULT)) {
+                    OperationResult result = data.getParcelableExtra(OperationResult.EXTRA_RESULT);
+                    result.createNotify(getActivity()).show();
+                } else {
+                    super.onActivityResult(requestCode, resultCode, data);
+                }
+                break;
+
+            case REQUEST_ACTION:
+                // if a result has been returned, display a notify
+                if (data != null && data.hasExtra(OperationResult.EXTRA_RESULT)) {
+                    OperationResult result = data.getParcelableExtra(OperationResult.EXTRA_RESULT);
+                    result.createNotify(getActivity()).show();
+                } else {
+                    super.onActivityResult(requestCode, resultCode, data);
+                }
+                break;
+
+            case REQUEST_VIEW_KEY:
+                if (data != null && data.hasExtra(OperationResult.EXTRA_RESULT)) {
+                    OperationResult result = data.getParcelableExtra(OperationResult.EXTRA_RESULT);
+                    result.createNotify(getActivity()).show();
+                } else {
+                    super.onActivityResult(requestCode, resultCode, data);
+                }
+                break;
         }
     }
 
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/NfcOperationActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/NfcOperationActivity.java
index 8802cd621..1584b87ae 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/NfcOperationActivity.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/NfcOperationActivity.java
@@ -33,21 +33,25 @@ import org.sufficientlysecure.keychain.util.Preferences;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
+import java.util.Date;
 
 /**
  * This class provides a communication interface to OpenPGP applications on ISO SmartCard compliant
  * NFC devices.
  * <p/>
  * For the full specs, see http://g10code.com/docs/openpgp-card-2.0.pdf
+ * NOTE: If no CryptoInputParcel is passed via EXTRA_CRYPTO_INPUT, the CryptoInputParcel is created
+ * internally and is NOT meant to be used by signing operations before adding signature time
  */
 public class NfcOperationActivity extends BaseNfcActivity {
 
     public static final String EXTRA_REQUIRED_INPUT = "required_input";
+    public static final String EXTRA_CRYPTO_INPUT = "crypto_input";
 
     // passthrough for OpenPgpService
     public static final String EXTRA_SERVICE_INTENT = "data";
 
-    public static final String RESULT_DATA = "result_data";
+    public static final String RESULT_CRYPTO_INPUT = "result_data";
 
     public ViewAnimator vAnimator;
     public TextView vErrorText;
@@ -67,6 +71,15 @@ public class NfcOperationActivity extends BaseNfcActivity {
 
         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
 
+        mInputParcel = getIntent().getParcelableExtra(EXTRA_CRYPTO_INPUT);
+
+        if (mInputParcel == null) {
+            // for compatibility when used from OpenPgpService
+            // (or any place other than CryptoOperationHelper)
+            // NOTE: This CryptoInputParcel cannot be used for signing without adding signature time
+            mInputParcel = new CryptoInputParcel();
+        }
+
         setTitle(R.string.nfc_text);
 
         vAnimator = (ViewAnimator) findViewById(R.id.view_animator);
@@ -112,8 +125,6 @@ public class NfcOperationActivity extends BaseNfcActivity {
     @Override
     protected void doNfcInBackground() throws IOException {
 
-        mInputParcel = new CryptoInputParcel(mRequiredInput.mSignatureTime);
-
         switch (mRequiredInput.mType) {
             case NFC_DECRYPT: {
                 for (int i = 0; i < mRequiredInput.mInputData.length; i++) {
@@ -124,6 +135,9 @@ public class NfcOperationActivity extends BaseNfcActivity {
                 break;
             }
             case NFC_SIGN: {
+                if (mInputParcel.getSignatureTime() == null) {
+                    mInputParcel.addSignatureTime(new Date());
+                }
                 for (int i = 0; i < mRequiredInput.mInputData.length; i++) {
                     byte[] hash = mRequiredInput.mInputData[i];
                     int algo = mRequiredInput.mSignAlgos[i];
@@ -218,11 +232,16 @@ public class NfcOperationActivity extends BaseNfcActivity {
     @Override
     protected void onNfcPostExecute() throws IOException {
         if (mServiceIntent != null) {
+            // if we're triggered by OpenPgpService
             CryptoInputParcelCacheService.addCryptoInputParcel(this, mServiceIntent, mInputParcel);
+            mServiceIntent.putExtra(EXTRA_CRYPTO_INPUT,
+                    getIntent().getParcelableExtra(EXTRA_CRYPTO_INPUT));
             setResult(RESULT_OK, mServiceIntent);
         } else {
             Intent result = new Intent();
-            result.putExtra(NfcOperationActivity.RESULT_DATA, mInputParcel);
+            result.putExtra(RESULT_CRYPTO_INPUT, mInputParcel);
+            // send back the CryptoInputParcel we receive, to conform with the pattern in
+            // CryptoOperationHelper
             setResult(RESULT_OK, result);
         }
 
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/PassphraseDialogActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/PassphraseDialogActivity.java
index 004d1d127..8b482584d 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/PassphraseDialogActivity.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/PassphraseDialogActivity.java
@@ -66,17 +66,22 @@ import org.sufficientlysecure.keychain.util.Preferences;
 /**
  * We can not directly create a dialog on the application context.
  * This activity encapsulates a DialogFragment to emulate a dialog.
+ * NOTE: If no CryptoInputParcel is passed via EXTRA_CRYPTO_INPUT, the CryptoInputParcel is created
+ * internally and is NOT meant to be used by signing operations before adding a signature time
  */
 public class PassphraseDialogActivity extends FragmentActivity {
     public static final String RESULT_CRYPTO_INPUT = "result_data";
 
     public static final String EXTRA_REQUIRED_INPUT = "required_input";
     public static final String EXTRA_SUBKEY_ID = "secret_key_id";
+    public static final String EXTRA_CRYPTO_INPUT = "crypto_input";
 
     // special extra for OpenPgpService
     public static final String EXTRA_SERVICE_INTENT = "data";
     private long mSubKeyId;
 
+    private CryptoInputParcel mCryptoInputParcel;
+
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -90,6 +95,15 @@ public class PassphraseDialogActivity extends FragmentActivity {
             );
         }
 
+        mCryptoInputParcel = getIntent().getParcelableExtra(EXTRA_CRYPTO_INPUT);
+
+        if (mCryptoInputParcel == null) {
+            // not all usages of PassphraseActivity are from CryptoInputOperation
+            // NOTE: This CryptoInputParcel cannot be used for signing operations without setting
+            // signature time
+            mCryptoInputParcel = new CryptoInputParcel();
+        }
+
         // this activity itself has no content view (see manifest)
 
         if (getIntent().hasExtra(EXTRA_SUBKEY_ID)) {
@@ -113,7 +127,8 @@ public class PassphraseDialogActivity extends FragmentActivity {
                                 SecretKeyType.PASSPHRASE_EMPTY) {
                             // also return passphrase back to activity
                             Intent returnIntent = new Intent();
-                            returnIntent.putExtra(RESULT_CRYPTO_INPUT, new CryptoInputParcel(new Passphrase("")));
+                            mCryptoInputParcel.mPassphrase = new Passphrase("");
+                            returnIntent.putExtra(RESULT_CRYPTO_INPUT, mCryptoInputParcel);
                             setResult(RESULT_OK, returnIntent);
                             finish();
                             return;
@@ -330,11 +345,16 @@ public class PassphraseDialogActivity extends FragmentActivity {
                 public void onClick(View v) {
                     final Passphrase passphrase = new Passphrase(mPassphraseEditText);
 
+                    CryptoInputParcel cryptoInputParcel =
+                            ((PassphraseDialogActivity) getActivity()).mCryptoInputParcel;
+
                     // Early breakout if we are dealing with a symmetric key
                     if (mSecretRing == null) {
-                        PassphraseCacheService.addCachedPassphrase(getActivity(),
-                                Constants.key.symmetric, Constants.key.symmetric, passphrase,
-                                getString(R.string.passp_cache_notif_pwd));
+                        if (cryptoInputParcel.mCachePassphrase) {
+                            PassphraseCacheService.addCachedPassphrase(getActivity(),
+                                    Constants.key.symmetric, Constants.key.symmetric, passphrase,
+                                    getString(R.string.passp_cache_notif_pwd));
+                        }
 
                         finishCaching(passphrase);
                         return;
@@ -387,15 +407,24 @@ public class PassphraseDialogActivity extends FragmentActivity {
                                 return;
                             }
 
-                            // cache the new passphrase
-                            Log.d(Constants.TAG, "Everything okay! Caching entered passphrase");
+                            // cache the new passphrase as specified in CryptoInputParcel
+                            Log.d(Constants.TAG, "Everything okay!");
 
-                            try {
-                                PassphraseCacheService.addCachedPassphrase(getActivity(),
-                                        mSecretRing.getMasterKeyId(), mSubKeyId, passphrase,
-                                        mSecretRing.getPrimaryUserIdWithFallback());
-                            } catch (PgpKeyNotFoundException e) {
-                                Log.e(Constants.TAG, "adding of a passphrase failed", e);
+                            CryptoInputParcel cryptoInputParcel
+                                    = ((PassphraseDialogActivity) getActivity()).mCryptoInputParcel;
+
+                            if (cryptoInputParcel.mCachePassphrase) {
+                                Log.d(Constants.TAG, "Caching entered passphrase");
+
+                                try {
+                                    PassphraseCacheService.addCachedPassphrase(getActivity(),
+                                            mSecretRing.getMasterKeyId(), mSubKeyId, passphrase,
+                                            mSecretRing.getPrimaryUserIdWithFallback());
+                                } catch (PgpKeyNotFoundException e) {
+                                    Log.e(Constants.TAG, "adding of a passphrase failed", e);
+                                }
+                            } else {
+                                Log.d(Constants.TAG, "Not caching entered passphrase!");
                             }
 
                             finishCaching(passphrase);
@@ -411,9 +440,12 @@ public class PassphraseDialogActivity extends FragmentActivity {
                 return;
             }
 
-            CryptoInputParcel inputParcel = new CryptoInputParcel(null, passphrase);
+            CryptoInputParcel inputParcel =
+                    ((PassphraseDialogActivity) getActivity()).mCryptoInputParcel;
+            inputParcel.mPassphrase = passphrase;
             if (mServiceIntent != null) {
-                CryptoInputParcelCacheService.addCryptoInputParcel(getActivity(), mServiceIntent, inputParcel);
+                CryptoInputParcelCacheService.addCryptoInputParcel(getActivity(), mServiceIntent,
+                        inputParcel);
                 getActivity().setResult(RESULT_OK, mServiceIntent);
             } else {
                 // also return passphrase back to activity
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/RetryUploadDialogActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/RetryUploadDialogActivity.java
new file mode 100644
index 000000000..85f2096db
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/RetryUploadDialogActivity.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2013-2015 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2015 Vincent Breitmoser <v.breitmoser@mugenguild.com>
+ * Copyright (C) 2015 Adithya Abraham Philip <adithyaphilip@gmail.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.ui;
+
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import android.view.ContextThemeWrapper;
+
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.ui.dialog.CustomAlertDialogBuilder;
+
+public class RetryUploadDialogActivity extends FragmentActivity {
+
+    public static final String EXTRA_CRYPTO_INPUT = "extra_crypto_input";
+
+    public static final String RESULT_CRYPTO_INPUT = "result_crypto_input";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        UploadRetryDialogFragment.newInstance().show(getSupportFragmentManager(),
+                "uploadRetryDialog");
+    }
+
+    public static class UploadRetryDialogFragment extends DialogFragment {
+        public static UploadRetryDialogFragment newInstance() {
+            return new UploadRetryDialogFragment();
+        }
+
+        @NonNull
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+
+            ContextThemeWrapper theme = new ContextThemeWrapper(getActivity(),
+                    R.style.Theme_AppCompat_Light_Dialog);
+
+            CustomAlertDialogBuilder dialogBuilder = new CustomAlertDialogBuilder(theme);
+            dialogBuilder.setTitle(R.string.retry_up_dialog_title);
+            dialogBuilder.setMessage(R.string.retry_up_dialog_message);
+
+            dialogBuilder.setNegativeButton(R.string.retry_up_dialog_btn_cancel,
+                    new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                    getActivity().setResult(RESULT_CANCELED);
+                    getActivity().finish();
+                }
+            });
+
+            dialogBuilder.setPositiveButton(R.string.retry_up_dialog_btn_reupload,
+                    new DialogInterface.OnClickListener() {
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                    Intent intent = new Intent();
+                    intent.putExtra(RESULT_CRYPTO_INPUT, getActivity()
+                            .getIntent().getParcelableExtra(EXTRA_CRYPTO_INPUT));
+                    getActivity().setResult(RESULT_OK, intent);
+                    getActivity().finish();
+                }
+            });
+
+            return dialogBuilder.show();
+        }
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java
index 9ed46d517..938dbc9f2 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java
@@ -31,8 +31,6 @@ import android.os.AsyncTask;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
-import android.os.Message;
-import android.os.Messenger;
 import android.provider.ContactsContract;
 import android.support.v4.app.ActivityCompat;
 import android.support.v4.app.FragmentManager;
@@ -52,7 +50,9 @@ import android.widget.ImageView;
 import android.widget.RelativeLayout;
 import android.widget.TextView;
 import android.widget.Toast;
+
 import com.getbase.floatingactionbutton.FloatingActionButton;
+
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
 import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
@@ -65,10 +65,8 @@ import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
 import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
-import org.sufficientlysecure.keychain.service.ServiceProgressHandler.MessageStatus;
 import org.sufficientlysecure.keychain.ui.base.BaseNfcActivity;
 import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
-import org.sufficientlysecure.keychain.ui.dialog.DeleteKeyDialogFragment;
 import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State;
@@ -85,7 +83,6 @@ import org.sufficientlysecure.keychain.util.Preferences;
 import java.io.IOException;
 import java.util.ArrayList;
 
-
 public class ViewKeyActivity extends BaseNfcActivity implements
         LoaderManager.LoaderCallbacks<Cursor>,
         CryptoOperationHelper.Callback<ImportKeyringParcel, ImportKeyResult> {
@@ -97,6 +94,7 @@ public class ViewKeyActivity extends BaseNfcActivity implements
     static final int REQUEST_QR_FINGERPRINT = 1;
     static final int REQUEST_BACKUP = 2;
     static final int REQUEST_CERTIFY = 3;
+    static final int REQUEST_DELETE = 4;
 
     public static final String EXTRA_DISPLAY_RESULT = "display_result";
 
@@ -419,27 +417,18 @@ public class ViewKeyActivity extends BaseNfcActivity implements
     }
 
     private void deleteKey() {
-        new Handler().post(new Runnable() {
-           @Override
-           public void run() {
-               // Message is received after key is deleted
-               Handler returnHandler = new Handler() {
-                   @Override
-                   public void handleMessage(Message message) {
-                       if (message.arg1 == MessageStatus.OKAY.ordinal()) {
-                           setResult(RESULT_CANCELED);
-                           finish();
-                       }
-                   }
-               };
-
-               // Create a new Messenger for the communication back
-               Messenger messenger = new Messenger(returnHandler);
-               DeleteKeyDialogFragment deleteKeyDialog = DeleteKeyDialogFragment.newInstance(messenger,
-                       new long[]{ mMasterKeyId });
-               deleteKeyDialog.show(getSupportFragmentManager(), "deleteKeyDialog");
-           }
-       });
+        Intent deleteIntent = new Intent(this, DeleteKeyDialogActivity.class);
+
+        deleteIntent.putExtra(DeleteKeyDialogActivity.EXTRA_DELETE_MASTER_KEY_IDS,
+                new long[]{mMasterKeyId});
+        deleteIntent.putExtra(DeleteKeyDialogActivity.EXTRA_HAS_SECRET, mIsSecret);
+        if (mIsSecret) {
+            // for upload in case key is secret
+            deleteIntent.putExtra(DeleteKeyDialogActivity.EXTRA_KEYSERVER,
+                    Preferences.getPreferences(this).getPreferredKeyserver());
+        }
+
+        startActivityForResult(deleteIntent, REQUEST_DELETE);
     }
 
     @Override
@@ -487,6 +476,12 @@ public class ViewKeyActivity extends BaseNfcActivity implements
                 }
                 return;
             }
+
+            case REQUEST_DELETE: {
+                setResult(RESULT_OK, data);
+                finish();
+                return;
+            }
         }
 
         super.onActivityResult(requestCode, resultCode, data);
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysListCloudLoader.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysListCloudLoader.java
index adf46caf8..e77c92923 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysListCloudLoader.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/adapter/ImportKeysListCloudLoader.java
@@ -27,6 +27,7 @@ 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.service.input.CryptoInputParcel;
 import org.sufficientlysecure.keychain.service.input.RequiredInputParcel;
 import org.sufficientlysecure.keychain.util.Log;
 import org.sufficientlysecure.keychain.util.ParcelableProxy;
@@ -48,12 +49,13 @@ public class ImportKeysListCloudLoader
     private AsyncTaskResultWrapper<ArrayList<ImportKeysListEntry>> mEntryListWrapper;
 
     /**
-     * Pass a parcelableProxy to specify an explicit proxy, otherwise will fetch from preferences
+     * Searches a keyserver as specified in cloudPrefs, using an explicit proxy if passed
      *
-     * @param context
-     * @param serverQuery
-     * @param cloudPrefs
-     * @param parcelableProxy
+     * @param serverQuery     string to search on servers for. If is a fingerprint,
+     *                        will enforce fingerprint check
+     * @param cloudPrefs      contains keyserver to search on, whether to search on the keyserver,
+     *                        and whether to search keybase.io
+     * @param parcelableProxy explicit proxy to use. If null, will retrieve from preferences
      */
     public ImportKeysListCloudLoader(Context context, String serverQuery, Preferences.CloudSearchPrefs cloudPrefs,
                                      @Nullable ParcelableProxy parcelableProxy) {
@@ -121,7 +123,8 @@ public class ImportKeysListCloudLoader
                 // user needs to enable/install orbot
                 mEntryList.clear();
                 GetKeyResult pendingResult = new GetKeyResult(null,
-                        RequiredInputParcel.createOrbotRequiredOperation());
+                        RequiredInputParcel.createOrbotRequiredOperation(),
+                        new CryptoInputParcel());
                 mEntryListWrapper = new AsyncTaskResultWrapper<>(mEntryList, pendingResult);
                 return;
             }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationHelper.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationHelper.java
index 91ea969d7..b33128978 100644
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationHelper.java
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationHelper.java
@@ -40,6 +40,7 @@ import org.sufficientlysecure.keychain.service.input.RequiredInputParcel;
 import org.sufficientlysecure.keychain.ui.NfcOperationActivity;
 import org.sufficientlysecure.keychain.ui.OrbotRequiredDialogActivity;
 import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity;
+import org.sufficientlysecure.keychain.ui.RetryUploadDialogActivity;
 import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment;
 import org.sufficientlysecure.keychain.util.Log;
 
@@ -76,6 +77,7 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
     public static final int REQUEST_CODE_PASSPHRASE = 1;
     public static final int REQUEST_CODE_NFC = 2;
     public static final int REQUEST_CODE_ENABLE_ORBOT = 3;
+    public static final int REQUEST_CODE_RETRY_UPLOAD = 4;
 
     private Integer mProgressMessageResource;
 
@@ -118,18 +120,14 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
         Activity activity = mUseFragment ? mFragment.getActivity() : mActivity;
 
         switch (requiredInput.mType) {
-            // TODO: Verify that all started activities add to cryptoInputParcel if necessary (like OrbotRequiredDialogActivity)
-            // don't forget to set mRequestedCode!
+            // always use CryptoOperationHelper.startActivityForResult!
             case NFC_MOVE_KEY_TO_CARD:
             case NFC_DECRYPT:
             case NFC_SIGN: {
                 Intent intent = new Intent(activity, NfcOperationActivity.class);
                 intent.putExtra(NfcOperationActivity.EXTRA_REQUIRED_INPUT, requiredInput);
-                if (mUseFragment) {
-                    mFragment.startActivityForResult(intent, mId + REQUEST_CODE_NFC);
-                } else {
-                    activity.startActivityForResult(intent, mId + REQUEST_CODE_NFC);
-                }
+                intent.putExtra(NfcOperationActivity.EXTRA_CRYPTO_INPUT, cryptoInputParcel);
+                startActivityForResult(intent, REQUEST_CODE_NFC);
                 return;
             }
 
@@ -137,22 +135,22 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
             case PASSPHRASE_SYMMETRIC: {
                 Intent intent = new Intent(activity, PassphraseDialogActivity.class);
                 intent.putExtra(PassphraseDialogActivity.EXTRA_REQUIRED_INPUT, requiredInput);
-                if (mUseFragment) {
-                    mFragment.startActivityForResult(intent, mId + REQUEST_CODE_PASSPHRASE);
-                } else {
-                    activity.startActivityForResult(intent, mId + REQUEST_CODE_PASSPHRASE);
-                }
+                intent.putExtra(PassphraseDialogActivity.EXTRA_CRYPTO_INPUT, cryptoInputParcel);
+                startActivityForResult(intent, REQUEST_CODE_PASSPHRASE);
                 return;
             }
 
             case ENABLE_ORBOT: {
                 Intent intent = new Intent(activity, OrbotRequiredDialogActivity.class);
                 intent.putExtra(OrbotRequiredDialogActivity.EXTRA_CRYPTO_INPUT, cryptoInputParcel);
-                if (mUseFragment) {
-                    mFragment.startActivityForResult(intent, mId + REQUEST_CODE_ENABLE_ORBOT);
-                } else {
-                    activity.startActivityForResult(intent, mId + REQUEST_CODE_ENABLE_ORBOT);
-                }
+                startActivityForResult(intent, REQUEST_CODE_ENABLE_ORBOT);
+                return;
+            }
+
+            case UPLOAD_FAIL_RETRY: {
+                Intent intent = new Intent(activity, RetryUploadDialogActivity.class);
+                intent.putExtra(RetryUploadDialogActivity.EXTRA_CRYPTO_INPUT, cryptoInputParcel);
+                startActivityForResult(intent, REQUEST_CODE_RETRY_UPLOAD);
                 return;
             }
 
@@ -162,6 +160,14 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
         }
     }
 
+    protected void startActivityForResult(Intent intent, int requestCode) {
+        if (mUseFragment) {
+            mFragment.startActivityForResult(intent, mId + requestCode);
+        } else {
+            mActivity.startActivityForResult(intent, mId + requestCode);
+        }
+    }
+
     /**
      * Attempts the result of an activity started by this helper. Returns true if requestCode is
      * recognized, false otherwise.
@@ -174,6 +180,7 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
             // this wasn't meant for us to handle
             return false;
         }
+        Log.d(Constants.TAG, "handling activity result in OperationHelper");
         // filter out mId from requestCode
         requestCode ^= mId;
 
@@ -188,7 +195,6 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
                     CryptoInputParcel cryptoInput =
                             data.getParcelableExtra(PassphraseDialogActivity.RESULT_CRYPTO_INPUT);
                     cryptoOperation(cryptoInput);
-                    return true;
                 }
                 break;
             }
@@ -196,9 +202,8 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
             case REQUEST_CODE_NFC: {
                 if (resultCode == Activity.RESULT_OK && data != null) {
                     CryptoInputParcel cryptoInput =
-                            data.getParcelableExtra(NfcOperationActivity.RESULT_DATA);
+                            data.getParcelableExtra(NfcOperationActivity.RESULT_CRYPTO_INPUT);
                     cryptoOperation(cryptoInput);
-                    return true;
                 }
                 break;
             }
@@ -209,12 +214,22 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
                             data.getParcelableExtra(
                                     OrbotRequiredDialogActivity.RESULT_CRYPTO_INPUT);
                     cryptoOperation(cryptoInput);
-                    return true;
                 }
+                break;
+            }
+
+            case REQUEST_CODE_RETRY_UPLOAD: {
+                if (resultCode == Activity.RESULT_OK) {
+                    CryptoInputParcel cryptoInput =
+                            data.getParcelableExtra(
+                                    RetryUploadDialogActivity.RESULT_CRYPTO_INPUT);
+                    cryptoOperation(cryptoInput);
+                }
+                break;
             }
         }
 
-        return false;
+        return true;
     }
 
     protected void dismissProgress() {
@@ -271,7 +286,7 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
                     final OperationResult result =
                             returnData.getParcelable(OperationResult.EXTRA_RESULT);
 
-                    onHandleResult(result, cryptoInput);
+                    onHandleResult(result);
                 }
             }
 
@@ -301,15 +316,14 @@ public class CryptoOperationHelper<T extends Parcelable, S extends OperationResu
         cryptoOperation(new CryptoInputParcel());
     }
 
-    public void onHandleResult(OperationResult result, CryptoInputParcel oldCryptoInput) {
+    public void onHandleResult(OperationResult result) {
         Log.d(Constants.TAG, "Handling result in OperationHelper success: " + result.success());
 
         if (result instanceof InputPendingResult) {
             InputPendingResult pendingResult = (InputPendingResult) result;
             if (pendingResult.isPending()) {
-
                 RequiredInputParcel requiredInput = pendingResult.getRequiredInputParcel();
-                initiateInputActivity(requiredInput, oldCryptoInput);
+                initiateInputActivity(requiredInput, pendingResult.mCryptoInputParcel);
                 return;
             }
         }
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java
deleted file mode 100644
index e92f9f78d..000000000
--- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java
+++ /dev/null
@@ -1,211 +0,0 @@
-/*
- * Copyright (C) 2013-2014 Dominik Schürmann <dominik@dominikschuermann.de>
- *
- * 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.ui.dialog;
-
-import android.app.Dialog;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.os.Bundle;
-import android.os.Message;
-import android.os.Messenger;
-import android.os.RemoteException;
-import android.support.v4.app.DialogFragment;
-import android.support.v4.app.FragmentActivity;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.widget.TextView;
-
-import org.sufficientlysecure.keychain.Constants;
-import org.sufficientlysecure.keychain.R;
-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.KeyRings;
-import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.service.DeleteKeyringParcel;
-import org.sufficientlysecure.keychain.service.ServiceProgressHandler;
-import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
-import org.sufficientlysecure.keychain.util.Log;
-
-import java.util.HashMap;
-
-public class DeleteKeyDialogFragment extends DialogFragment
-        implements CryptoOperationHelper.Callback<DeleteKeyringParcel, DeleteResult> {
-    private static final String ARG_MESSENGER = "messenger";
-    private static final String ARG_DELETE_MASTER_KEY_IDS = "delete_master_key_ids";
-
-    public static final int MESSAGE_OKAY = 1;
-    public static final int MESSAGE_ERROR = 0;
-
-    private TextView mMainMessage;
-    private View mInflateView;
-
-    private Messenger mMessenger;
-
-    // for CryptoOperationHelper.Callback
-    private long[] mMasterKeyIds;
-    private boolean mHasSecret;
-    private CryptoOperationHelper<DeleteKeyringParcel, DeleteResult> mDeleteOpHelper;
-
-    /**
-     * Creates new instance of this delete file dialog fragment
-     */
-    public static DeleteKeyDialogFragment newInstance(Messenger messenger, long[] masterKeyIds) {
-        DeleteKeyDialogFragment frag = new DeleteKeyDialogFragment();
-        Bundle args = new Bundle();
-
-        args.putParcelable(ARG_MESSENGER, messenger);
-        args.putLongArray(ARG_DELETE_MASTER_KEY_IDS, masterKeyIds);
-
-        frag.setArguments(args);
-
-        return frag;
-    }
-
-    @Override
-    public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (mDeleteOpHelper != null) {
-            mDeleteOpHelper.handleActivityResult(requestCode, resultCode, data);
-        }
-        super.onActivityResult(requestCode, resultCode, data);
-    }
-
-    @Override
-    public Dialog onCreateDialog(Bundle savedInstanceState) {
-        final FragmentActivity activity = getActivity();
-        mMessenger = getArguments().getParcelable(ARG_MESSENGER);
-
-        final long[] masterKeyIds = getArguments().getLongArray(ARG_DELETE_MASTER_KEY_IDS);
-
-        CustomAlertDialogBuilder builder = new CustomAlertDialogBuilder(activity);
-
-        // Setup custom View to display in AlertDialog
-        LayoutInflater inflater = activity.getLayoutInflater();
-        mInflateView = inflater.inflate(R.layout.view_key_delete_fragment, null);
-        builder.setView(mInflateView);
-
-        mMainMessage = (TextView) mInflateView.findViewById(R.id.mainMessage);
-
-        final boolean hasSecret;
-
-        // If only a single key has been selected
-        if (masterKeyIds.length == 1) {
-            long masterKeyId = masterKeyIds[0];
-
-            try {
-                HashMap<String, Object> data = new ProviderHelper(activity).getUnifiedData(
-                        masterKeyId, new String[]{
-                                KeyRings.USER_ID,
-                                KeyRings.HAS_ANY_SECRET
-                        }, new int[]{
-                                ProviderHelper.FIELD_TYPE_STRING,
-                                ProviderHelper.FIELD_TYPE_INTEGER
-                        }
-                );
-                String name;
-                KeyRing.UserId mainUserId = KeyRing.splitUserId((String) data.get(KeyRings.USER_ID));
-                if (mainUserId.name != null) {
-                    name = mainUserId.name;
-                } else {
-                    name = getString(R.string.user_id_no_name);
-                }
-                hasSecret = ((Long) data.get(KeyRings.HAS_ANY_SECRET)) == 1;
-
-                if (hasSecret) {
-                    // show title only for secret key deletions,
-                    // see http://www.google.com/design/spec/components/dialogs.html#dialogs-behavior
-                    builder.setTitle(getString(R.string.title_delete_secret_key, name));
-                    mMainMessage.setText(getString(R.string.secret_key_deletion_confirmation, name));
-                } else {
-                    mMainMessage.setText(getString(R.string.public_key_deletetion_confirmation, name));
-                }
-            } catch (ProviderHelper.NotFoundException e) {
-                dismiss();
-                return null;
-            }
-        } else {
-            mMainMessage.setText(R.string.key_deletion_confirmation_multi);
-            hasSecret = false;
-        }
-
-        builder.setPositiveButton(R.string.btn_delete, new DialogInterface.OnClickListener() {
-            @Override
-            public void onClick(DialogInterface dialog, int which) {
-
-                mMasterKeyIds = masterKeyIds;
-                mHasSecret = hasSecret;
-
-                mDeleteOpHelper = new CryptoOperationHelper<>
-                        (1, DeleteKeyDialogFragment.this, DeleteKeyDialogFragment.this,
-                                R.string.progress_deleting);
-                mDeleteOpHelper.cryptoOperation();
-                // do NOT dismiss here, it'll give
-                // OperationHelper a null fragmentManager
-                // dismiss();
-            }
-        });
-        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
-
-            @Override
-            public void onClick(DialogInterface dialog, int id) {
-                dismiss();
-            }
-        });
-
-        return builder.show();
-    }
-
-    @Override
-    public DeleteKeyringParcel createOperationInput() {
-        return new DeleteKeyringParcel(mMasterKeyIds, mHasSecret);
-    }
-
-    @Override
-    public void onCryptoOperationSuccess(DeleteResult result) {
-        handleResult(result);
-    }
-
-    @Override
-    public void onCryptoOperationCancelled() {
-
-    }
-
-    @Override
-    public void onCryptoOperationError(DeleteResult result) {
-        handleResult(result);
-    }
-
-    @Override
-    public boolean onCryptoSetProgress(String msg, int progress, int max) {
-        return false;
-    }
-
-    public void handleResult(DeleteResult result) {
-        try {
-            Bundle data = new Bundle();
-            data.putParcelable(OperationResult.EXTRA_RESULT, result);
-            Message msg = Message.obtain();
-            msg.arg1 = ServiceProgressHandler.MessageStatus.OKAY.ordinal();
-            msg.setData(data);
-            mMessenger.send(msg);
-        } catch (RemoteException e) {
-            Log.e(Constants.TAG, "messenger error", e);
-        }
-        dismiss();
-    }
-}