Rename folder structure from OpenPGP Keychain to OpenKeychain

10 files changed, 1723 insertions, 0 deletions

diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/BadImportKeyDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/BadImportKeyDialogFragment.java
new file mode 100644
index 000000000..20b70658c
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/BadImportKeyDialogFragment.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2012-2013 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.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import org.sufficientlysecure.keychain.R;
+
+public class BadImportKeyDialogFragment extends DialogFragment {
+    private static final String ARG_BAD_IMPORT = "bad_import";
+
+    /**
+     * Creates a new instance of this Bad Import Key DialogFragment
+     *
+     * @param bad
+     * @return
+     */
+    public static BadImportKeyDialogFragment newInstance(int bad) {
+        BadImportKeyDialogFragment frag = new BadImportKeyDialogFragment();
+        Bundle args = new Bundle();
+
+        args.putInt(ARG_BAD_IMPORT, bad);
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final FragmentActivity activity = getActivity();
+        final int badImport = getArguments().getInt(ARG_BAD_IMPORT);
+
+        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+        alert.setIcon(R.drawable.ic_dialog_alert_holo_light);
+        alert.setTitle(R.string.warning);
+        alert.setMessage(activity.getResources()
+                .getQuantityString(R.plurals.bad_keys_encountered, badImport, badImport));
+        alert.setPositiveButton(android.R.string.ok,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface dialog, int id) {
+                        dialog.cancel();
+                    }
+                });
+        alert.setCancelable(true);
+
+        return alert.create();
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/CreateKeyDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/CreateKeyDialogFragment.java
new file mode 100644
index 000000000..ad558a81e
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/CreateKeyDialogFragment.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright (C) 2012-2013 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.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.AdapterView;
+import android.widget.ArrayAdapter;
+import android.widget.Spinner;
+import org.sufficientlysecure.keychain.Id;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.util.Choice;
+
+import java.util.ArrayList;
+
+public class CreateKeyDialogFragment extends DialogFragment {
+
+    public interface OnAlgorithmSelectedListener {
+        public void onAlgorithmSelected(Choice algorithmChoice, int keySize);
+    }
+
+    private static final String ARG_EDITOR_CHILD_COUNT = "child_count";
+
+    private int mNewKeySize;
+    private Choice mNewKeyAlgorithmChoice;
+    private OnAlgorithmSelectedListener mAlgorithmSelectedListener;
+
+    public void setOnAlgorithmSelectedListener(OnAlgorithmSelectedListener listener) {
+        mAlgorithmSelectedListener = listener;
+    }
+
+    public static CreateKeyDialogFragment newInstance(int mEditorChildCount) {
+        CreateKeyDialogFragment frag = new CreateKeyDialogFragment();
+        Bundle args = new Bundle();
+
+        args.putInt(ARG_EDITOR_CHILD_COUNT, mEditorChildCount);
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final FragmentActivity context = getActivity();
+        final LayoutInflater mInflater;
+
+        final int childCount = getArguments().getInt(ARG_EDITOR_CHILD_COUNT);
+        mInflater = context.getLayoutInflater();
+
+        AlertDialog.Builder dialog = new AlertDialog.Builder(context);
+
+        View view = mInflater.inflate(R.layout.create_key_dialog, null);
+        dialog.setView(view);
+        dialog.setTitle(R.string.title_create_key);
+
+        boolean wouldBeMasterKey = (childCount == 0);
+
+        final Spinner algorithm = (Spinner) view.findViewById(R.id.create_key_algorithm);
+        ArrayList<Choice> choices = new ArrayList<Choice>();
+        choices.add(new Choice(Id.choice.algorithm.dsa, getResources().getString(
+                R.string.dsa)));
+        if (!wouldBeMasterKey) {
+            choices.add(new Choice(Id.choice.algorithm.elgamal, getResources().getString(
+                    R.string.elgamal)));
+        }
+
+        choices.add(new Choice(Id.choice.algorithm.rsa, getResources().getString(
+                R.string.rsa)));
+
+        ArrayAdapter<Choice> adapter = new ArrayAdapter<Choice>(context,
+                android.R.layout.simple_spinner_item, choices);
+        adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+        algorithm.setAdapter(adapter);
+        // make RSA the default
+        for (int i = 0; i < choices.size(); ++i) {
+            if (choices.get(i).getId() == Id.choice.algorithm.rsa) {
+                algorithm.setSelection(i);
+                break;
+            }
+        }
+
+        final Spinner keySize = (Spinner) view.findViewById(R.id.create_key_size);
+        ArrayAdapter<CharSequence> keySizeAdapter = ArrayAdapter.createFromResource(
+                context, R.array.key_size_spinner_values,
+                android.R.layout.simple_spinner_item);
+        keySizeAdapter
+                .setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);
+        keySize.setAdapter(keySizeAdapter);
+        keySize.setSelection(3); // Default to 4096 for the key length
+        dialog.setPositiveButton(android.R.string.ok,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface di, int id) {
+                        di.dismiss();
+                        try {
+                            final String selectedItem = (String) keySize.getSelectedItem();
+                            mNewKeySize = Integer.parseInt(selectedItem);
+                        } catch (NumberFormatException e) {
+                            mNewKeySize = 0;
+                        }
+
+                        mNewKeyAlgorithmChoice = (Choice) algorithm.getSelectedItem();
+                        mAlgorithmSelectedListener.onAlgorithmSelected(mNewKeyAlgorithmChoice, mNewKeySize);
+                    }
+                });
+
+        dialog.setCancelable(true);
+        dialog.setNegativeButton(android.R.string.cancel,
+                new DialogInterface.OnClickListener() {
+                    public void onClick(DialogInterface di, int id) {
+                        di.dismiss();
+                    }
+                });
+
+        final AlertDialog alertDialog = dialog.create();
+
+        final AdapterView.OnItemSelectedListener weakRsaListener = new AdapterView.OnItemSelectedListener() {
+            @Override
+            public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+                final Choice selectedAlgorithm = (Choice) algorithm.getSelectedItem();
+                final int selectedKeySize = Integer.parseInt((String) keySize.getSelectedItem());
+                final boolean isWeakRsa = (selectedAlgorithm.getId() == Id.choice.algorithm.rsa &&
+                                            selectedKeySize <= 1024);
+                alertDialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(!isWeakRsa);
+            }
+
+            @Override
+            public void onNothingSelected(AdapterView<?> parent) {
+            }
+        };
+
+        keySize.setOnItemSelectedListener(weakRsaListener);
+        algorithm.setOnItemSelectedListener(weakRsaListener);
+
+        return alertDialog;
+    }
+
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteFileDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteFileDialogFragment.java
new file mode 100644
index 000000000..b4c38184c
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteFileDialogFragment.java
@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2012-2013 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.AlertDialog;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Message;
+import android.os.Messenger;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import android.widget.Toast;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.service.KeychainIntentService;
+import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
+
+public class DeleteFileDialogFragment extends DialogFragment {
+    private static final String ARG_DELETE_FILE = "delete_file";
+
+    /**
+     * Creates new instance of this delete file dialog fragment
+     */
+    public static DeleteFileDialogFragment newInstance(String deleteFile) {
+        DeleteFileDialogFragment frag = new DeleteFileDialogFragment();
+        Bundle args = new Bundle();
+
+        args.putString(ARG_DELETE_FILE, deleteFile);
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final FragmentActivity activity = getActivity();
+
+        final String deleteFile = getArguments().getString(ARG_DELETE_FILE);
+
+        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+
+
+        alert.setIcon(R.drawable.ic_dialog_alert_holo_light);
+        alert.setTitle(R.string.warning);
+        alert.setMessage(this.getString(R.string.file_delete_confirmation, deleteFile));
+
+        alert.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+
+                // Send all information needed to service to edit key in other thread
+                Intent intent = new Intent(activity, KeychainIntentService.class);
+
+                // fill values for this action
+                Bundle data = new Bundle();
+
+                intent.setAction(KeychainIntentService.ACTION_DELETE_FILE_SECURELY);
+                data.putString(KeychainIntentService.DELETE_FILE, deleteFile);
+                intent.putExtra(KeychainIntentService.EXTRA_DATA, data);
+
+                ProgressDialogFragment deletingDialog = ProgressDialogFragment.newInstance(
+                        getString(R.string.progress_deleting_securely),
+                        ProgressDialog.STYLE_HORIZONTAL,
+                        false,
+                        null);
+
+                // Message is received after deleting is done in KeychainIntentService
+                KeychainIntentServiceHandler saveHandler =
+                        new KeychainIntentServiceHandler(activity, deletingDialog) {
+                    public void handleMessage(Message message) {
+                        // handle messages by standard KeychainIntentHandler first
+                        super.handleMessage(message);
+
+                        if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) {
+                            Toast.makeText(activity, R.string.file_delete_successful,
+                                    Toast.LENGTH_SHORT).show();
+                        }
+                    }
+                };
+
+                // Create a new Messenger for the communication back
+                Messenger messenger = new Messenger(saveHandler);
+                intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger);
+
+                // show progress dialog
+                deletingDialog.show(activity.getSupportFragmentManager(), "deletingDialog");
+
+                // start service with intent
+                activity.startService(intent);
+            }
+        });
+        alert.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+            }
+        });
+        alert.setCancelable(true);
+
+        return alert.create();
+    }
+}
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
new file mode 100644
index 000000000..72ea4c013
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java
@@ -0,0 +1,174 @@
+/*
+ * 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.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+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.CheckBox;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRingData;
+import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
+import org.sufficientlysecure.keychain.provider.KeychainDatabase;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.util.Log;
+
+import java.util.HashMap;
+
+public class DeleteKeyDialogFragment extends DialogFragment {
+    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 boolean mIsSingleSelection = false;
+
+    private TextView mMainMessage;
+    private CheckBox mCheckDeleteSecret;
+    private LinearLayout mDeleteSecretKeyView;
+    private View mInflateView;
+
+    private Messenger mMessenger;
+
+    /**
+     * 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);
+        //We don't need the key type
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    @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);
+
+        AlertDialog.Builder builder = new AlertDialog.Builder(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);
+
+        mDeleteSecretKeyView = (LinearLayout) mInflateView.findViewById(R.id.deleteSecretKeyView);
+        mMainMessage = (TextView) mInflateView.findViewById(R.id.mainMessage);
+        mCheckDeleteSecret = (CheckBox) mInflateView.findViewById(R.id.checkDeleteSecret);
+
+        builder.setTitle(R.string.warning);
+
+        // If only a single key has been selected
+        if (masterKeyIds.length == 1) {
+            mIsSingleSelection = true;
+
+            long masterKeyId = masterKeyIds[0];
+
+            HashMap<String, Object> data = ProviderHelper.getUnifiedData(activity, masterKeyId, new String[]{
+                    KeyRings.USER_ID,
+                    KeyRings.HAS_SECRET
+            }, new int[] { ProviderHelper.FIELD_TYPE_STRING, ProviderHelper.FIELD_TYPE_INTEGER });
+            String userId = (String) data.get(KeyRings.USER_ID);
+            boolean hasSecret = ((Long) data.get(KeyRings.HAS_SECRET)) == 1;
+
+            // Hide the Checkbox and TextView since this is a single selection,user will be notified through message
+            mDeleteSecretKeyView.setVisibility(View.GONE);
+            // Set message depending on which key it is.
+            mMainMessage.setText(getString(
+                    hasSecret ? R.string.secret_key_deletion_confirmation
+                              : R.string.public_key_deletetion_confirmation,
+                    userId));
+        } else {
+            mDeleteSecretKeyView.setVisibility(View.VISIBLE);
+            mMainMessage.setText(R.string.key_deletion_confirmation_multi);
+        }
+
+        builder.setIcon(R.drawable.ic_dialog_alert_holo_light);
+        builder.setPositiveButton(R.string.btn_delete, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int which) {
+
+                boolean success = false;
+                for(long masterKeyId : masterKeyIds) {
+                    int count = activity.getContentResolver().delete(
+                            KeyRingData.buildPublicKeyRingUri(Long.toString(masterKeyId)), null, null
+                        );
+                    success = count > 0;
+                }
+                if (success) {
+                    sendMessageToHandler(MESSAGE_OKAY, null);
+                } else {
+                    sendMessageToHandler(MESSAGE_ERROR, null);
+                }
+                dismiss();
+            }
+        });
+        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+            }
+        });
+
+        return builder.create();
+    }
+
+    /**
+     * Send message back to handler which is initialized in a activity
+     *
+     * @param what Message integer you want to send
+     */
+    private void sendMessageToHandler(Integer what, Bundle data) {
+        Message msg = Message.obtain();
+        msg.what = what;
+        if (data != null) {
+            msg.setData(data);
+        }
+        try {
+            mMessenger.send(msg);
+        } catch (RemoteException e) {
+            Log.w(Constants.TAG, "Exception sending message, Is handler present?", e);
+        } catch (NullPointerException e) {
+            Log.w(Constants.TAG, "Messenger is null!", e);
+        }
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/FileDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/FileDialogFragment.java
new file mode 100644
index 000000000..a4285c8e9
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/FileDialogFragment.java
@@ -0,0 +1,220 @@
+/*
+ * Copyright (C) 2012-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.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+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.view.LayoutInflater;
+import android.view.View;
+import android.widget.CheckBox;
+import android.widget.EditText;
+import android.widget.TextView;
+import com.beardedhen.androidbootstrap.BootstrapButton;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.helper.FileHelper;
+import org.sufficientlysecure.keychain.util.Log;
+
+public class FileDialogFragment extends DialogFragment {
+    private static final String ARG_MESSENGER = "messenger";
+    private static final String ARG_TITLE = "title";
+    private static final String ARG_MESSAGE = "message";
+    private static final String ARG_DEFAULT_FILE = "default_file";
+    private static final String ARG_CHECKBOX_TEXT = "checkbox_text";
+
+    public static final int MESSAGE_OKAY = 1;
+
+    public static final String MESSAGE_DATA_FILENAME = "filename";
+    public static final String MESSAGE_DATA_CHECKED = "checked";
+
+    private Messenger mMessenger;
+
+    private EditText mFilename;
+    private BootstrapButton mBrowse;
+    private CheckBox mCheckBox;
+    private TextView mMessageTextView;
+
+    private static final int REQUEST_CODE = 0x00007004;
+
+    /**
+     * Creates new instance of this file dialog fragment
+     */
+    public static FileDialogFragment newInstance(Messenger messenger, String title, String message,
+                                                 String defaultFile, String checkboxText) {
+        FileDialogFragment frag = new FileDialogFragment();
+        Bundle args = new Bundle();
+        args.putParcelable(ARG_MESSENGER, messenger);
+
+        args.putString(ARG_TITLE, title);
+        args.putString(ARG_MESSAGE, message);
+        args.putString(ARG_DEFAULT_FILE, defaultFile);
+        args.putString(ARG_CHECKBOX_TEXT, checkboxText);
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity activity = getActivity();
+
+        mMessenger = getArguments().getParcelable(ARG_MESSENGER);
+
+        String title = getArguments().getString(ARG_TITLE);
+        String message = getArguments().getString(ARG_MESSAGE);
+        String defaultFile = getArguments().getString(ARG_DEFAULT_FILE);
+        String checkboxText = getArguments().getString(ARG_CHECKBOX_TEXT);
+
+        LayoutInflater inflater = (LayoutInflater) activity
+                .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+        alert.setTitle(title);
+
+        View view = inflater.inflate(R.layout.file_dialog, null);
+
+        mMessageTextView = (TextView) view.findViewById(R.id.message);
+        mMessageTextView.setText(message);
+
+        mFilename = (EditText) view.findViewById(R.id.input);
+        mFilename.setText(defaultFile);
+        mBrowse = (BootstrapButton) view.findViewById(R.id.btn_browse);
+        mBrowse.setOnClickListener(new View.OnClickListener() {
+            public void onClick(View v) {
+                // only .asc or .gpg files
+                // setting it to text/plain prevents Cynaogenmod's file manager from selecting asc
+                // or gpg types!
+                FileHelper.openFile(FileDialogFragment.this, mFilename.getText().toString(), "*/*",
+                        REQUEST_CODE);
+            }
+        });
+
+        mCheckBox = (CheckBox) view.findViewById(R.id.checkbox);
+        if (checkboxText == null) {
+            mCheckBox.setEnabled(false);
+            mCheckBox.setVisibility(View.GONE);
+        } else {
+            mCheckBox.setEnabled(true);
+            mCheckBox.setVisibility(View.VISIBLE);
+            mCheckBox.setText(checkboxText);
+        }
+
+        alert.setView(view);
+
+        alert.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+
+                boolean checked = false;
+                if (mCheckBox.isEnabled()) {
+                    checked = mCheckBox.isChecked();
+                }
+
+                // return resulting data back to activity
+                Bundle data = new Bundle();
+                data.putString(MESSAGE_DATA_FILENAME, mFilename.getText().toString());
+                data.putBoolean(MESSAGE_DATA_CHECKED, checked);
+
+                sendMessageToHandler(MESSAGE_OKAY, data);
+            }
+        });
+
+        alert.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+            }
+        });
+        return alert.create();
+    }
+
+    /**
+     * Updates filename in dialog, normally called in onActivityResult in activity using the
+     * FileDialog
+     */
+    private void setFilename(String filename) {
+        AlertDialog dialog = (AlertDialog) getDialog();
+        EditText filenameEditText = (EditText) dialog.findViewById(R.id.input);
+
+        if (filenameEditText != null) {
+            filenameEditText.setText(filename);
+        }
+    }
+
+    @Override
+    public void onActivityResult(int requestCode, int resultCode, Intent data) {
+        switch (requestCode & 0xFFFF) {
+            case REQUEST_CODE: {
+                if (resultCode == Activity.RESULT_OK && data != null) {
+                    try {
+                        String path = data.getData().getPath();
+                        Log.d(Constants.TAG, "path=" + path);
+
+                        // set filename used in export/import dialogs
+                        setFilename(path);
+                    } catch (NullPointerException e) {
+                        Log.e(Constants.TAG, "Nullpointer while retrieving path!", e);
+                    }
+                }
+
+                break;
+            }
+
+            default:
+                super.onActivityResult(requestCode, resultCode, data);
+
+                break;
+        }
+    }
+
+    /**
+     * Send message back to handler which is initialized in a activity
+     *
+     * @param what Message integer you want to send
+     */
+    private void sendMessageToHandler(Integer what, Bundle data) {
+        Message msg = Message.obtain();
+        msg.what = what;
+        if (data != null) {
+            msg.setData(data);
+        }
+
+        try {
+            mMessenger.send(msg);
+        } catch (RemoteException e) {
+            Log.w(Constants.TAG, "Exception sending message, Is handler present?", e);
+        } catch (NullPointerException e) {
+            Log.w(Constants.TAG, "Messenger is null!", e);
+        }
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/PassphraseDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/PassphraseDialogFragment.java
new file mode 100644
index 000000000..a3feab959
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/PassphraseDialogFragment.java
@@ -0,0 +1,328 @@
+/*
+ * Copyright (C) 2012-2013 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.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnClickListener;
+import android.os.Bundle;
+import android.os.Handler;
+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.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.WindowManager.LayoutParams;
+import android.view.inputmethod.EditorInfo;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.TextView;
+import android.widget.TextView.OnEditorActionListener;
+import android.widget.Toast;
+import org.spongycastle.openpgp.PGPException;
+import org.spongycastle.openpgp.PGPPrivateKey;
+import org.spongycastle.openpgp.PGPSecretKey;
+import org.spongycastle.openpgp.operator.PBESecretKeyDecryptor;
+import org.spongycastle.openpgp.operator.jcajce.JcePBESecretKeyDecryptorBuilder;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.Id;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
+import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.service.PassphraseCacheService;
+import org.sufficientlysecure.keychain.util.Log;
+
+public class PassphraseDialogFragment extends DialogFragment implements OnEditorActionListener {
+    private static final String ARG_MESSENGER = "messenger";
+    private static final String ARG_SECRET_KEY_ID = "secret_key_id";
+
+    public static final int MESSAGE_OKAY = 1;
+    public static final int MESSAGE_CANCEL = 2;
+
+    public static final String MESSAGE_DATA_PASSPHRASE = "passphrase";
+
+    private Messenger mMessenger;
+    private EditText mPassphraseEditText;
+    private boolean mCanKB;
+
+    /**
+     * Shows passphrase dialog to cache a new passphrase the user enters for using it later for
+     * encryption. Based on mSecretKeyId it asks for a passphrase to open a private key or it asks
+     * for a symmetric passphrase
+     */
+    public static void show(FragmentActivity context, long keyId, Handler returnHandler) {
+        // Create a new Messenger for the communication back
+        Messenger messenger = new Messenger(returnHandler);
+
+        try {
+            PassphraseDialogFragment passphraseDialog = PassphraseDialogFragment.newInstance(context,
+                    messenger, keyId);
+
+            passphraseDialog.show(context.getSupportFragmentManager(), "passphraseDialog");
+        } catch (PgpGeneralException e) {
+            Log.d(Constants.TAG, "No passphrase for this secret key, encrypt directly!");
+            // send message to handler to start encryption directly
+            returnHandler.sendEmptyMessage(PassphraseDialogFragment.MESSAGE_OKAY);
+        }
+    }
+
+    /**
+     * Creates new instance of this dialog fragment
+     *
+     * @param secretKeyId secret key id you want to use
+     * @param messenger   to communicate back after caching the passphrase
+     * @return
+     * @throws PgpGeneralException
+     */
+    public static PassphraseDialogFragment newInstance(Context context, Messenger messenger,
+                                                       long secretKeyId) throws PgpGeneralException {
+        // check if secret key has a passphrase
+        if (!(secretKeyId == Id.key.symmetric || secretKeyId == Id.key.none)) {
+            if (!PassphraseCacheService.hasPassphrase(context, secretKeyId)) {
+                throw new PgpGeneralException("No passphrase! No passphrase dialog needed!");
+            }
+        }
+
+        PassphraseDialogFragment frag = new PassphraseDialogFragment();
+        Bundle args = new Bundle();
+        args.putLong(ARG_SECRET_KEY_ID, secretKeyId);
+        args.putParcelable(ARG_MESSENGER, messenger);
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity activity = getActivity();
+        final long secretKeyId = getArguments().getLong(ARG_SECRET_KEY_ID);
+        mMessenger = getArguments().getParcelable(ARG_MESSENGER);
+
+        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+
+        alert.setTitle(R.string.title_authentication);
+
+        final PGPSecretKey secretKey;
+
+        if (secretKeyId == Id.key.symmetric || secretKeyId == Id.key.none) {
+            secretKey = null;
+            alert.setMessage(R.string.passphrase_for_symmetric_encryption);
+        } else {
+            secretKey = ProviderHelper.getPGPSecretKeyRing(activity, secretKeyId).getSecretKey();
+
+            if (secretKey == null) {
+                alert.setTitle(R.string.title_key_not_found);
+                alert.setMessage(getString(R.string.key_not_found, secretKeyId));
+                alert.setPositiveButton(android.R.string.ok, new OnClickListener() {
+                    public void onClick(DialogInterface dialog, int which) {
+                        dismiss();
+                    }
+                });
+                alert.setCancelable(false);
+                mCanKB = false;
+                return alert.create();
+            }
+            String userId = PgpKeyHelper.getMainUserIdSafe(activity, secretKey);
+
+            Log.d(Constants.TAG, "User id: '" + userId + "'");
+            alert.setMessage(getString(R.string.passphrase_for, userId));
+        }
+
+        LayoutInflater inflater = activity.getLayoutInflater();
+        View view = inflater.inflate(R.layout.passphrase_dialog, null);
+        alert.setView(view);
+
+        mPassphraseEditText = (EditText) view.findViewById(R.id.passphrase_passphrase);
+
+        alert.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+                long curKeyIndex = 1;
+                boolean keyOK = true;
+                String passphrase = mPassphraseEditText.getText().toString();
+                long keyId;
+                PGPSecretKey clickSecretKey = secretKey;
+
+                if (clickSecretKey != null) {
+                    while (keyOK) {
+                        if (clickSecretKey != null) { // check again for loop
+                            try {
+                                PBESecretKeyDecryptor keyDecryptor = new JcePBESecretKeyDecryptorBuilder()
+                                        .setProvider(Constants.BOUNCY_CASTLE_PROVIDER_NAME).build(
+                                                passphrase.toCharArray());
+                                PGPPrivateKey testKey = clickSecretKey
+                                        .extractPrivateKey(keyDecryptor);
+                                if (testKey == null) {
+                                    if (!clickSecretKey.isMasterKey()) {
+                                        Toast.makeText(activity,
+                                                R.string.error_could_not_extract_private_key,
+                                                Toast.LENGTH_SHORT).show();
+
+                                        sendMessageToHandler(MESSAGE_CANCEL);
+                                        return;
+                                    } else {
+                                        clickSecretKey = PgpKeyHelper.getKeyNum(ProviderHelper
+                                                .getPGPSecretKeyRingWithKeyId(activity, secretKeyId),
+                                                curKeyIndex);
+                                        curKeyIndex++; // does post-increment work like C?
+                                        continue;
+                                    }
+                                } else {
+                                    keyOK = false;
+                                }
+                            } catch (PGPException e) {
+                                Toast.makeText(activity, R.string.wrong_passphrase,
+                                        Toast.LENGTH_SHORT).show();
+
+                                sendMessageToHandler(MESSAGE_CANCEL);
+                                return;
+                            }
+                        } else {
+                            Toast.makeText(activity, R.string.error_could_not_extract_private_key,
+                                    Toast.LENGTH_SHORT).show();
+
+                            sendMessageToHandler(MESSAGE_CANCEL);
+                            return; // ran out of keys to try
+                        }
+                    }
+                    keyId = secretKey.getKeyID();
+                } else {
+                    keyId = Id.key.symmetric;
+                }
+
+                // cache the new passphrase
+                Log.d(Constants.TAG, "Everything okay! Caching entered passphrase");
+                PassphraseCacheService.addCachedPassphrase(activity, keyId, passphrase);
+                if (!keyOK && clickSecretKey.getKeyID() != keyId) {
+                    PassphraseCacheService.addCachedPassphrase(activity, clickSecretKey.getKeyID(),
+                            passphrase);
+                }
+
+                // also return passphrase back to activity
+                Bundle data = new Bundle();
+                data.putString(MESSAGE_DATA_PASSPHRASE, passphrase);
+
+                sendMessageToHandler(MESSAGE_OKAY, data);
+            }
+        });
+
+        alert.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dialog.cancel();
+            }
+        });
+
+        mCanKB = true;
+        return alert.create();
+    }
+
+    @Override
+    public void onActivityCreated(Bundle arg0) {
+        super.onActivityCreated(arg0);
+        if (mCanKB) {
+            // request focus and open soft keyboard
+            mPassphraseEditText.requestFocus();
+            getDialog().getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+
+            mPassphraseEditText.setOnEditorActionListener(this);
+        }
+    }
+
+    @Override
+    public void onCancel(DialogInterface dialog) {
+        super.onCancel(dialog);
+
+        dismiss();
+        sendMessageToHandler(MESSAGE_CANCEL);
+    }
+
+    /**
+     * Associate the "done" button on the soft keyboard with the okay button in the view
+     */
+    @Override
+    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+        if (EditorInfo.IME_ACTION_DONE == actionId) {
+            AlertDialog dialog = ((AlertDialog) getDialog());
+            Button bt = dialog.getButton(AlertDialog.BUTTON_POSITIVE);
+
+            bt.performClick();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Send message back to handler which is initialized in a activity
+     *
+     * @param what Message integer you want to send
+     */
+    private void sendMessageToHandler(Integer what) {
+        Message msg = Message.obtain();
+        msg.what = what;
+
+        try {
+            mMessenger.send(msg);
+        } catch (RemoteException e) {
+            Log.w(Constants.TAG, "Exception sending message, Is handler present?", e);
+        } catch (NullPointerException e) {
+            Log.w(Constants.TAG, "Messenger is null!", e);
+        }
+    }
+
+    /**
+     * Send message back to handler which is initialized in a activity
+     *
+     * @param what Message integer you want to send
+     */
+    private void sendMessageToHandler(Integer what, Bundle data) {
+        Message msg = Message.obtain();
+        msg.what = what;
+        if (data != null) {
+            msg.setData(data);
+        }
+
+        try {
+            mMessenger.send(msg);
+        } catch (RemoteException e) {
+            Log.w(Constants.TAG, "Exception sending message, Is handler present?", e);
+        } catch (NullPointerException e) {
+            Log.w(Constants.TAG, "Messenger is null!", e);
+        }
+    }
+
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ProgressDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ProgressDialogFragment.java
new file mode 100644
index 000000000..132a2ce86
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ProgressDialogFragment.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2012-2013 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.Activity;
+import android.app.Dialog;
+import android.app.ProgressDialog;
+import android.content.DialogInterface;
+import android.content.DialogInterface.OnCancelListener;
+import android.content.DialogInterface.OnKeyListener;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import android.view.KeyEvent;
+import org.sufficientlysecure.keychain.R;
+
+public class ProgressDialogFragment extends DialogFragment {
+    private static final String ARG_MESSAGE = "message";
+    private static final String ARG_STYLE = "style";
+    private static final String ARG_CANCELABLE = "cancelable";
+
+    private OnCancelListener mOnCancelListener;
+
+    /**
+     * Creates new instance of this fragment
+     *
+     * @param message
+     * @param style
+     * @param cancelable
+     * @return
+     */
+    public static ProgressDialogFragment newInstance(String message, int style, boolean cancelable,
+                                                     OnCancelListener onCancelListener) {
+        ProgressDialogFragment frag = new ProgressDialogFragment();
+        Bundle args = new Bundle();
+        args.putString(ARG_MESSAGE, message);
+        args.putInt(ARG_STYLE, style);
+        args.putBoolean(ARG_CANCELABLE, cancelable);
+
+        frag.setArguments(args);
+        frag.mOnCancelListener = onCancelListener;
+
+        return frag;
+    }
+
+    /**
+     * Updates progress of dialog
+     *
+     * @param messageId
+     * @param progress
+     * @param max
+     */
+    public void setProgress(int messageId, int progress, int max) {
+        setProgress(getString(messageId), progress, max);
+    }
+
+    /**
+     * Updates progress of dialog
+     *
+     * @param progress
+     * @param max
+     */
+    public void setProgress(int progress, int max) {
+        ProgressDialog dialog = (ProgressDialog) getDialog();
+
+        dialog.setProgress(progress);
+        dialog.setMax(max);
+    }
+
+    /**
+     * Updates progress of dialog
+     *
+     * @param message
+     * @param progress
+     * @param max
+     */
+    public void setProgress(String message, int progress, int max) {
+        ProgressDialog dialog = (ProgressDialog) getDialog();
+
+        dialog.setMessage(message);
+        dialog.setProgress(progress);
+        dialog.setMax(max);
+    }
+
+    @Override
+    public void onCancel(DialogInterface dialog) {
+        super.onCancel(dialog);
+
+        if (this.mOnCancelListener != null) {
+            this.mOnCancelListener.onCancel(dialog);
+        }
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity activity = getActivity();
+
+        ProgressDialog dialog = new ProgressDialog(activity);
+        dialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
+        dialog.setCancelable(false);
+        dialog.setCanceledOnTouchOutside(false);
+
+        String message = getArguments().getString(ARG_MESSAGE);
+        int style = getArguments().getInt(ARG_STYLE);
+        boolean cancelable = getArguments().getBoolean(ARG_CANCELABLE);
+
+        dialog.setMessage(message);
+        dialog.setProgressStyle(style);
+
+        if (cancelable) {
+            dialog.setButton(DialogInterface.BUTTON_NEGATIVE,
+                    activity.getString(R.string.progress_cancel),
+                    new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int which) {
+                            dialog.cancel();
+                        }
+                    });
+        }
+
+        // Disable the back button
+        OnKeyListener keyListener = new OnKeyListener() {
+
+            @Override
+            public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
+                if (keyCode == KeyEvent.KEYCODE_BACK) {
+                    return true;
+                }
+                return false;
+            }
+
+        };
+        dialog.setOnKeyListener(keyListener);
+
+        return dialog;
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/SetPassphraseDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/SetPassphraseDialogFragment.java
new file mode 100644
index 000000000..ae61c1470
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/SetPassphraseDialogFragment.java
@@ -0,0 +1,186 @@
+/*
+ * Copyright (C) 2012-2013 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.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.os.Message;
+import android.os.Messenger;
+import android.os.RemoteException;
+import android.support.v4.app.DialogFragment;
+import android.view.KeyEvent;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.WindowManager.LayoutParams;
+import android.view.inputmethod.EditorInfo;
+import android.widget.Button;
+import android.widget.EditText;
+import android.widget.TextView;
+import android.widget.TextView.OnEditorActionListener;
+import android.widget.Toast;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.util.Log;
+
+public class SetPassphraseDialogFragment extends DialogFragment implements OnEditorActionListener {
+    private static final String ARG_MESSENGER = "messenger";
+    private static final String ARG_TITLE = "title";
+
+    public static final int MESSAGE_OKAY = 1;
+
+    public static final String MESSAGE_NEW_PASSPHRASE = "new_passphrase";
+
+    private Messenger mMessenger;
+    private EditText mPassphraseEditText;
+    private EditText mPassphraseAgainEditText;
+
+    /**
+     * Creates new instance of this dialog fragment
+     *
+     * @param title     title of dialog
+     * @param messenger to communicate back after setting the passphrase
+     * @return
+     */
+    public static SetPassphraseDialogFragment newInstance(Messenger messenger, int title) {
+        SetPassphraseDialogFragment frag = new SetPassphraseDialogFragment();
+        Bundle args = new Bundle();
+        args.putInt(ARG_TITLE, title);
+        args.putParcelable(ARG_MESSENGER, messenger);
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity activity = getActivity();
+
+        int title = getArguments().getInt(ARG_TITLE);
+        mMessenger = getArguments().getParcelable(ARG_MESSENGER);
+
+        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+
+        alert.setTitle(title);
+        alert.setMessage(R.string.enter_passphrase_twice);
+
+        LayoutInflater inflater = activity.getLayoutInflater();
+        View view = inflater.inflate(R.layout.passphrase_repeat_dialog, null);
+        alert.setView(view);
+
+        mPassphraseEditText = (EditText) view.findViewById(R.id.passphrase_passphrase);
+        mPassphraseAgainEditText = (EditText) view.findViewById(R.id.passphrase_passphrase_again);
+
+        alert.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+
+                String passphrase1 = mPassphraseEditText.getText().toString();
+                String passphrase2 = mPassphraseAgainEditText.getText().toString();
+                if (!passphrase1.equals(passphrase2)) {
+                    Toast.makeText(
+                            activity,
+                            getString(R.string.error_message,
+                                    getString(R.string.passphrases_do_not_match)), Toast.LENGTH_SHORT)
+                            .show();
+                    return;
+                }
+
+                if (passphrase1.equals("")) {
+                    Toast.makeText(
+                            activity,
+                            getString(R.string.error_message,
+                                    getString(R.string.passphrase_must_not_be_empty)),
+                            Toast.LENGTH_SHORT).show();
+                    return;
+                }
+
+                // return resulting data back to activity
+                Bundle data = new Bundle();
+                data.putString(MESSAGE_NEW_PASSPHRASE, passphrase1);
+
+                sendMessageToHandler(MESSAGE_OKAY, data);
+            }
+        });
+
+        alert.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+            }
+        });
+
+        return alert.create();
+    }
+
+    @Override
+    public void onActivityCreated(Bundle arg0) {
+        super.onActivityCreated(arg0);
+
+        // request focus and open soft keyboard
+        mPassphraseEditText.requestFocus();
+        getDialog().getWindow().setSoftInputMode(LayoutParams.SOFT_INPUT_STATE_VISIBLE);
+
+        mPassphraseAgainEditText.setOnEditorActionListener(this);
+    }
+
+    /**
+     * Associate the "done" button on the soft keyboard with the okay button in the view
+     */
+    @Override
+    public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
+        if (EditorInfo.IME_ACTION_DONE == actionId) {
+            AlertDialog dialog = ((AlertDialog) getDialog());
+            Button bt = dialog.getButton(AlertDialog.BUTTON_POSITIVE);
+
+            bt.performClick();
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Send message back to handler which is initialized in a activity
+     *
+     * @param what Message integer you want to send
+     */
+    private void sendMessageToHandler(Integer what, Bundle data) {
+        Message msg = Message.obtain();
+        msg.what = what;
+        if (data != null) {
+            msg.setData(data);
+        }
+
+        try {
+            mMessenger.send(msg);
+        } catch (RemoteException e) {
+            Log.w(Constants.TAG, "Exception sending message, Is handler present?", e);
+        } catch (NullPointerException e) {
+            Log.w(Constants.TAG, "Messenger is null!", e);
+        }
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ShareNfcDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ShareNfcDialogFragment.java
new file mode 100644
index 000000000..741530b1d
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ShareNfcDialogFragment.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2013 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.annotation.TargetApi;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.nfc.NfcAdapter;
+import android.os.Build;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.support.v4.app.DialogFragment;
+import android.support.v4.app.FragmentActivity;
+import org.sufficientlysecure.htmltextview.HtmlTextView;
+import org.sufficientlysecure.keychain.R;
+
+@TargetApi(Build.VERSION_CODES.JELLY_BEAN)
+public class ShareNfcDialogFragment extends DialogFragment {
+
+    /**
+     * Creates new instance of this fragment
+     */
+    public static ShareNfcDialogFragment newInstance() {
+        ShareNfcDialogFragment frag = new ShareNfcDialogFragment();
+
+        return frag;
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final FragmentActivity activity = getActivity();
+
+        AlertDialog.Builder alert = new AlertDialog.Builder(activity);
+
+        alert.setTitle(R.string.share_nfc_dialog);
+        alert.setCancelable(true);
+
+        alert.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(DialogInterface dialog, int id) {
+                dismiss();
+            }
+        });
+
+        HtmlTextView textView = new HtmlTextView(getActivity());
+        textView.setPadding(8, 8, 8, 8);
+        alert.setView(textView);
+
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN) {
+            textView.setText(getString(R.string.error) + ": "
+                    + getString(R.string.error_jelly_bean_needed));
+        } else {
+            // check if NFC Adapter is available
+            NfcAdapter nfcAdapter = NfcAdapter.getDefaultAdapter(getActivity());
+            if (nfcAdapter == null) {
+                textView.setText(getString(R.string.error) + ": "
+                        + getString(R.string.error_nfc_needed));
+            } else {
+                // nfc works...
+                textView.setHtmlFromRawResource(getActivity(), R.raw.nfc_beam_share);
+
+                alert.setNegativeButton(R.string.menu_beam_preferences,
+                        new DialogInterface.OnClickListener() {
+                            @Override
+                            public void onClick(DialogInterface dialog, int id) {
+                                Intent intentSettings = new Intent(
+                                        Settings.ACTION_NFCSHARING_SETTINGS);
+                                startActivity(intentSettings);
+                            }
+                        });
+            }
+        }
+
+        // no flickering when clicking textview for Android < 4
+        // aboutTextView.setTextColor(getResources().getColor(android.R.color.black));
+
+        return alert.create();
+    }
+}
diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ShareQrCodeDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ShareQrCodeDialogFragment.java
new file mode 100644
index 000000000..b6ff139df
--- /dev/null
+++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/ShareQrCodeDialogFragment.java
@@ -0,0 +1,212 @@
+/*
+ * Copyright (C) 2012-2013 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.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.v4.app.DialogFragment;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.TextView;
+import org.sufficientlysecure.keychain.Constants;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.pgp.PgpKeyHelper;
+import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.util.QrCodeUtils;
+
+import java.util.ArrayList;
+
+public class ShareQrCodeDialogFragment extends DialogFragment {
+    private static final String ARG_KEY_URI = "uri";
+    private static final String ARG_FINGERPRINT_ONLY = "fingerprint_only";
+
+    private ImageView mImage;
+    private TextView mText;
+
+    private boolean mFingerprintOnly;
+
+    private ArrayList<String> mContentList;
+    private int mCounter;
+
+    private static final int QR_CODE_SIZE = 1000;
+
+    /**
+     * Creates new instance of this dialog fragment
+     */
+    public static ShareQrCodeDialogFragment newInstance(Uri dataUri, boolean fingerprintOnly) {
+        ShareQrCodeDialogFragment frag = new ShareQrCodeDialogFragment();
+        Bundle args = new Bundle();
+        args.putParcelable(ARG_KEY_URI, dataUri);
+        args.putBoolean(ARG_FINGERPRINT_ONLY, fingerprintOnly);
+
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    /**
+     * Creates dialog
+     */
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        final Activity activity = getActivity();
+
+        Uri dataUri = getArguments().getParcelable(ARG_KEY_URI);
+        mFingerprintOnly = getArguments().getBoolean(ARG_FINGERPRINT_ONLY);
+
+        AlertDialog.Builder alert = new AlertDialog.Builder(getActivity());
+
+        alert.setTitle(R.string.share_qr_code_dialog_title);
+
+        LayoutInflater inflater = activity.getLayoutInflater();
+        View view = inflater.inflate(R.layout.share_qr_code_dialog, null);
+        alert.setView(view);
+
+        mImage = (ImageView) view.findViewById(R.id.share_qr_code_dialog_image);
+        mText = (TextView) view.findViewById(R.id.share_qr_code_dialog_text);
+
+        String content = null;
+        if (mFingerprintOnly) {
+            alert.setPositiveButton(R.string.btn_okay, null);
+
+            byte[] blob = (byte[]) ProviderHelper.getGenericData(
+                    getActivity(), KeyRings.buildUnifiedKeyRingUri(dataUri),
+                    KeyRings.FINGERPRINT, ProviderHelper.FIELD_TYPE_BLOB);
+            if(blob == null) {
+                // TODO error handling?!
+                return null;
+            }
+
+            String fingerprint = PgpKeyHelper.convertFingerprintToHex(blob);
+            mText.setText(getString(R.string.share_qr_code_dialog_fingerprint_text) + " " + fingerprint);
+            content = Constants.FINGERPRINT_SCHEME + ":" + fingerprint;
+            setQrCode(content);
+        } else {
+            mText.setText(R.string.share_qr_code_dialog_start);
+
+            // TODO works, but
+            long masterKeyId = ProviderHelper.getMasterKeyId(getActivity(), dataUri);
+            // get public keyring as ascii armored string
+            ArrayList<String> keyringArmored = ProviderHelper.getKeyRingsAsArmoredString(
+                    getActivity(), new long[] { masterKeyId });
+
+            // TODO: binary?
+
+            content = keyringArmored.get(0);
+
+            // OnClickListener are set in onResume to prevent automatic dismissing of Dialogs
+            // http://bit.ly/O5vfaR
+            alert.setPositiveButton(R.string.btn_next, null);
+            alert.setNegativeButton(android.R.string.cancel, null);
+
+            mContentList = splitString(content, 1000);
+
+            // start with first
+            mCounter = 0;
+            updatePartsQrCode();
+        }
+
+        return alert.create();
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        if (!mFingerprintOnly) {
+            AlertDialog alertDialog = (AlertDialog) getDialog();
+            final Button backButton = alertDialog.getButton(AlertDialog.BUTTON_NEGATIVE);
+            final Button nextButton = alertDialog.getButton(AlertDialog.BUTTON_POSITIVE);
+
+            backButton.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+                    if (mCounter > 0) {
+                        mCounter--;
+                        updatePartsQrCode();
+                        updateDialog(backButton, nextButton);
+                    } else {
+                        dismiss();
+                    }
+                }
+            });
+            nextButton.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    if (mCounter < mContentList.size() - 1) {
+                        mCounter++;
+                        updatePartsQrCode();
+                        updateDialog(backButton, nextButton);
+                    } else {
+                        dismiss();
+                    }
+                }
+            });
+        }
+    }
+
+    private void updatePartsQrCode() {
+        // Content: <counter>,<size>,<content>
+        setQrCode(mCounter + "," + mContentList.size() + "," + mContentList.get(mCounter));
+    }
+
+    private void setQrCode(String data) {
+        mImage.setImageBitmap(QrCodeUtils.getQRCodeBitmap(data, QR_CODE_SIZE));
+    }
+
+    private void updateDialog(Button backButton, Button nextButton) {
+        if (mCounter == 0) {
+            backButton.setText(android.R.string.cancel);
+        } else {
+            backButton.setText(R.string.btn_back);
+        }
+        if (mCounter == mContentList.size() - 1) {
+            nextButton.setText(android.R.string.ok);
+        } else {
+            nextButton.setText(R.string.btn_next);
+        }
+
+        mText.setText(getResources().getString(R.string.share_qr_code_dialog_progress,
+                mCounter + 1, mContentList.size()));
+    }
+
+    /**
+     * Split String by number of characters
+     *
+     * @param text
+     * @param size
+     * @return
+     */
+    private ArrayList<String> splitString(String text, int size) {
+        ArrayList<String> strings = new ArrayList<String>();
+        int index = 0;
+        while (index < text.length()) {
+            strings.add(text.substring(index, Math.min(index + size, text.length())));
+            index += size;
+        }
+
+        return strings;
+    }
+}