Merge branch 'tobsbot-recycler-view'

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

@@ -25,14 +25,12 @@ import android.text.Spannable;
 import android.text.SpannableString;
 import android.text.SpannableStringBuilder;
 import android.text.style.BulletSpan;
-import android.text.style.ForegroundColorSpan;
 import android.text.style.StyleSpan;
 import android.view.View;
 import android.widget.TextView;
 
 import org.openintents.openpgp.util.OpenPgpApi;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.ui.SelectPublicKeyFragment;
 import org.sufficientlysecure.keychain.ui.base.BaseActivity;
 
 import java.util.ArrayList;

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

@@ -0,0 +1,282 @@
+/*
+ * Copyright (C) 2012-2014 Dominik Schürmann <dominik@dominikschuermann.de>
+ * Copyright (C) 2010-2014 Thialfihar <thi@thialfihar.org>
+ *
+ * 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.remote.ui;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.v4.app.LoaderManager;
+import android.support.v4.content.ContextCompat;
+import android.support.v4.content.CursorLoader;
+import android.support.v4.content.Loader;
+import android.support.v7.widget.LinearLayoutManager;
+import android.support.v7.widget.RecyclerView;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+import android.widget.LinearLayout;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+import org.openintents.openpgp.util.OpenPgpUtils;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
+import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
+import org.sufficientlysecure.keychain.remote.ui.adapter.SelectEncryptKeyAdapter;
+import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
+import org.sufficientlysecure.keychain.ui.util.recyclerview.RecyclerFragment;
+
+public class SelectPublicKeyFragment extends RecyclerFragment<SelectEncryptKeyAdapter>
+        implements TextWatcher, LoaderManager.LoaderCallbacks<Cursor> {
+    public static final String ARG_PRESELECTED_KEY_IDS = "preselected_key_ids";
+
+    private EditText mSearchView;
+    private long mSelectedMasterKeyIds[];
+    private String mQuery;
+
+    /**
+     * Creates new instance of this fragment
+     */
+    public static SelectPublicKeyFragment newInstance(long[] preselectedKeyIds) {
+        SelectPublicKeyFragment frag = new SelectPublicKeyFragment();
+        Bundle args = new Bundle();
+
+        args.putLongArray(ARG_PRESELECTED_KEY_IDS, preselectedKeyIds);
+        frag.setArguments(args);
+
+        return frag;
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        mSelectedMasterKeyIds = getArguments().getLongArray(ARG_PRESELECTED_KEY_IDS);
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        final Context context = getContext();
+        FrameLayout root = new FrameLayout(context);
+
+        LinearLayout progressContainer = new LinearLayout(context);
+        progressContainer.setId(INTERNAL_PROGRESS_CONTAINER_ID);
+        progressContainer.setOrientation(LinearLayout.VERTICAL);
+        progressContainer.setGravity(Gravity.CENTER);
+        progressContainer.setVisibility(View.GONE);
+
+        ProgressBar progressBar = new ProgressBar(context, null,
+                android.R.attr.progressBarStyleLarge);
+
+        progressContainer.addView(progressBar, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        root.addView(progressContainer, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+        FrameLayout listContainer = new FrameLayout(context);
+        listContainer.setId(INTERNAL_LIST_CONTAINER_ID);
+
+        TextView textView = new TextView(context);
+        textView.setId(INTERNAL_EMPTY_VIEW_ID);
+        textView.setGravity(Gravity.CENTER);
+
+        listContainer.addView(textView, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        LinearLayout innerListContainer = new LinearLayout(context);
+        innerListContainer.setOrientation(LinearLayout.VERTICAL);
+
+        mSearchView = new EditText(context);
+        mSearchView.setId(android.R.id.input);
+        mSearchView.setHint(R.string.menu_search);
+        mSearchView.setCompoundDrawablesWithIntrinsicBounds(
+                ContextCompat.getDrawable(
+                        context,
+                        R.drawable.ic_search_grey_24dp
+                ), null, null, null);
+
+        innerListContainer.addView(mSearchView, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT));
+
+        RecyclerView listView = new RecyclerView(context);
+        listView.setId(INTERNAL_LIST_VIEW_ID);
+
+        int padding = FormattingUtils.dpToPx(context, 8);
+        listView.setPadding(padding, 0, padding, 0);
+        listView.setClipToPadding(false);
+
+        innerListContainer.addView(listView, new LinearLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+        listContainer.addView(innerListContainer, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+        root.addView(listContainer, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+
+        root.setLayoutParams(new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
+
+        return root;
+    }
+
+    /**
+     * Define Adapter and Loader on create of Activity
+     */
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        // Give some text to display if there is no data. In a real
+        // application this would come from a resource.
+        setEmptyText(getString(R.string.list_empty));
+        mSearchView.addTextChangedListener(this);
+
+        setAdapter(new SelectEncryptKeyAdapter(getContext(), null));
+        setLayoutManager(new LinearLayoutManager(getContext()));
+
+        // Start out with a progress indicator.
+        hideList(false);
+
+        // Prepare the loader. Either re-connect with an existing one,
+        // or start a new one.
+        getLoaderManager().initLoader(0, null, this);
+    }
+
+    public long[] getSelectedMasterKeyIds() {
+        return getAdapter() != null ?
+                getAdapter().getMasterKeyIds() : new long[0];
+    }
+
+    public String[] getSelectedRawUserIds() {
+        return getAdapter() != null ?
+                getAdapter().getRawUserIds() : new String[0];
+    }
+
+    public OpenPgpUtils.UserId[] getSelectedUserIds() {
+        return getAdapter() != null ?
+                getAdapter().getUserIds() : new OpenPgpUtils.UserId[0];
+    }
+
+    @Override
+    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
+        Uri baseUri = KeyRings.buildUnifiedKeyRingsUri();
+
+        // These are the rows that we will retrieve.
+        String[] projection = new String[]{
+                KeyRings._ID,
+                KeyRings.MASTER_KEY_ID,
+                KeyRings.USER_ID,
+                KeyRings.IS_EXPIRED,
+                KeyRings.IS_REVOKED,
+                KeyRings.HAS_ENCRYPT,
+                KeyRings.VERIFIED,
+                KeyRings.HAS_DUPLICATE_USER_ID,
+                KeyRings.CREATION,
+        };
+
+        String inMasterKeyList = null;
+        if (mSelectedMasterKeyIds != null && mSelectedMasterKeyIds.length > 0) {
+            inMasterKeyList = Tables.KEYS + "." + KeyRings.MASTER_KEY_ID + " IN (";
+            for (int i = 0; i < mSelectedMasterKeyIds.length; ++i) {
+                if (i != 0) {
+                    inMasterKeyList += ", ";
+                }
+                inMasterKeyList += DatabaseUtils.sqlEscapeString("" + mSelectedMasterKeyIds[i]);
+            }
+            inMasterKeyList += ")";
+        }
+
+        String orderBy = KeyRings.USER_ID + " ASC";
+        if (inMasterKeyList != null) {
+            // sort by selected master keys
+            orderBy = inMasterKeyList + " DESC, " + orderBy;
+        }
+        String where = null;
+        String whereArgs[] = null;
+        if (mQuery != null) {
+            String[] words = mQuery.trim().split("\\s+");
+            whereArgs = new String[words.length];
+            for (int i = 0; i < words.length; ++i) {
+                if (where == null) {
+                    where = "";
+                } else {
+                    where += " AND ";
+                }
+                where += KeyRings.USER_ID + " LIKE ?";
+                whereArgs[i] = "%" + words[i] + "%";
+            }
+        }
+
+        // Now create and return a CursorLoader that will take care of
+        // creating a Cursor for the data being displayed.
+        return new CursorLoader(getActivity(), baseUri, projection, where, whereArgs, orderBy);
+    }
+
+    @Override
+    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
+        // Swap the new cursor in. (The framework will take care of closing the
+        // old cursor once we return.)
+        getAdapter().setQuery(mQuery);
+        getAdapter().swapCursor(SelectEncryptKeyAdapter.PublicKeyCursor.wrap(data));
+
+        // The list should now be shown.
+        if (isResumed()) {
+            showList(true);
+        } else {
+            showList(false);
+        }
+
+        // preselect given master keys
+        getAdapter().preselectMasterKeyIds(mSelectedMasterKeyIds);
+    }
+
+    @Override
+    public void onLoaderReset(Loader<Cursor> loader) {
+        // This is called when the last Cursor provided to onLoadFinished()
+        // above is about to be closed. We need to make sure we are no
+        // longer using it.
+        getAdapter().swapCursor(null);
+    }
+
+    @Override
+    public void beforeTextChanged(CharSequence charSequence, int i, int i2, int i3) {
+
+    }
+
+    @Override
+    public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) {
+
+    }
+
+    @Override
+    public void afterTextChanged(Editable editable) {
+        mQuery = !TextUtils.isEmpty(editable.toString()) ? editable.toString() : null;
+        getLoaderManager().restartLoader(0, null, this);
+    }
+}

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

@@ -39,7 +39,7 @@ public class SelectSignKeyIdActivity extends BaseActivity {
     public static final String EXTRA_USER_ID = OpenPgpApi.EXTRA_USER_ID;
     public static final String EXTRA_DATA = "data";
 
-    private static final int REQUEST_CODE_CREATE_KEY = 0x00008884;
+    protected static final int REQUEST_CODE_CREATE_KEY = 0x00008884;
 
     private String mPreferredUserId;
     private Intent mData;
@@ -58,13 +58,6 @@ public class SelectSignKeyIdActivity extends BaseActivity {
                     }
                 });
 
