moparisthebest/open-keychain
1
0
Fork 0
mirror of https://github.com/moparisthebest/open-keychain synced 2024-11-16 05:45:04 -05:00
Code Issues Releases Wiki Activity

Import code, fix collision of key spinner with other loaders

Browse Source
This commit is contained in:
Dominik Schürmann 2014-10-04 15:42:23 +02:00
parent f0ee7ed4cf
commit a29d6b0ef3
7 changed files with 321 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

296
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/AddKeysActivity.java
View File

@ -17,33 +17,52 @@
package org.sufficientlysecure.keychain.ui;
import android.app.ProgressDialog;
import android.content.Intent;
import android.graphics.PorterDuff;
import android.net.Uri;
import android.os.Bundle;
import android.os.Message;
import android.os.Messenger;
import android.support.v4.app.LoaderManager;
import android.support.v4.content.Loader;
import android.support.v4.util.LongSparseArray;
import android.support.v7.app.ActionBarActivity;
import android.view.View;
import android.widget.ImageView;
import org.sufficientlysecure.keychain.Constants;
import org.sufficientlysecure.keychain.R;
import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
import org.sufficientlysecure.keychain.provider.CachedPublicKeyRing;
import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
import org.sufficientlysecure.keychain.keyimport.Keyserver;
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
import org.sufficientlysecure.keychain.provider.KeychainContract;
import org.sufficientlysecure.keychain.provider.ProviderHelper;
import org.sufficientlysecure.keychain.service.KeychainIntentService;
import org.sufficientlysecure.keychain.service.KeychainIntentServiceHandler;
import org.sufficientlysecure.keychain.service.results.ImportKeyResult;
import org.sufficientlysecure.keychain.service.results.OperationResult;
import org.sufficientlysecure.keychain.ui.adapter.AsyncTaskResultWrapper;
import org.sufficientlysecure.keychain.ui.adapter.ImportKeysListCloudLoader;
import org.sufficientlysecure.keychain.ui.adapter.ImportKeysListLoader;
import org.sufficientlysecure.keychain.ui.util.Notify;
import org.sufficientlysecure.keychain.ui.widget.ExchangeKeySpinner;
import org.sufficientlysecure.keychain.ui.widget.KeySpinner;
import org.sufficientlysecure.keychain.util.InputData;
import org.sufficientlysecure.keychain.util.Log;
import org.sufficientlysecure.keychain.util.ParcelableFileCache;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import edu.cmu.cylab.starslinger.exchange.ExchangeActivity;
import edu.cmu.cylab.starslinger.exchange.ExchangeConfig;
public class AddKeysActivity extends ActionBarActivity {
public class AddKeysActivity extends ActionBarActivity implements
LoaderManager.LoaderCallbacks<AsyncTaskResultWrapper<ArrayList<ImportKeysListEntry>>> {
ExchangeKeySpinner mSafeSlingerKeySpinner;
View mActionSafeSlinger;
@ -55,9 +74,16 @@ public class AddKeysActivity extends ActionBarActivity {
long mExchangeMasterKeyId = Constants.key.none;
private static final int REQUEST_CODE_SAFESLINGER = 1;
byte[] mImportBytes;
private LongSparseArray<ParcelableKeyRing> mCachedKeyData;
private static final int REQUEST_CODE_SAFE_SLINGER = 1;
private static final int LOADER_ID_BYTES = 0;
private static final int LOADER_ID_CLOUD = 1;
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
@ -119,7 +145,7 @@ public class AddKeysActivity extends ActionBarActivity {
Intent slingerIntent = new Intent(this, ExchangeActivity.class);
slingerIntent.putExtra(ExchangeConfig.extra.USER_DATA, keyBlob);
slingerIntent.putExtra(ExchangeConfig.extra.HOST_NAME, Constants.SAFESLINGER_SERVER);
startActivityForResult(slingerIntent, REQUEST_CODE_SAFESLINGER);
startActivityForResult(slingerIntent, REQUEST_CODE_SAFE_SLINGER);
} catch (ProviderHelper.NotFoundException e) {
Log.e(Constants.TAG, "personal key not found", e);
}
@ -143,14 +169,16 @@ public class AddKeysActivity extends ActionBarActivity {
result.createNotify(this).show();
} else {
switch (requestCode) {
case REQUEST_CODE_SAFESLINGER:
case REQUEST_CODE_SAFE_SLINGER:
switch (resultCode) {
case ExchangeActivity.RESULT_EXCHANGE_OK:
// import exchanged keys
Intent importIntent = new Intent(this, ImportKeysActivity.class);
importIntent.setAction(ImportKeysActivity.ACTION_IMPORT_KEY);
importIntent.putExtra(ImportKeysActivity.EXTRA_KEY_BYTES, getSlingedKeys(data));
startActivity(importIntent);
mImportBytes = getSlingedKeys(data);
getSupportLoaderManager().restartLoader(LOADER_ID_BYTES, null, this);
// Intent importIntent = new Intent(this, ImportKeysActivity.class);
// importIntent.setAction(ImportKeysActivity.ACTION_IMPORT_KEY);
// importIntent.putExtra(ImportKeysActivity.EXTRA_KEY_BYTES, getSlingedKeys(data));
// startActivity(importIntent);
break;
case ExchangeActivity.RESULT_EXCHANGE_CANCELED:
// handle canceled result
@ -185,4 +213,252 @@ public class AddKeysActivity extends ActionBarActivity {
return out.toByteArray();
}
@Override
public Loader<AsyncTaskResultWrapper<ArrayList<ImportKeysListEntry>>> onCreateLoader(int id, Bundle args) {
switch (id) {
case LOADER_ID_BYTES: {
InputData inputData = new InputData(new ByteArrayInputStream(mImportBytes), mImportBytes.length);
return new ImportKeysListLoader(this, inputData);
}
case LOADER_ID_CLOUD: {
// ImportKeysListFragment.CloudLoaderState ls = (ImportKeysListFragment.CloudLoaderState) mLoaderState;
// return new ImportKeysListCloudLoader(this, ls.mServerQuery, ls.mCloudPrefs);
}
default:
return null;
}
}
@Override
public void onLoadFinished(Loader<AsyncTaskResultWrapper<ArrayList<ImportKeysListEntry>>> loader, AsyncTaskResultWrapper<ArrayList<ImportKeysListEntry>> data) {
Log.d(Constants.TAG, "data: " + data.getResult());
// swap in the real data!
// mAdapter.setData(data.getResult());
// mAdapter.notifyDataSetChanged();
//
// setListAdapter(mAdapter);
//
// // The list should now be shown.
// if (isResumed()) {
// setListShown(true);
// } else {
// setListShownNoAnimation(true);
// }
Exception error = data.getError();
// free old cached key data
mCachedKeyData = null;
// TODO: Use parcels!!!!!!!!!!!!!!!
switch (loader.getId()) {
case LOADER_ID_BYTES:
if (error == null) {
// No error
mCachedKeyData = ((ImportKeysListLoader) loader).getParcelableRings();
} else if (error instanceof ImportKeysListLoader.NoValidKeysException) {
Notify.showNotify(this, R.string.error_import_no_valid_keys, Notify.Style.ERROR);
} else if (error instanceof ImportKeysListLoader.NonPgpPartException) {
Notify.showNotify(this,
((ImportKeysListLoader.NonPgpPartException) error).getCount() + " " + getResources().
getQuantityString(R.plurals.error_import_non_pgp_part,
((ImportKeysListLoader.NonPgpPartException) error).getCount()),
Notify.Style.OK
);
} else {
Notify.showNotify(this, R.string.error_generic_report_bug, Notify.Style.ERROR);
}
break;
case LOADER_ID_CLOUD:
if (error == null) {
// No error
} else if (error instanceof Keyserver.QueryTooShortException) {
Notify.showNotify(this, R.string.error_query_too_short, Notify.Style.ERROR);
} else if (error instanceof Keyserver.TooManyResponsesException) {
Notify.showNotify(this, R.string.error_too_many_responses, Notify.Style.ERROR);
} else if (error instanceof Keyserver.QueryTooShortOrTooManyResponsesException) {
Notify.showNotify(this, R.string.error_too_short_or_too_many_responses, Notify.Style.ERROR);
} else if (error instanceof Keyserver.QueryFailedException) {
Log.d(Constants.TAG,
"Unrecoverable keyserver query error: " + error.getLocalizedMessage());
String alert = this.getString(R.string.error_searching_keys);
alert = alert + " (" + error.getLocalizedMessage() + ")";
Notify.showNotify(this, alert, Notify.Style.ERROR);
}
break;
default:
break;
}
importKeys();
}
@Override
public void onLoaderReset(Loader<AsyncTaskResultWrapper<ArrayList<ImportKeysListEntry>>> loader) {
switch (loader.getId()) {
case LOADER_ID_BYTES:
// Clear the data in the adapter.
// mAdapter.clear();
break;
case LOADER_ID_CLOUD:
// Clear the data in the adapter.
// mAdapter.clear();
break;
default:
break;
}
}
public ParcelableFileCache.IteratorWithSize<ParcelableKeyRing> getSelectedData() {
return new ParcelableFileCache.IteratorWithSize<ParcelableKeyRing>() {
int i = 0;
@Override
public int getSize() {
return mCachedKeyData.size();
}
@Override
public boolean hasNext() {
return (mCachedKeyData.get(i + 1) != null);
}
@Override
public ParcelableKeyRing next() {
ParcelableKeyRing key = mCachedKeyData.get(i);
i++;
return key;
}
@Override
public void remove() {
mCachedKeyData.remove(i);
}
};
}
public void importKeys() {
// Message is received after importing is done in KeychainIntentService
KeychainIntentServiceHandler saveHandler = new KeychainIntentServiceHandler(
this,
getString(R.string.progress_importing),
ProgressDialog.STYLE_HORIZONTAL,
true) {
public void handleMessage(Message message) {
// handle messages by standard KeychainIntentServiceHandler first
super.handleMessage(message);
if (message.arg1 == KeychainIntentServiceHandler.MESSAGE_OKAY) {
// get returned data bundle
Bundle returnData = message.getData();
if (returnData == null) {
return;
}
final ImportKeyResult result =
returnData.getParcelable(OperationResult.EXTRA_RESULT);
if (result == null) {
Log.e(Constants.TAG, "result == null");
return;
}
// if (ACTION_IMPORT_KEY_FROM_KEYSERVER_AND_RETURN_RESULT.equals(getIntent().getAction())
// || ACTION_IMPORT_KEY_FROM_FILE_AND_RETURN.equals(getIntent().getAction())) {
// Intent intent = new Intent();
// intent.putExtra(ImportKeyResult.EXTRA_RESULT, result);
// ImportKeysActivity.this.setResult(RESULT_OK, intent);
// ImportKeysActivity.this.finish();
// return;
// }
// if (ACTION_IMPORT_KEY_FROM_KEYSERVER_AND_RETURN_TO_SERVICE.equals(getIntent().getAction())) {
// ImportKeysActivity.this.setResult(RESULT_OK, mPendingIntentData);
// ImportKeysActivity.this.finish();
// return;
// }
result.createNotify(AddKeysActivity.this).show();
}
}
};
// ImportKeysListFragment.LoaderState ls = mListFragment.getLoaderState();
// if (importBytes != null) {
Log.d(Constants.TAG, "importKeys started");
// Send all information needed to service to import key in other thread
Intent intent = new Intent(this, KeychainIntentService.class);
intent.setAction(KeychainIntentService.ACTION_IMPORT_KEYRING);
// fill values for this action
Bundle data = new Bundle();
// get DATA from selected key entries
// ParcelableFileCache.IteratorWithSize<ParcelableKeyRing> selectedEntries = mListFragment.getSelectedData();
// instead of giving the entries by Intent extra, cache them into a
// file to prevent Java Binder problems on heavy imports
// read FileImportCache for more info.
try {
// We parcel this iteratively into a file - anything we can
// display here, we should be able to import.
ParcelableFileCache<ParcelableKeyRing> cache =
new ParcelableFileCache<ParcelableKeyRing>(this, "key_import.pcl");
cache.writeCache(getSelectedData());
intent.putExtra(KeychainIntentService.EXTRA_DATA, data);
// Create a new Messenger for the communication back
Messenger messenger = new Messenger(saveHandler);
intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger);
// show progress dialog
saveHandler.showProgressDialog(this);
// start service with intent
startService(intent);
} catch (IOException e) {
Log.e(Constants.TAG, "Problem writing cache file", e);
Notify.showNotify(this, "Problem writing cache file!", Notify.Style.ERROR);
}
// } else if (ls instanceof ImportKeysListFragment.CloudLoaderState) {
// ImportKeysListFragment.CloudLoaderState sls = (ImportKeysListFragment.CloudLoaderState) ls;
//
// // Send all information needed to service to query keys in other thread
// Intent intent = new Intent(this, KeychainIntentService.class);
//
// intent.setAction(KeychainIntentService.ACTION_DOWNLOAD_AND_IMPORT_KEYS);
//
// // fill values for this action
// Bundle data = new Bundle();
//
// data.putString(KeychainIntentService.DOWNLOAD_KEY_SERVER, sls.mCloudPrefs.keyserver);
//
// // get selected key entries
// ArrayList<ImportKeysListEntry> selectedEntries = mListFragment.getSelectedEntries();
// data.putParcelableArrayList(KeychainIntentService.DOWNLOAD_KEY_LIST, selectedEntries);
//
// intent.putExtra(KeychainIntentService.EXTRA_DATA, data);
//
// // Create a new Messenger for the communication back
// Messenger messenger = new Messenger(saveHandler);
// intent.putExtra(KeychainIntentService.EXTRA_MESSENGER, messenger);
//
// // show progress dialog
// saveHandler.showProgressDialog(this);
//
// // start service with intent
// startService(intent);
// } else {
// Notify.showNotify(this, R.string.error_nothing_import, Notify.Style.ERROR);
// }
}
}

17
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ImportKeysActivity.java
View File

@ -97,7 +97,6 @@ public class ImportKeysActivity extends ActionBarActivity {
private SlidingTabLayout mSlidingTabLayout;
private PagerTabStripAdapter mTabsAdapter;
public static final int VIEW_PAGER_HEIGHT = 64; // dp
private static final int ALL_TABS = -1;
private static final int TAB_CLOUD = 0;
@ -270,10 +269,6 @@ public class ImportKeysActivity extends ActionBarActivity {
mSlidingTabLayout.setOnPageChangeListener(new ViewPager.OnPageChangeListener() {
@Override
public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
// resize view pager back to 64 if keyserver settings have been collapsed
if (getViewPagerHeight() > VIEW_PAGER_HEIGHT) {
resizeViewPager(VIEW_PAGER_HEIGHT);
}
}
@Override
@ -339,18 +334,6 @@ public class ImportKeysActivity extends ActionBarActivity {
getSupportFragmentManager().executePendingTransactions();
}
public void resizeViewPager(int dp) {
ViewGroup.LayoutParams params = mViewPager.getLayoutParams();
params.height = FormattingUtils.dpToPx(this, dp);
// update layout after operations
mSlidingTabLayout.setViewPager(mViewPager);
}
public int getViewPagerHeight() {
ViewGroup.LayoutParams params = mViewPager.getLayoutParams();
return FormattingUtils.pxToDp(this, params.height);
}
private String getFingerprintFromUri(Uri dataUri) {
String fingerprint = dataUri.toString().split(":")[1].toLowerCase(Locale.ENGLISH);
Log.d(Constants.TAG, "fingerprint: " + fingerprint);

3
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/CertifyKeySpinner.java
View File

@ -84,6 +84,8 @@ public class CertifyKeySpinner extends KeySpinner {
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
super.onLoadFinished(loader, data);
if (loader.getId() == LOADER_ID) {
// If there is only one choice, pick it by default
if (mAdapter.getCount() == 2) {
setSelection(1);
@ -92,6 +94,7 @@ public class CertifyKeySpinner extends KeySpinner {
mIndexIsRevoked = data.getColumnIndex(KeychainContract.KeyRings.IS_REVOKED);
mIndexIsExpired = data.getColumnIndex(KeychainContract.KeyRings.IS_EXPIRED);
}
}
@Override
boolean setStatus(Context context, Cursor cursor, ImageView statusView) {

5
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/ExchangeKeySpinner.java
View File

@ -66,11 +66,13 @@ public class ExchangeKeySpinner extends KeySpinner {
return new CursorLoader(getContext(), baseUri, projection, where, null, null);
}
private int mIndexHasSign, mIndexIsRevoked, mIndexIsExpired;
private int mIndexIsRevoked, mIndexIsExpired;
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
super.onLoadFinished(loader, data);
if (loader.getId() == LOADER_ID) {
// If there is only one choice, pick it by default
if (mAdapter.getCount() == 2) {
setSelection(1);
@ -78,6 +80,7 @@ public class ExchangeKeySpinner extends KeySpinner {
mIndexIsRevoked = data.getColumnIndex(KeychainContract.KeyRings.IS_REVOKED);
mIndexIsExpired = data.getColumnIndex(KeychainContract.KeyRings.IS_EXPIRED);
}
}
@Override
boolean setStatus(Context context, Cursor cursor, ImageView statusView) {

9
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/KeySpinner.java
View File

@ -50,6 +50,9 @@ public abstract class KeySpinner extends Spinner implements LoaderManager.Loader
protected SelectKeyAdapter mAdapter = new SelectKeyAdapter();
protected OnKeyChangedListener mListener;
// this shall note collide with other loaders inside the activity
protected int LOADER_ID = 2343;
public KeySpinner(Context context) {
super(context);
initView();
@ -101,7 +104,7 @@ public abstract class KeySpinner extends Spinner implements LoaderManager.Loader
public void reload() {
if (getContext() instanceof FragmentActivity) {
((FragmentActivity) getContext()).getSupportLoaderManager().restartLoader(0, null, this);
((FragmentActivity) getContext()).getSupportLoaderManager().restartLoader(LOADER_ID, null, this);
} else {
Log.e(Constants.TAG, "KeySpinner must be attached to FragmentActivity, this is " + getContext().getClass());
}
@ -109,13 +112,17 @@ public abstract class KeySpinner extends Spinner implements LoaderManager.Loader
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
if (loader.getId() == LOADER_ID) {
mAdapter.swapCursor(data);
}
}
@Override
public void onLoaderReset(Loader<Cursor> loader) {
if (loader.getId() == LOADER_ID) {
mAdapter.swapCursor(null);
}
}
public long getSelectedKeyId() {
return mSelectedKeyId;

3
OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/widget/SignKeySpinner.java
View File

@ -73,10 +73,13 @@ public class SignKeySpinner extends KeySpinner {
@Override
public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
super.onLoadFinished(loader, data);
if (loader.getId() == LOADER_ID) {
mIndexHasSign = data.getColumnIndex(KeychainContract.KeyRings.HAS_SIGN);
mIndexIsRevoked = data.getColumnIndex(KeychainContract.KeyRings.IS_REVOKED);
mIndexIsExpired = data.getColumnIndex(KeychainContract.KeyRings.IS_EXPIRED);
}
}
@Override
boolean setStatus(Context context, Cursor cursor, ImageView statusView) {

2
OpenKeychain/src/main/res/layout/add_key_activity.xml
View File

@ -87,7 +87,7 @@
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_marginTop="32dp"
android:text="Add" />
android:text="Secure add" />
<TextView
android:id="@+id/add_keys_qr_code"