-        TextView createKeyButton = (TextView) findViewById(R.id.api_select_sign_key_create_key);
-        createKeyButton.setOnClickListener(new View.OnClickListener() {
-            @Override
-            public void onClick(View v) {
-                createKey(mPreferredUserId);
-            }
-        });
         TextView noneButton = (TextView) findViewById(R.id.api_select_sign_key_none);
         noneButton.setOnClickListener(new View.OnClickListener() {
             @Override
@@ -83,23 +76,13 @@ public class SelectSignKeyIdActivity extends BaseActivity {
         if (appUri == null) {
             Log.e(Constants.TAG, "Intent data missing. Should be Uri of app!");
             finish();
-            return;
         } else {
             Log.d(Constants.TAG, "uri: " + appUri);
-            startListFragments(savedInstanceState, appUri, mData);
+            startListFragments(savedInstanceState, appUri, mData, mPreferredUserId);
         }
     }
 
-    private void createKey(String userId) {
-        OpenPgpUtils.UserId userIdSplit = KeyRing.splitUserId(userId);
-
-        Intent intent = new Intent(this, CreateKeyActivity.class);
-        intent.putExtra(CreateKeyActivity.EXTRA_NAME, userIdSplit.name);
-        intent.putExtra(CreateKeyActivity.EXTRA_EMAIL, userIdSplit.email);
-        startActivityForResult(intent, REQUEST_CODE_CREATE_KEY);
-    }
-
-    private void startListFragments(Bundle savedInstanceState, Uri dataUri, Intent data) {
+    private void startListFragments(Bundle savedInstanceState, Uri dataUri, Intent data, String preferredUserId) {
         // However, if we're being restored from a previous state,
         // then we don't need to do anything and should return or else
         // we could end up with overlapping fragments.
@@ -108,7 +91,8 @@ public class SelectSignKeyIdActivity extends BaseActivity {
         }
 
         // Create an instance of the fragments
-        SelectSignKeyIdListFragment listFragment = SelectSignKeyIdListFragment.newInstance(dataUri, data);
+        SelectSignKeyIdListFragment listFragment = SelectSignKeyIdListFragment
+                .newInstance(dataUri, data, preferredUserId);
         // Add the fragment to the 'fragment_container' FrameLayout
         // NOTE: We use commitAllowingStateLoss() to prevent weird crashes!
         getSupportFragmentManager().beginTransaction()

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

@@ -19,7 +19,6 @@ package org.sufficientlysecure.keychain.remote.ui;
 
 
 import android.app.Activity;
-import android.content.Context;
 import android.content.Intent;
 import android.database.Cursor;
 import android.net.Uri;
@@ -27,42 +26,44 @@ import android.os.Bundle;
 import android.support.v4.app.LoaderManager;
 import android.support.v4.content.CursorLoader;
 import android.support.v4.content.Loader;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import android.widget.AdapterView;
-import android.widget.ListView;
+import android.support.v7.widget.LinearLayoutManager;
 
 import org.openintents.openpgp.util.OpenPgpApi;
+import org.openintents.openpgp.util.OpenPgpUtils;
 import org.sufficientlysecure.keychain.Constants;
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.compatibility.ListFragmentWorkaround;
+import org.sufficientlysecure.keychain.pgp.KeyRing;
 import org.sufficientlysecure.keychain.provider.ApiDataAccessObject;
 import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
-import org.sufficientlysecure.keychain.ui.adapter.SelectKeyCursorAdapter;
-import org.sufficientlysecure.keychain.ui.widget.FixedListView;
+import org.sufficientlysecure.keychain.remote.ui.adapter.SelectSignKeyAdapter;
+import org.sufficientlysecure.keychain.ui.CreateKeyActivity;
+import org.sufficientlysecure.keychain.ui.util.adapter.CursorAdapter;
+import org.sufficientlysecure.keychain.ui.util.recyclerview.RecyclerFragment;
 import org.sufficientlysecure.keychain.util.Log;
 
-public class SelectSignKeyIdListFragment extends ListFragmentWorkaround implements LoaderManager.LoaderCallbacks<Cursor> {
+public class SelectSignKeyIdListFragment extends RecyclerFragment<SelectSignKeyAdapter>
+        implements SelectSignKeyAdapter.SelectSignKeyListener, LoaderManager.LoaderCallbacks<Cursor> {
 
     private static final String ARG_DATA_URI = "uri";
+    private static final String ARG_PREF_UID = "pref_uid";
     public static final String ARG_DATA = "data";
 
-    private SelectKeyCursorAdapter mAdapter;
-    private ApiDataAccessObject mApiDao;
-
     private Uri mDataUri;
+    private Intent mResult;
+    private String mPrefUid;
+    private ApiDataAccessObject mApiDao;
 
     /**
      * Creates new instance of this fragment
      */
-    public static SelectSignKeyIdListFragment newInstance(Uri dataUri, Intent data) {
+    public static SelectSignKeyIdListFragment newInstance(Uri dataUri, Intent data, String preferredUserId) {
         SelectSignKeyIdListFragment frag = new SelectSignKeyIdListFragment();
         Bundle args = new Bundle();
 
         args.putParcelable(ARG_DATA_URI, dataUri);
         args.putParcelable(ARG_DATA, data);
+        args.putString(ARG_PREF_UID, preferredUserId);
 
         frag.setArguments(args);
 
@@ -72,33 +73,9 @@ public class SelectSignKeyIdListFragment extends ListFragmentWorkaround implemen
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-
         mApiDao = new ApiDataAccessObject(getActivity());
     }
 
-    @Override
-    public View onCreateView(LayoutInflater inflater, ViewGroup container,
-                             Bundle savedInstanceState) {
-        View layout = super.onCreateView(inflater, container,
-                savedInstanceState);
-        ListView lv = (ListView) layout.findViewById(android.R.id.list);
-        ViewGroup parent = (ViewGroup) lv.getParent();
-
-        /*
-         * http://stackoverflow.com/a/15880684
-         * Remove ListView and add FixedListView in its place.
-         * This is done here programatically to be still able to use the progressBar of ListFragment.
-         *
-         * We want FixedListView to be able to put this ListFragment inside a ScrollView
-         */
-        int lvIndex = parent.indexOfChild(lv);
-        parent.removeViewAt(lvIndex);
-        FixedListView newLv = new FixedListView(getActivity());
-        newLv.setId(android.R.id.list);
-        parent.addView(newLv, lvIndex, lv.getLayoutParams());
-        return layout;
-    }
-
     /**
      * Define Adapter and Loader on create of Activity
      */
@@ -106,36 +83,22 @@ public class SelectSignKeyIdListFragment extends ListFragmentWorkaround implemen
     public void onActivityCreated(Bundle savedInstanceState) {
         super.onActivityCreated(savedInstanceState);
 
+        mResult = getArguments().getParcelable(ARG_DATA);
+        mPrefUid = getArguments().getString(ARG_PREF_UID);
         mDataUri = getArguments().getParcelable(ARG_DATA_URI);
-        final Intent resultData = getArguments().getParcelable(ARG_DATA);
-
-        getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
-        getListView().setOnItemClickListener(new AdapterView.OnItemClickListener() {
-            @Override
-            public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
-                long masterKeyId = mAdapter.getMasterKeyId(position);
-
-                Uri allowedKeysUri = mDataUri.buildUpon().appendPath(KeychainContract.PATH_ALLOWED_KEYS).build();
-                Log.d(Constants.TAG, "allowedKeysUri: " + allowedKeysUri);
-                mApiDao.addAllowedKeyIdForApp(allowedKeysUri, masterKeyId);
-
-                resultData.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, masterKeyId);
-
-                getActivity().setResult(Activity.RESULT_OK, resultData);
-                getActivity().finish();
-            }
-        });
 
         // Give some text to display if there is no data. In a real
         // application this would come from a resource.
         setEmptyText(getString(R.string.list_empty));
 
-        mAdapter = new SecretKeyCursorAdapter(getActivity(), null, 0, getListView());
+        SelectSignKeyAdapter adapter = new SelectSignKeyAdapter(getContext(), null);
+        adapter.setListener(this);
 
-        setListAdapter(mAdapter);
+        setAdapter(adapter);
+        setLayoutManager(new LinearLayoutManager(getContext()));
 
         // Start out with a progress indicator.
-        setListShown(false);
+        hideList(false);
 
         // Prepare the loader. Either re-connect with an existing one,
         // or start a new one.
@@ -172,13 +135,13 @@ public class SelectSignKeyIdListFragment extends ListFragmentWorkaround implemen
     public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
         // Swap the new cursor in. (The framework will take care of closing the
         // old cursor once we return.)
-        mAdapter.swapCursor(data);
+        getAdapter().swapCursor(CursorAdapter.KeyCursor.wrap(data));
 
         // The list should now be shown.
         if (isResumed()) {
-            setListShown(true);
+            showList(true);
         } else {
-            setListShownNoAnimation(true);
+            showList(false);
         }
 
     }
@@ -188,35 +151,38 @@ public class SelectSignKeyIdListFragment extends ListFragmentWorkaround implemen
         // This is called when the last Cursor provided to onLoadFinished()
         // above is about to be closed. We need to make sure we are no
         // longer using it.
-        mAdapter.swapCursor(null);
+        getAdapter().swapCursor(null);
     }
 
-    private class SecretKeyCursorAdapter extends SelectKeyCursorAdapter {
-
-        public SecretKeyCursorAdapter(Context context, Cursor c, int flags, ListView listView) {
-            super(context, c, flags, listView);
-        }
-
-        @Override
-        protected void initIndex(Cursor cursor) {
-            super.initIndex(cursor);
-        }
-
-        @Override
-        public void bindView(View view, Context context, Cursor cursor) {
-            super.bindView(view, context, cursor);
-            ViewHolderItem h = (ViewHolderItem) view.getTag();
-
-            h.selected.setVisibility(View.GONE);
-
-            boolean enabled = false;
-            if ((Boolean) h.statusIcon.getTag()) {
-                h.statusIcon.setVisibility(View.GONE);
-                enabled = true;
-            }
-            h.setEnabled(enabled);
-        }
-
+    @Override
+    public void onDestroy() {
+        getAdapter().setListener(null);
+        super.onDestroy();
     }
 
+    @Override
+    public void onCreateKeyDummyClicked() {
+        OpenPgpUtils.UserId userIdSplit = KeyRing.splitUserId(mPrefUid);
+
+        Intent intent = new Intent(getActivity(), CreateKeyActivity.class);
+        intent.putExtra(CreateKeyActivity.EXTRA_NAME, userIdSplit.name);
+        intent.putExtra(CreateKeyActivity.EXTRA_EMAIL, userIdSplit.email);
+        getActivity().startActivityForResult(intent, SelectSignKeyIdActivity.REQUEST_CODE_CREATE_KEY);
+    }
+
+    @Override
+    public void onSelectKeyItemClicked(long masterKeyId) {
+        Uri allowedKeysUri = mDataUri.buildUpon()
+                .appendPath(KeychainContract.PATH_ALLOWED_KEYS)
+                .build();
+
+        mApiDao.addAllowedKeyIdForApp(allowedKeysUri, masterKeyId);
+        mResult.putExtra(OpenPgpApi.EXTRA_SIGN_KEY_ID, masterKeyId);
+
+        Log.d(Constants.TAG, "allowedKeyId: " + masterKeyId);
+        Log.d(Constants.TAG, "allowedKeysUri: " + allowedKeysUri);
+
+        getActivity().setResult(Activity.RESULT_OK, mResult);
+        getActivity().finish();
+    }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/adapter/SelectEncryptKeyAdapter.java

@@ -0,0 +1,310 @@
+package org.sufficientlysecure.keychain.remote.ui.adapter;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.widget.RecyclerView;
+import android.text.format.DateUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.CheckBox;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.openintents.openpgp.util.OpenPgpUtils;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.provider.KeychainContract;
+import org.sufficientlysecure.keychain.ui.adapter.KeyCursorAdapter;
+import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
+import org.sufficientlysecure.keychain.ui.util.Highlighter;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
+import org.sufficientlysecure.keychain.ui.util.adapter.CursorAdapter;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+public class SelectEncryptKeyAdapter extends KeyCursorAdapter<SelectEncryptKeyAdapter.PublicKeyCursor,
+        SelectEncryptKeyAdapter.EncryptKeyItemHolder> {
+
+    private ArrayList<Integer> mSelected;
+
+    public SelectEncryptKeyAdapter(Context context, PublicKeyCursor cursor) {
+        super(context, cursor);
+
+        mSelected = new ArrayList<>();
+    }
+
+    private boolean isSelected(int position) {
+        return mSelected.contains(position);
+    }
+
+    private void select(int position) {
+        if(!isSelected(position)) {
+            mSelected.add(position);
+            notifyItemChanged(position);
+        }
+    }
+
+    private void switchSelected(int position) {
+        int index = mSelected.indexOf(position);
+        if(index < 0) {
+            mSelected.add(position);
+        } else {
+            mSelected.remove(index);
+        }
+
+        notifyItemChanged(position);
+    }
+
+    public long[] getMasterKeyIds() {
+        long[] selected = new long[mSelected.size()];
+        for(int i = 0; i < selected.length; i++) {
+            int position = mSelected.get(i);
+            if(!moveCursor(position)) {
+                return selected;
+            }
+
+            selected[i] = getCursor().getKeyId();
+        }
+
+        return selected;
+    }
+
+    public void preselectMasterKeyIds(long[] keyIds) {
+        if(keyIds != null) {
+            int count = 0;
+            for(int i = 0; i < getItemCount(); i++) {
+                if(!moveCursor(i)) {
+                    continue;
+                }
+
+                long id = getCursor().getKeyId();
+                for(int l = 0; l < keyIds.length; l++) {
+                    if(id == keyIds[l]) {
+                        select(i); count ++;
+                        break;
+                    }
+                }
+
+                if(count >= keyIds.length) {
+                    return;
+                }
+            }
+        }
+    }
+
+    public String[] getRawUserIds() {
+        String[] selected = new String[mSelected.size()];
+        for(int i = 0; i < selected.length; i++) {
+            int position = mSelected.get(i);
+            if(!moveCursor(position)) {
+                return selected;
+            }
+
+            selected[i] = getCursor().getRawUserId();
+        }
+
+        return selected;
+    }
+
+    public OpenPgpUtils.UserId[] getUserIds() {
+        OpenPgpUtils.UserId[] selected = new OpenPgpUtils.UserId[mSelected.size()];
+        for(int i = 0; i < selected.length; i++) {
+            int position = mSelected.get(i);
+            if(!moveCursor(position)) {
+                return selected;
+            }
+
+            selected[i] = getCursor().getUserId();
+        }
+
+        return selected;
+    }
+
+    @Override
+    public void onContentChanged() {
+        mSelected.clear();
+        super.onContentChanged();
+    }
+
+    @Override
+    public void onBindViewHolder(EncryptKeyItemHolder holder, PublicKeyCursor cursor, String query) {
+        holder.bind(cursor, query, isSelected(holder.getAdapterPosition()));
+    }
+
+    @Override
+    public EncryptKeyItemHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        return new EncryptKeyItemHolder(LayoutInflater.from(parent.getContext())
+                .inflate(R.layout.select_encrypt_key_item, parent, false));
+    }
+
+    class EncryptKeyItemHolder extends RecyclerView.ViewHolder implements View.OnClickListener {
+        private TextView mUserIdText;
+        private TextView mUserIdRestText;
+        private TextView mCreationText;
+        private ImageView mStatusIcon;
+        private CheckBox mChecked;
+
+        public EncryptKeyItemHolder(View itemView) {
+            super(itemView);
+            itemView.setOnClickListener(this);
+
+            mUserIdText = (TextView) itemView.findViewById(R.id.select_key_item_name);
+            mUserIdRestText = (TextView) itemView.findViewById(R.id.select_key_item_email);
+            mCreationText = (TextView) itemView.findViewById(R.id.select_key_item_creation);
+            mStatusIcon = (ImageView) itemView.findViewById(R.id.select_key_item_status_icon);
+            mChecked = (CheckBox) itemView.findViewById(R.id.selected);
+        }
+
+        public void bind(PublicKeyCursor cursor, String query, boolean selected) {
+            Highlighter highlighter = new Highlighter(itemView.getContext(), query);
+            Context context = itemView.getContext();
+
+            { // set name and stuff, common to both key types
+                OpenPgpUtils.UserId userIdSplit = cursor.getUserId();
+                if (userIdSplit.name != null) {
+                    mUserIdText.setText(highlighter.highlight(userIdSplit.name));
+                } else {
+                    mUserIdText.setText(R.string.user_id_no_name);
+                }
+                if (userIdSplit.email != null) {
+                    mUserIdRestText.setText(highlighter.highlight(userIdSplit.email));
+                    mUserIdRestText.setVisibility(View.VISIBLE);
+                } else {
+                    mUserIdRestText.setVisibility(View.GONE);
+                }
+            }
+
+            boolean enabled;
+            { // set edit button and status, specific by key type. Note: order is important!
+                int textColor;
+                if (cursor.isRevoked()) {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            null,
+                            KeyFormattingUtils.State.REVOKED,
+                            R.color.key_flag_gray
+                    );
+
+                    mStatusIcon.setVisibility(View.VISIBLE);
+
+                    enabled = false;
+                    textColor = ContextCompat.getColor(context, R.color.key_flag_gray);
+                } else if (cursor.isExpired()) {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            null,
+                            KeyFormattingUtils.State.EXPIRED,
+                            R.color.key_flag_gray
+                    );
+
+                    mStatusIcon.setVisibility(View.VISIBLE);
+
+                    enabled = false;
+                    textColor = ContextCompat.getColor(context, R.color.key_flag_gray);
+                } else if (!cursor.hasEncrypt()) {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            KeyFormattingUtils.State.UNAVAILABLE
+                    );
+
+                    mStatusIcon.setVisibility(View.VISIBLE);
+
+                    enabled = false;
+                    textColor = ContextCompat.getColor(context, R.color.key_flag_gray);
+                } else if (cursor.isVerified()) {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            KeyFormattingUtils.State.VERIFIED
+                    );
+
+                    mStatusIcon.setVisibility(View.VISIBLE);
+
+                    enabled = true;
+                    textColor = FormattingUtils.getColorFromAttr(context, R.attr.colorText);
+                } else {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            KeyFormattingUtils.State.UNVERIFIED
+                    );
+
+                    mStatusIcon.setVisibility(View.VISIBLE);
+
+                    enabled = true;
+                    textColor = FormattingUtils.getColorFromAttr(context, R.attr.colorText);
+                }
+
+                mUserIdText.setTextColor(textColor);
+                mUserIdRestText.setTextColor(textColor);
+
+                if (cursor.hasDuplicate()) {
+                    String dateTime = DateUtils.formatDateTime(context,
+                            cursor.getCreationTime(),
+                            DateUtils.FORMAT_SHOW_DATE
+                                    | DateUtils.FORMAT_SHOW_TIME
+                                    | DateUtils.FORMAT_SHOW_YEAR
+                                    | DateUtils.FORMAT_ABBREV_MONTH);
+                    mCreationText.setText(context.getString(R.string.label_key_created,
+                            dateTime));
+                    mCreationText.setTextColor(textColor);
+                    mCreationText.setVisibility(View.VISIBLE);
+                } else {
+                    mCreationText.setVisibility(View.GONE);
+                }
+            }
+
+            itemView.setEnabled(enabled);
+            itemView.setClickable(enabled);
+            mChecked.setChecked(enabled && selected);
+
+        }
+
+        @Override
+        public void onClick(View v) {
+            switchSelected(getAdapterPosition());
+        }
+    }
+
+    public static class PublicKeyCursor extends CursorAdapter.KeyCursor {
+        public static final String[] PROJECTION;
+
+        static {
+            ArrayList<String> arr = new ArrayList<>();
+            arr.addAll(Arrays.asList(KeyCursor.PROJECTION));
+            arr.addAll(Arrays.asList(
+                    KeychainContract.KeyRings.HAS_ENCRYPT,
+                    KeychainContract.KeyRings.VERIFIED
+            ));
+
+            PROJECTION = arr.toArray(new String[arr.size()]);
+        }
+
+        public static PublicKeyCursor wrap(Cursor cursor) {
+            if (cursor != null) {
+                return new PublicKeyCursor(cursor);
+            } else {
+                return null;
+            }
+        }
+
+        private PublicKeyCursor(Cursor cursor) {
+            super(cursor);
+        }
+
+        public boolean hasEncrypt() {
+            int index = getColumnIndexOrThrow(KeychainContract.KeyRings.HAS_ENCRYPT);
+            return getInt(index) != 0;
+        }
+
+        public boolean isVerified() {
+            int index = getColumnIndexOrThrow(KeychainContract.KeyRings.VERIFIED);
+            return getInt(index) != 0;
+        }
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/remote/ui/adapter/SelectSignKeyAdapter.java

@@ -0,0 +1,205 @@
+package org.sufficientlysecure.keychain.remote.ui.adapter;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.widget.RecyclerView;
+import android.text.format.DateUtils;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+import android.widget.TextView;
+
+import org.openintents.openpgp.util.OpenPgpUtils;
+import org.sufficientlysecure.keychain.R;
+import org.sufficientlysecure.keychain.ui.adapter.KeyCursorAdapter;
+import org.sufficientlysecure.keychain.ui.util.FormattingUtils;
+import org.sufficientlysecure.keychain.ui.util.Highlighter;
+import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
+import org.sufficientlysecure.keychain.ui.util.adapter.CursorAdapter;
+
+public class SelectSignKeyAdapter extends KeyCursorAdapter<CursorAdapter.KeyCursor, RecyclerView.ViewHolder> {
+    private static final int VIEW_TYPE_KEY = 0;
+    private static final int VIEW_TYPE_DUMMY = 1;
+
+    private SelectSignKeyListener mListener;
+
+    public SelectSignKeyAdapter(Context context, Cursor cursor) {
+        super(context, KeyCursor.wrap(cursor));
+    }
+
+    public void setListener(SelectSignKeyListener listener) {
+        mListener = listener;
+    }
+
+    @Override
+    public int getItemCount() {
+        return super.getItemCount() + 1; // received items + 1 dummy key
+    }
+
+    @Override
+    public long getItemId(int pos) {
+        if(pos < super.getItemCount()) {
+            return super.getItemId(pos);
+        } else {
+            return RecyclerView.NO_ID;
+        }
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        return position == super.getItemCount() ?
+                VIEW_TYPE_DUMMY : VIEW_TYPE_KEY;
+    }
+
+    @Override
+    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+        switch (viewType) {
+            case VIEW_TYPE_KEY:
+                return new SignKeyItemHolder(LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.select_sign_key_item, parent, false));
+
+            case VIEW_TYPE_DUMMY:
+                return new DummyViewHolder(LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.select_dummy_key_item, parent, false));
+
+            default:
+                return null;
+        }
+
+    }
+
+    @Override
+    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
+        if(holder.getItemViewType() == VIEW_TYPE_KEY) {
+            super.onBindViewHolder(holder, position);
+        }
+    }
+
+    @Override
+    public void onBindViewHolder(RecyclerView.ViewHolder holder, KeyCursor cursor, String query) {
+        ((SignKeyItemHolder)holder).bind(cursor, query);
+    }
+
+    private class DummyViewHolder extends RecyclerView.ViewHolder
+            implements View.OnClickListener{
+
+        public DummyViewHolder(View itemView) {
+            super(itemView);
+            itemView.setClickable(true);
+            itemView.setOnClickListener(this);
+        }
+
+        @Override
+        public void onClick(View v) {
+            if (mListener != null) {
+                mListener.onCreateKeyDummyClicked();
+            }
+        }
+    }
+
+    private class SignKeyItemHolder extends RecyclerView.ViewHolder
+            implements View.OnClickListener {
+
+        private TextView mUserIdText;
+        private TextView mUserIdRestText;
+        private TextView mCreationText;
+        private ImageView mStatusIcon;
+
+        public SignKeyItemHolder(View itemView) {
+            super(itemView);
+            itemView.setClickable(true);
+            itemView.setOnClickListener(this);
+
+            mUserIdText = (TextView) itemView.findViewById(R.id.select_key_item_name);
+            mUserIdRestText = (TextView) itemView.findViewById(R.id.select_key_item_email);
+            mCreationText = (TextView) itemView.findViewById(R.id.select_key_item_creation);
+            mStatusIcon = (ImageView) itemView.findViewById(R.id.select_key_item_status_icon);
+        }
+
+        public void bind(KeyCursor cursor, String query) {
+            Highlighter highlighter = new Highlighter(itemView.getContext(), query);
+            Context context = itemView.getContext();
+
+            { // set name and stuff, common to both key types
+                OpenPgpUtils.UserId userIdSplit = cursor.getUserId();
+                if (userIdSplit.name != null) {
+                    mUserIdText.setText(highlighter.highlight(userIdSplit.name));
+                } else {
+                    mUserIdText.setText(R.string.user_id_no_name);
+                }
+                if (userIdSplit.email != null) {
+                    mUserIdRestText.setText(highlighter.highlight(userIdSplit.email));
+                    mUserIdRestText.setVisibility(View.VISIBLE);
+                } else {
+                    mUserIdRestText.setVisibility(View.GONE);
+                }
+            }
+
+            { // set edit button and status, specific by key type. Note: order is important!
+                int textColor;
+                if (cursor.isRevoked()) {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            null,
+                            KeyFormattingUtils.State.REVOKED,
+                            R.color.key_flag_gray
+                    );
+
+                    itemView.setEnabled(false);
+                    mStatusIcon.setVisibility(View.VISIBLE);
+                    textColor = ContextCompat.getColor(context, R.color.key_flag_gray);
+                } else if (cursor.isExpired()) {
+                    KeyFormattingUtils.setStatusImage(
+                            context,
+                            mStatusIcon,
+                            null,
+                            KeyFormattingUtils.State.EXPIRED,
+                            R.color.key_flag_gray
+                    );
+
+                    itemView.setEnabled(false);
+                    mStatusIcon.setVisibility(View.VISIBLE);
+                    textColor = ContextCompat.getColor(context, R.color.key_flag_gray);
+                } else {
+                    itemView.setEnabled(true);
+                    mStatusIcon.setVisibility(View.GONE);
+                    textColor = FormattingUtils.getColorFromAttr(context, R.attr.colorText);
+                }
+
+                mUserIdText.setTextColor(textColor);
+                mUserIdRestText.setTextColor(textColor);
+
+                if (cursor.hasDuplicate()) {
+                    String dateTime = DateUtils.formatDateTime(context,
+                            cursor.getCreationTime(),
+                            DateUtils.FORMAT_SHOW_DATE
+                                    | DateUtils.FORMAT_SHOW_TIME
+                                    | DateUtils.FORMAT_SHOW_YEAR
+                                    | DateUtils.FORMAT_ABBREV_MONTH);
+                    mCreationText.setText(context.getString(R.string.label_key_created,
+                            dateTime));
+                    mCreationText.setTextColor(textColor);
+                    mCreationText.setVisibility(View.VISIBLE);
+                } else {
+                    mCreationText.setVisibility(View.GONE);
+                }
+            }
+
+        }
+
+        @Override
+        public void onClick(View v) {
+            if (mListener != null) {
+                mListener.onSelectKeyItemClicked(getItemId());
+            }
+        }
+    }
+
+    public interface SelectSignKeyListener {
+        void onCreateKeyDummyClicked();
+        void onSelectKeyItemClicked(long masterKeyId);
+    }
+}