mirror of
https://github.com/moparisthebest/open-keychain
synced 2024-11-23 17:22:16 -05:00
made ImportKeysActivity CryptoOperationHelper compatible
This commit is contained in:
Adithya Abraham Philip
parent
40f931371f
commit
010d6328af
@ -22,6 +22,7 @@ import android.content.Context;
|
||||
import android.database.Cursor;
|
||||
import android.net.Uri;
|
||||
|
||||
import android.os.Parcelable;
|
||||
import org.spongycastle.bcpg.ArmoredOutputStream;
|
||||
import org.sufficientlysecure.keychain.Constants;
|
||||
import org.sufficientlysecure.keychain.R;
|
||||
@ -33,6 +34,7 @@ import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
|
||||
import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.ExportResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
|
||||
import org.sufficientlysecure.keychain.operations.results.SaveKeyringResult;
|
||||
@ -45,6 +47,9 @@ import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
|
||||
import org.sufficientlysecure.keychain.provider.KeychainDatabase.Tables;
|
||||
import org.sufficientlysecure.keychain.provider.ProviderHelper;
|
||||
import org.sufficientlysecure.keychain.service.ContactSyncAdapterService;
|
||||
import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
|
||||
import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
|
||||
import org.sufficientlysecure.keychain.service.input.RequiredInputParcel;
|
||||
import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
|
||||
import org.sufficientlysecure.keychain.util.FileHelper;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
@ -59,9 +64,18 @@ import java.io.FileNotFoundException;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.OutputStream;
|
||||
import java.net.Proxy;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.Callable;
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.ExecutorCompletionService;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.SynchronousQueue;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
|
||||
/** An operation class which implements high level import and export
|
||||
@ -87,7 +101,7 @@ import java.util.concurrent.atomic.AtomicBoolean;
|
||||
* TODO rework uploadKeyRingToServer
|
||||
*
|
||||
*/
|
||||
public class ImportExportOperation extends BaseOperation {
|
||||
public class ImportExportOperation extends BaseOperation<ImportKeyringParcel> {
|
||||
|
||||
public ImportExportOperation(Context context, ProviderHelper providerHelper, Progressable progressable) {
|
||||
super(context, providerHelper, progressable);
|
||||
@ -127,23 +141,41 @@ public class ImportExportOperation extends BaseOperation {
|
||||
}
|
||||
}
|
||||
|
||||
public ImportKeyResult importKeyRings(List<ParcelableKeyRing> entries, String keyServerUri) {
|
||||
// Overloaded functions for using progressable supplied in constructor during import
|
||||
public ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int num,
|
||||
String keyServerUri) {
|
||||
return serialKeyRingImport(entries, num, keyServerUri, mProgressable);
|
||||
}
|
||||
|
||||
public ImportKeyResult serialKeyRingImport(List<ParcelableKeyRing> entries,
|
||||
String keyServerUri) {
|
||||
|
||||
Iterator<ParcelableKeyRing> it = entries.iterator();
|
||||
int numEntries = entries.size();
|
||||
|
||||
return importKeyRings(it, numEntries, keyServerUri);
|
||||
return serialKeyRingImport(it, numEntries, keyServerUri, mProgressable);
|
||||
|
||||
}
|
||||
|
||||
public ImportKeyResult importKeyRings(ParcelableFileCache<ParcelableKeyRing> cache, String keyServerUri) {
|
||||
public ImportKeyResult serialKeyRingImport(List<ParcelableKeyRing> entries, String keyServerUri,
|
||||
Progressable progressable) {
|
||||
|
||||
Iterator<ParcelableKeyRing> it = entries.iterator();
|
||||
int numEntries = entries.size();
|
||||
|
||||
return serialKeyRingImport(it, numEntries, keyServerUri, progressable);
|
||||
|
||||
}
|
||||
|
||||
public ImportKeyResult serialKeyRingImport(ParcelableFileCache<ParcelableKeyRing> cache,
|
||||
String keyServerUri) {
|
||||
|
||||
// get entries from cached file
|
||||
try {
|
||||
IteratorWithSize<ParcelableKeyRing> it = cache.readCache();
|
||||
int numEntries = it.getSize();
|
||||
|
||||
return importKeyRings(it, numEntries, keyServerUri);
|
||||
return serialKeyRingImport(it, numEntries, keyServerUri, mProgressable);
|
||||
} catch (IOException e) {
|
||||
|
||||
// Special treatment here, we need a lot
|
||||
@ -157,15 +189,18 @@ public class ImportExportOperation extends BaseOperation {
|
||||
}
|
||||
|
||||
/**
|
||||
* Since the introduction of multithreaded import, we expect calling functions to handle the key sync i,e
|
||||
* ContactSyncAdapterService.requestSync()
|
||||
* Since the introduction of multithreaded import, we expect calling functions to handle the
|
||||
* key sync i,eContactSyncAdapterService.requestSync()
|
||||
*
|
||||
* @param entries keys to import
|
||||
* @param num number of keys to import
|
||||
* @param keyServerUri contains uri of keyserver to import from, if it is an import from cloud
|
||||
* @param progressable Allows multi-threaded import to supply a progressable that ignores the
|
||||
* progress of a single key being imported
|
||||
* @return
|
||||
*/
|
||||
public ImportKeyResult importKeyRings(Iterator<ParcelableKeyRing> entries, int num, String keyServerUri) {
|
||||
public ImportKeyResult serialKeyRingImport(Iterator<ParcelableKeyRing> entries, int num,
|
||||
String keyServerUri, Progressable progressable) {
|
||||
updateProgress(R.string.progress_importing, 0, 100);
|
||||
|
||||
OperationLog log = new OperationLog();
|
||||
@ -224,7 +259,8 @@ public class ImportExportOperation extends BaseOperation {
|
||||
byte[] data;
|
||||
// Download by fingerprint, or keyId - whichever is available
|
||||
if (entry.mExpectedFingerprint != null) {
|
||||
log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, "0x" + entry.mExpectedFingerprint.substring(24));
|
||||
log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, "0x" +
|
||||
entry.mExpectedFingerprint.substring(24));
|
||||
data = keyServer.get("0x" + entry.mExpectedFingerprint).getBytes();
|
||||
} else {
|
||||
log.add(LogType.MSG_IMPORT_FETCH_KEYSERVER, 2, entry.mKeyIdHex);
|
||||
@ -302,10 +338,12 @@ public class ImportExportOperation extends BaseOperation {
|
||||
mProviderHelper.clearLog();
|
||||
if (key.isSecret()) {
|
||||
result = mProviderHelper.saveSecretKeyRing(key,
|
||||
new ProgressScaler(mProgressable, (int)(position*progSteps), (int)((position+1)*progSteps), 100));
|
||||
new ProgressScaler(progressable, (int)(position*progSteps),
|
||||
(int)((position+1)*progSteps), 100));
|
||||
} else {
|
||||
result = mProviderHelper.savePublicKeyRing(key,
|
||||
new ProgressScaler(mProgressable, (int)(position*progSteps), (int)((position+1)*progSteps), 100));
|
||||
new ProgressScaler(progressable, (int)(position*progSteps),
|
||||
(int)((position+1)*progSteps), 100));
|
||||
}
|
||||
if (!result.success()) {
|
||||
badKeys += 1;
|
||||
@ -333,7 +371,7 @@ public class ImportExportOperation extends BaseOperation {
|
||||
// Special: consolidate on secret key import (cannot be cancelled!)
|
||||
if (secret > 0) {
|
||||
setPreventCancel();
|
||||
ConsolidateResult result = mProviderHelper.consolidateDatabaseStep1(mProgressable);
|
||||
ConsolidateResult result = mProviderHelper.consolidateDatabaseStep1(progressable);
|
||||
log.add(result, 1);
|
||||
}
|
||||
|
||||
@ -590,4 +628,210 @@ public class ImportExportOperation extends BaseOperation {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public ImportKeyResult execute(ImportKeyringParcel input, CryptoInputParcel cryptoInput) {
|
||||
|
||||
return importKeys(input.mKeyList, input.mKeyserver);
|
||||
}
|
||||
|
||||
public ImportKeyResult importKeys(ArrayList<ParcelableKeyRing> keyList, String keyServer) {
|
||||
|
||||
ImportKeyResult result;
|
||||
|
||||
if (keyList == null) {// import from file, do serially
|
||||
ParcelableFileCache<ParcelableKeyRing> cache = new ParcelableFileCache<>(mContext,
|
||||
"key_import.pcl");
|
||||
|
||||
result = serialKeyRingImport(cache, keyServer);
|
||||
} else {
|
||||
// if there is more than one key with the same fingerprint, we do a serial import to prevent
|
||||
// https://github.com/open-keychain/open-keychain/issues/1221
|
||||
HashSet<String> keyFingerprintSet = new HashSet<>();
|
||||
for (int i = 0; i < keyList.size(); i++) {
|
||||
keyFingerprintSet.add(keyList.get(i).mExpectedFingerprint);
|
||||
}
|
||||
if (keyFingerprintSet.size() == keyList.size()) {
|
||||
// all keys have unique fingerprints
|
||||
result = multiThreadedKeyImport(keyList.iterator(), keyList.size(), keyServer);
|
||||
} else {
|
||||
result = serialKeyRingImport(keyList, keyServer);
|
||||
}
|
||||
}
|
||||
|
||||
ContactSyncAdapterService.requestSync();
|
||||
return result;
|
||||
}
|
||||
|
||||
private ImportKeyResult multiThreadedKeyImport(Iterator<ParcelableKeyRing> keyListIterator,
|
||||
int totKeys, final String keyServer) {
|
||||
Log.d(Constants.TAG, "Multi-threaded key import starting");
|
||||
if (keyListIterator != null) {
|
||||
KeyImportAccumulator accumulator = new KeyImportAccumulator(totKeys, mProgressable);
|
||||
|
||||
final Progressable ignoreProgressable = new Progressable() {
|
||||
@Override
|
||||
public void setProgress(String message, int current, int total) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setProgress(int resourceId, int current, int total) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setProgress(int current, int total) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPreventCancel() {
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
final int maxThreads = 200;
|
||||
ExecutorService importExecutor = new ThreadPoolExecutor(0, maxThreads,
|
||||
30L, TimeUnit.SECONDS,
|
||||
new SynchronousQueue<Runnable>());
|
||||
|
||||
ExecutorCompletionService<ImportKeyResult> importCompletionService =
|
||||
new ExecutorCompletionService(importExecutor);
|
||||
|
||||
while (keyListIterator.hasNext()) { // submit all key rings to be imported
|
||||
|
||||
final ParcelableKeyRing pkRing = keyListIterator.next();
|
||||
|
||||
Callable<ImportKeyResult> importOperationCallable = new Callable<ImportKeyResult>() {
|
||||
|
||||
@Override
|
||||
public ImportKeyResult call() {
|
||||
|
||||
ArrayList<ParcelableKeyRing> list = new ArrayList<>();
|
||||
list.add(pkRing);
|
||||
|
||||
return serialKeyRingImport(list, keyServer, ignoreProgressable);
|
||||
}
|
||||
};
|
||||
|
||||
importCompletionService.submit(importOperationCallable);
|
||||
}
|
||||
|
||||
while (!accumulator.isImportFinished()) { // accumulate the results of each import
|
||||
try {
|
||||
accumulator.accumulateKeyImport(importCompletionService.take().get());
|
||||
} catch (InterruptedException | ExecutionException e) {
|
||||
Log.e(Constants.TAG, "A key could not be imported during multi-threaded import", e);
|
||||
// do nothing?
|
||||
if (e instanceof ExecutionException) {
|
||||
// Since serialKeyRingImport does not throw any exceptions, this is what would have happened if
|
||||
// we were importing the key on this thread
|
||||
throw new RuntimeException();
|
||||
}
|
||||
}
|
||||
}
|
||||
return accumulator.getConsolidatedResult();
|
||||
}
|
||||
return null; // TODO: Decide if we should just crash instead of returning null
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to accumulate the results of individual key imports
|
||||
*/
|
||||
private class KeyImportAccumulator {
|
||||
private OperationResult.OperationLog mImportLog = new OperationResult.OperationLog();
|
||||
Progressable mProgressable;
|
||||
private int mTotalKeys;
|
||||
private int mImportedKeys = 0;
|
||||
ArrayList<Long> mImportedMasterKeyIds = new ArrayList<Long>();
|
||||
private int mBadKeys = 0;
|
||||
private int mNewKeys = 0;
|
||||
private int mUpdatedKeys = 0;
|
||||
private int mSecret = 0;
|
||||
private int mResultType = 0;
|
||||
|
||||
/**
|
||||
* Accumulates keyring imports and updates the progressable whenever a new key is imported.
|
||||
* Also sets the progress to 0 on instantiation.
|
||||
*
|
||||
* @param totalKeys total number of keys to be imported
|
||||
* @param externalProgressable the external progressable to be updated every time a key is imported
|
||||
*/
|
||||
public KeyImportAccumulator(int totalKeys, Progressable externalProgressable) {
|
||||
mTotalKeys = totalKeys;
|
||||
mProgressable = externalProgressable;
|
||||
mProgressable.setProgress(0, totalKeys);
|
||||
}
|
||||
|
||||
public int getTotalKeys() {
|
||||
return mTotalKeys;
|
||||
}
|
||||
|
||||
public int getImportedKeys() {
|
||||
return mImportedKeys;
|
||||
}
|
||||
|
||||
public synchronized void accumulateKeyImport(ImportKeyResult result) {
|
||||
mImportedKeys++;
|
||||
|
||||
mProgressable.setProgress(mImportedKeys, mTotalKeys);
|
||||
|
||||
mImportLog.addAll(result.getLog().toList());//accumulates log
|
||||
mBadKeys += result.mBadKeys;
|
||||
mNewKeys += result.mNewKeys;
|
||||
mUpdatedKeys += result.mUpdatedKeys;
|
||||
mSecret += result.mSecret;
|
||||
|
||||
long[] masterKeyIds = result.getImportedMasterKeyIds();
|
||||
for (long masterKeyId : masterKeyIds) {
|
||||
mImportedMasterKeyIds.add(masterKeyId);
|
||||
}
|
||||
|
||||
// if any key import has been cancelled, set result type to cancelled
|
||||
// resultType is added to in getConsolidatedKayImport to account for remaining factors
|
||||
mResultType |= result.getResult() & ImportKeyResult.RESULT_CANCELLED;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns accumulated result of all imports so far
|
||||
*/
|
||||
public ImportKeyResult getConsolidatedResult() {
|
||||
|
||||
// adding required information to mResultType
|
||||
// special case,no keys requested for import
|
||||
if (mBadKeys == 0 && mNewKeys == 0 && mUpdatedKeys == 0) {
|
||||
mResultType = ImportKeyResult.RESULT_FAIL_NOTHING;
|
||||
} else {
|
||||
if (mNewKeys > 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_OK_NEWKEYS;
|
||||
}
|
||||
if (mUpdatedKeys > 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_OK_UPDATED;
|
||||
}
|
||||
if (mBadKeys > 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_WITH_ERRORS;
|
||||
if (mNewKeys == 0 && mUpdatedKeys == 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_ERROR;
|
||||
}
|
||||
}
|
||||
if (mImportLog.containsWarnings()) {
|
||||
mResultType |= ImportKeyResult.RESULT_WARNINGS;
|
||||
}
|
||||
}
|
||||
|
||||
long masterKeyIds[] = new long[mImportedMasterKeyIds.size()];
|
||||
for (int i = 0; i < masterKeyIds.length; i++) {
|
||||
masterKeyIds[i] = mImportedMasterKeyIds.get(i);
|
||||
}
|
||||
|
||||
return new ImportKeyResult(mResultType, mImportLog, mNewKeys, mUpdatedKeys, mBadKeys,
|
||||
mSecret, masterKeyIds);
|
||||
}
|
||||
|
||||
public boolean isImportFinished() {
|
||||
return mTotalKeys == mImportedKeys;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -1250,7 +1250,7 @@ public class ProviderHelper {
|
||||
|
||||
ImportKeyResult result = new ImportExportOperation(mContext, this,
|
||||
new ProgressFixedScaler(progress, 10, 25, 100, R.string.progress_con_reimport))
|
||||
.importKeyRings(itSecrets, numSecrets, null);
|
||||
.serialKeyRingImport(itSecrets, numSecrets, null);
|
||||
log.add(result, indent);
|
||||
} else {
|
||||
log.add(LogType.MSG_CON_REIMPORT_SECRET_SKIP, indent);
|
||||
@ -1278,7 +1278,7 @@ public class ProviderHelper {
|
||||
|
||||
ImportKeyResult result = new ImportExportOperation(mContext, this,
|
||||
new ProgressFixedScaler(progress, 25, 99, 100, R.string.progress_con_reimport))
|
||||
.importKeyRings(itPublics, numPublics, null);
|
||||
.serialKeyRingImport(itPublics, numPublics, null);
|
||||
log.add(result, indent);
|
||||
} else {
|
||||
log.add(LogType.MSG_CON_REIMPORT_PUBLIC_SKIP, indent);
|
||||
|
||||
@ -0,0 +1,74 @@
|
||||
/*
|
||||
* Copyright (C) 2015 Dominik Schürmann <dominik@dominikschuermann.de>
|
||||
* Copyright (C) 2015 Adithya Abraham Philip <adithyaphilip@gmail.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
package org.sufficientlysecure.keychain.service;
|
||||
|
||||
import android.os.Parcel;
|
||||
import android.os.Parcelable;
|
||||
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
|
||||
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class ImportKeyringParcel implements Parcelable {
|
||||
// if null, keys are expected to be read from a cache file in ImportExportOperations
|
||||
public ArrayList<ParcelableKeyRing> mKeyList;
|
||||
public String mKeyserver; // must be set if keys are to be imported from a keyserver
|
||||
|
||||
public ImportKeyringParcel (ArrayList<ParcelableKeyRing> keyList, String keyserver) {
|
||||
mKeyList = keyList;
|
||||
mKeyserver = keyserver;
|
||||
}
|
||||
|
||||
protected ImportKeyringParcel(Parcel in) {
|
||||
if (in.readByte() == 0x01) {
|
||||
mKeyList = new ArrayList<>();
|
||||
in.readList(mKeyList, ParcelableKeyRing.class.getClassLoader());
|
||||
} else {
|
||||
mKeyList = null;
|
||||
}
|
||||
mKeyserver = in.readString();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int describeContents() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void writeToParcel(Parcel dest, int flags) {
|
||||
if (mKeyList == null) {
|
||||
dest.writeByte((byte) (0x00));
|
||||
} else {
|
||||
dest.writeByte((byte) (0x01));
|
||||
dest.writeList(mKeyList);
|
||||
}
|
||||
dest.writeString(mKeyserver);
|
||||
}
|
||||
|
||||
public static final Parcelable.Creator<ImportKeyringParcel> CREATOR = new Parcelable.Creator<ImportKeyringParcel>() {
|
||||
@Override
|
||||
public ImportKeyringParcel createFromParcel(Parcel in) {
|
||||
return new ImportKeyringParcel(in);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ImportKeyringParcel[] newArray(int size) {
|
||||
return new ImportKeyringParcel[size];
|
||||
}
|
||||
};
|
||||
}
|
||||
@ -31,10 +31,7 @@ import android.os.Parcelable;
|
||||
import android.os.RemoteException;
|
||||
|
||||
import org.sufficientlysecure.keychain.Constants;
|
||||
import org.sufficientlysecure.keychain.operations.BaseOperation;
|
||||
import org.sufficientlysecure.keychain.operations.CertifyOperation;
|
||||
import org.sufficientlysecure.keychain.operations.EditKeyOperation;
|
||||
import org.sufficientlysecure.keychain.operations.SignEncryptOperation;
|
||||
import org.sufficientlysecure.keychain.operations.*;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult;
|
||||
import org.sufficientlysecure.keychain.pgp.PgpDecryptVerify;
|
||||
import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyInputParcel;
|
||||
@ -96,13 +93,19 @@ public class KeychainNewService extends Service implements Progressable {
|
||||
// just for brevity
|
||||
KeychainNewService outerThis = KeychainNewService.this;
|
||||
if (inputParcel instanceof SignEncryptParcel) {
|
||||
op = new SignEncryptOperation(outerThis, new ProviderHelper(outerThis), outerThis, mActionCanceled);
|
||||
op = new SignEncryptOperation(outerThis, new ProviderHelper(outerThis),
|
||||
outerThis, mActionCanceled);
|
||||
} else if (inputParcel instanceof PgpDecryptVerifyInputParcel) {
|
||||
op = new PgpDecryptVerify(outerThis, new ProviderHelper(outerThis), outerThis);
|
||||
} else if (inputParcel instanceof SaveKeyringParcel) {
|
||||
op = new EditKeyOperation(outerThis, new ProviderHelper(outerThis), outerThis, mActionCanceled);
|
||||
op = new EditKeyOperation(outerThis, new ProviderHelper(outerThis), outerThis,
|
||||
mActionCanceled);
|
||||
} else if (inputParcel instanceof CertifyAction) {
|
||||
op = new CertifyOperation(outerThis, new ProviderHelper(outerThis), outerThis, mActionCanceled);
|
||||
op = new CertifyOperation(outerThis, new ProviderHelper(outerThis), outerThis,
|
||||
mActionCanceled);
|
||||
} else if (inputParcel instanceof ImportKeyringParcel){
|
||||
op = new ImportExportOperation(outerThis, new ProviderHelper(outerThis),
|
||||
outerThis, mActionCanceled);
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
@ -37,13 +37,10 @@ import org.sufficientlysecure.keychain.R;
|
||||
import org.sufficientlysecure.keychain.keyimport.HkpKeyserver;
|
||||
import org.sufficientlysecure.keychain.keyimport.Keyserver;
|
||||
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
|
||||
import org.sufficientlysecure.keychain.operations.CertifyOperation;
|
||||
import org.sufficientlysecure.keychain.operations.DeleteOperation;
|
||||
import org.sufficientlysecure.keychain.operations.EditKeyOperation;
|
||||
import org.sufficientlysecure.keychain.operations.ImportExportOperation;
|
||||
import org.sufficientlysecure.keychain.operations.PromoteKeyOperation;
|
||||
import org.sufficientlysecure.keychain.operations.SignEncryptOperation;
|
||||
import org.sufficientlysecure.keychain.operations.results.CertifyResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.DeleteResult;
|
||||
@ -52,30 +49,21 @@ import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult.OperationLog;
|
||||
import org.sufficientlysecure.keychain.operations.results.PromoteKeyResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.SignEncryptResult;
|
||||
import org.sufficientlysecure.keychain.pgp.CanonicalizedPublicKeyRing;
|
||||
import org.sufficientlysecure.keychain.pgp.PgpDecryptVerify;
|
||||
import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyInputParcel;
|
||||
import org.sufficientlysecure.keychain.pgp.Progressable;
|
||||
import org.sufficientlysecure.keychain.pgp.SignEncryptParcel;
|
||||
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralException;
|
||||
import org.sufficientlysecure.keychain.pgp.exception.PgpGeneralMsgIdException;
|
||||
import org.sufficientlysecure.keychain.provider.ProviderHelper;
|
||||
import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
|
||||
import org.sufficientlysecure.keychain.service.ServiceProgressHandler.MessageStatus;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
import org.sufficientlysecure.keychain.util.ParcelableFileCache;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.InputStream;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashSet;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.SynchronousQueue;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
|
||||
import de.measite.minidns.Client;
|
||||
@ -156,11 +144,6 @@ public class KeychainService extends Service implements Progressable {
|
||||
// this attribute can possibly merged with the one above? not sure...
|
||||
private AtomicBoolean mActionCanceled = new AtomicBoolean(false);
|
||||
|
||||
|
||||
private KeyImportAccumulator mKeyImportAccumulator;
|
||||
|
||||
private KeychainService mKeychainService;
|
||||
|
||||
@Override
|
||||
public IBinder onBind(Intent intent) {
|
||||
return null;
|
||||
@ -171,7 +154,6 @@ public class KeychainService extends Service implements Progressable {
|
||||
*/
|
||||
@Override
|
||||
public int onStartCommand(final Intent intent, int flags, int startId) {
|
||||
mKeychainService = this;
|
||||
|
||||
if (ACTION_CANCEL.equals(intent.getAction())) {
|
||||
mActionCanceled.set(true);
|
||||
@ -208,7 +190,7 @@ public class KeychainService extends Service implements Progressable {
|
||||
|
||||
Log.logDebugBundle(data, "EXTRA_DATA");
|
||||
|
||||
ProviderHelper providerHelper = new ProviderHelper(mKeychainService);
|
||||
ProviderHelper providerHelper = new ProviderHelper(KeychainService.this);
|
||||
|
||||
String action = intent.getAction();
|
||||
|
||||
@ -219,9 +201,9 @@ public class KeychainService extends Service implements Progressable {
|
||||
// Operation
|
||||
ConsolidateResult result;
|
||||
if (data.containsKey(CONSOLIDATE_RECOVERY) && data.getBoolean(CONSOLIDATE_RECOVERY)) {
|
||||
result = providerHelper.consolidateDatabaseStep2(mKeychainService);
|
||||
result = providerHelper.consolidateDatabaseStep2(KeychainService.this);
|
||||
} else {
|
||||
result = providerHelper.consolidateDatabaseStep1(mKeychainService);
|
||||
result = providerHelper.consolidateDatabaseStep1(KeychainService.this);
|
||||
}
|
||||
|
||||
// Result
|
||||
@ -284,8 +266,8 @@ public class KeychainService extends Service implements Progressable {
|
||||
}
|
||||
}
|
||||
|
||||
PgpDecryptVerify op = new PgpDecryptVerify(mKeychainService, providerHelper,
|
||||
mKeychainService);
|
||||
PgpDecryptVerify op = new PgpDecryptVerify(KeychainService.this, providerHelper,
|
||||
KeychainService.this);
|
||||
|
||||
PgpDecryptVerifyInputParcel input = new PgpDecryptVerifyInputParcel(messageBytes)
|
||||
.setSignedLiteralData(true)
|
||||
@ -330,7 +312,7 @@ public class KeychainService extends Service implements Progressable {
|
||||
boolean isSecret = data.getBoolean(DELETE_IS_SECRET);
|
||||
|
||||
// Operation
|
||||
DeleteOperation op = new DeleteOperation(mKeychainService, providerHelper, mKeychainService);
|
||||
DeleteOperation op = new DeleteOperation(KeychainService.this, providerHelper, KeychainService.this);
|
||||
DeleteResult result = op.execute(masterKeyIds, isSecret);
|
||||
|
||||
// Result
|
||||
@ -345,8 +327,8 @@ public class KeychainService extends Service implements Progressable {
|
||||
CryptoInputParcel cryptoInput = data.getParcelable(EXTRA_CRYPTO_INPUT);
|
||||
|
||||
// Operation
|
||||
EditKeyOperation op = new EditKeyOperation(mKeychainService, providerHelper,
|
||||
mKeychainService, mActionCanceled);
|
||||
EditKeyOperation op = new EditKeyOperation(KeychainService.this, providerHelper,
|
||||
KeychainService.this, mActionCanceled);
|
||||
OperationResult result = op.execute(saveParcel, cryptoInput);
|
||||
|
||||
// Result
|
||||
@ -363,7 +345,7 @@ public class KeychainService extends Service implements Progressable {
|
||||
|
||||
// Operation
|
||||
PromoteKeyOperation op = new PromoteKeyOperation(
|
||||
mKeychainService, providerHelper, mKeychainService,
|
||||
KeychainService.this, providerHelper, KeychainService.this,
|
||||
mActionCanceled);
|
||||
PromoteKeyResult result = op.execute(keyRingId, cardAid, subKeyIds);
|
||||
|
||||
@ -384,7 +366,7 @@ public class KeychainService extends Service implements Progressable {
|
||||
|
||||
// Operation
|
||||
ImportExportOperation importExportOperation = new ImportExportOperation(
|
||||
mKeychainService, providerHelper, mKeychainService);
|
||||
KeychainService.this, providerHelper, KeychainService.this);
|
||||
ExportResult result;
|
||||
if (outputFile != null) {
|
||||
result = importExportOperation.exportToFile(masterKeyIds, exportSecret, outputFile);
|
||||
@ -403,23 +385,16 @@ public class KeychainService extends Service implements Progressable {
|
||||
String keyServer = data.getString(IMPORT_KEY_SERVER);
|
||||
ArrayList<ParcelableKeyRing> keyList = data.getParcelableArrayList(IMPORT_KEY_LIST);
|
||||
|
||||
// either keyList or cache must be null, no guarantees otherwise
|
||||
if (keyList == null) {// import from file, do serially
|
||||
serialKeyImport(null, keyServer, providerHelper);
|
||||
} else {
|
||||
// if there is more than one key with the same fingerprint, we do a serial import to prevent
|
||||
// https://github.com/open-keychain/open-keychain/issues/1221
|
||||
HashSet<String> keyFingerprintSet = new HashSet<>();
|
||||
for (int i = 0; i < keyList.size(); i++) {
|
||||
keyFingerprintSet.add(keyList.get(i).mExpectedFingerprint);
|
||||
}
|
||||
if (keyFingerprintSet.size() == keyList.size()) {
|
||||
// all keys have unique fingerprints
|
||||
multiThreadedKeyImport(keyList.iterator(), keyList.size(), keyServer);
|
||||
} else {
|
||||
serialKeyImport(keyList, keyServer, providerHelper);
|
||||
}
|
||||
}
|
||||
ImportExportOperation importExportOperation = new ImportExportOperation(
|
||||
KeychainService.this,
|
||||
providerHelper, KeychainService.this, mActionCanceled);
|
||||
|
||||
ImportKeyringParcel inputParcel = new ImportKeyringParcel(keyList, keyServer);
|
||||
CryptoInputParcel cryptoInputParcel = new CryptoInputParcel();
|
||||
|
||||
ImportKeyResult result = importExportOperation.execute(inputParcel, cryptoInputParcel);
|
||||
|
||||
sendMessageToHandler(MessageStatus.OKAY, result);
|
||||
|
||||
break;
|
||||
}
|
||||
@ -434,8 +409,8 @@ public class KeychainService extends Service implements Progressable {
|
||||
HkpKeyserver server = new HkpKeyserver(keyServer);
|
||||
|
||||
CanonicalizedPublicKeyRing keyring = providerHelper.getCanonicalizedPublicKeyRing(dataUri);
|
||||
ImportExportOperation importExportOperation = new ImportExportOperation(mKeychainService,
|
||||
providerHelper, mKeychainService);
|
||||
ImportExportOperation importExportOperation = new ImportExportOperation(
|
||||
KeychainService.this, providerHelper, KeychainService.this);
|
||||
|
||||
try {
|
||||
importExportOperation.uploadKeyRingToServer(server, keyring);
|
||||
@ -450,11 +425,8 @@ public class KeychainService extends Service implements Progressable {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!intent.getAction().equals(ACTION_IMPORT_KEYRING)) {
|
||||
// import keyring handles stopping service on its own
|
||||
stopSelf();
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
Thread actionThread = new Thread(actionRunnable);
|
||||
@ -484,7 +456,7 @@ public class KeychainService extends Service implements Progressable {
|
||||
// contextualize the exception, if necessary
|
||||
String message;
|
||||
if (e instanceof PgpGeneralMsgIdException) {
|
||||
e = ((PgpGeneralMsgIdException) e).getContextualized(mKeychainService);
|
||||
e = ((PgpGeneralMsgIdException) e).getContextualized(KeychainService.this);
|
||||
message = e.getMessage();
|
||||
} else {
|
||||
message = e.getMessage();
|
||||
@ -563,215 +535,4 @@ public class KeychainService extends Service implements Progressable {
|
||||
public void setPreventCancel() {
|
||||
sendMessageToHandler(MessageStatus.PREVENT_CANCEL);
|
||||
}
|
||||
|
||||
public void serialKeyImport(ArrayList<ParcelableKeyRing> keyList, final String keyServer,
|
||||
ProviderHelper providerHelper) {
|
||||
Log.d(Constants.TAG, "serial key import starting");
|
||||
ParcelableFileCache<ParcelableKeyRing> cache =
|
||||
new ParcelableFileCache<>(mKeychainService, "key_import.pcl");
|
||||
|
||||
// Operation
|
||||
ImportExportOperation importExportOperation = new ImportExportOperation(
|
||||
mKeychainService, providerHelper, mKeychainService,
|
||||
mActionCanceled);
|
||||
// Either list or cache must be null, no guarantees otherwise.
|
||||
ImportKeyResult result = keyList != null
|
||||
? importExportOperation.importKeyRings(keyList, keyServer)
|
||||
: importExportOperation.importKeyRings(cache, keyServer);
|
||||
|
||||
ContactSyncAdapterService.requestSync();
|
||||
// Result
|
||||
sendMessageToHandler(MessageStatus.OKAY, result);
|
||||
|
||||
stopSelf();
|
||||
}
|
||||
|
||||
public void multiThreadedKeyImport(Iterator<ParcelableKeyRing> keyListIterator, int totKeys, final String
|
||||
keyServer) {
|
||||
Log.d(Constants.TAG, "Multi-threaded key import starting");
|
||||
if (keyListIterator != null) {
|
||||
mKeyImportAccumulator = new KeyImportAccumulator(totKeys, mKeychainService);
|
||||
setProgress(0, totKeys);
|
||||
|
||||
final int maxThreads = 200;
|
||||
ExecutorService importExecutor = new ThreadPoolExecutor(0, maxThreads,
|
||||
30L, TimeUnit.SECONDS,
|
||||
new SynchronousQueue<Runnable>());
|
||||
|
||||
while (keyListIterator.hasNext()) {
|
||||
|
||||
final ParcelableKeyRing pkRing = keyListIterator.next();
|
||||
|
||||
Runnable importOperationRunnable = new Runnable() {
|
||||
|
||||
@Override
|
||||
public void run() {
|
||||
ImportKeyResult result = null;
|
||||
try {
|
||||
ImportExportOperation importExportOperation = new ImportExportOperation(
|
||||
mKeychainService,
|
||||
new ProviderHelper(mKeychainService),
|
||||
mKeyImportAccumulator.getImportProgressable(),
|
||||
mActionCanceled);
|
||||
|
||||
ArrayList<ParcelableKeyRing> list = new ArrayList<>();
|
||||
list.add(pkRing);
|
||||
|
||||
result = importExportOperation.importKeyRings(list,
|
||||
keyServer);
|
||||
} finally {
|
||||
// in the off-chance that importKeyRings does something to crash the
|
||||
// thread before it can call singleKeyRingImportCompleted, our imported
|
||||
// key count will go wrong. This will cause the service to never die,
|
||||
// and the progress dialog to stay displayed. The finally block was
|
||||
// originally meant to ensure singleKeyRingImportCompleted was called,
|
||||
// and checks for null were to be introduced, but in such a scenario,
|
||||
// knowing an uncaught error exists in importKeyRings is more important.
|
||||
|
||||
// if a null gets passed, something wrong is happening. We want a crash.
|
||||
|
||||
mKeyImportAccumulator.singleKeyRingImportCompleted(result);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
importExecutor.execute(importOperationRunnable);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to accumulate the results of individual key imports
|
||||
*/
|
||||
private class KeyImportAccumulator {
|
||||
private OperationResult.OperationLog mImportLog = new OperationResult.OperationLog();
|
||||
private int mTotalKeys;
|
||||
private int mImportedKeys = 0;
|
||||
private Progressable mInternalProgressable;
|
||||
ArrayList<Long> mImportedMasterKeyIds = new ArrayList<Long>();
|
||||
private int mBadKeys = 0;
|
||||
private int mNewKeys = 0;
|
||||
private int mUpdatedKeys = 0;
|
||||
private int mSecret = 0;
|
||||
private int mResultType = 0;
|
||||
|
||||
/**
|
||||
* meant to be used with a service due to stopSelf() in singleKeyRingImportCompleted. Remove this if
|
||||
* generalising.
|
||||
*
|
||||
* @param totalKeys total number of keys to be imported
|
||||
* @param externalProgressable the external progressable to be updated every time a key is imported
|
||||
*/
|
||||
public KeyImportAccumulator(int totalKeys, Progressable externalProgressable) {
|
||||
mTotalKeys = totalKeys;
|
||||
// ignore updates from ImportExportOperation for now
|
||||
mInternalProgressable = new Progressable() {
|
||||
@Override
|
||||
public void setProgress(String message, int current, int total) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setProgress(int resourceId, int current, int total) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setProgress(int current, int total) {
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setPreventCancel() {
|
||||
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
private synchronized void singleKeyRingImportCompleted(ImportKeyResult result) {
|
||||
// increase imported key count and accumulate log and bad, new etc. key counts from result
|
||||
mKeyImportAccumulator.accumulateKeyImport(result);
|
||||
|
||||
setProgress(mKeyImportAccumulator.getImportedKeys(), mKeyImportAccumulator.getTotalKeys());
|
||||
|
||||
if (mKeyImportAccumulator.isImportFinished()) {
|
||||
ContactSyncAdapterService.requestSync();
|
||||
|
||||
sendMessageToHandler(ServiceProgressHandler.MessageStatus.OKAY,
|
||||
mKeyImportAccumulator.getConsolidatedImportKeyResult());
|
||||
|
||||
stopSelf();//we're done here
|
||||
}
|
||||
}
|
||||
|
||||
public Progressable getImportProgressable() {
|
||||
return mInternalProgressable;
|
||||
}
|
||||
|
||||
public int getTotalKeys() {
|
||||
return mTotalKeys;
|
||||
}
|
||||
|
||||
public int getImportedKeys() {
|
||||
return mImportedKeys;
|
||||
}
|
||||
|
||||
public synchronized void accumulateKeyImport(ImportKeyResult result) {
|
||||
mImportedKeys++;
|
||||
mImportLog.addAll(result.getLog().toList());//accumulates log
|
||||
mBadKeys += result.mBadKeys;
|
||||
mNewKeys += result.mNewKeys;
|
||||
mUpdatedKeys += result.mUpdatedKeys;
|
||||
mSecret += result.mSecret;
|
||||
|
||||
long[] masterKeyIds = result.getImportedMasterKeyIds();
|
||||
for (long masterKeyId : masterKeyIds) {
|
||||
mImportedMasterKeyIds.add(masterKeyId);
|
||||
}
|
||||
|
||||
// if any key import has been cancelled, set result type to cancelled
|
||||
// resultType is added to in getConsolidatedKayImport to account for remaining factors
|
||||
mResultType |= result.getResult() & ImportKeyResult.RESULT_CANCELLED;
|
||||
}
|
||||
|
||||
/**
|
||||
* returns accumulated result of all imports so far
|
||||
*/
|
||||
public ImportKeyResult getConsolidatedImportKeyResult() {
|
||||
|
||||
// adding required information to mResultType
|
||||
// special case,no keys requested for import
|
||||
if (mBadKeys == 0 && mNewKeys == 0 && mUpdatedKeys == 0) {
|
||||
mResultType = ImportKeyResult.RESULT_FAIL_NOTHING;
|
||||
} else {
|
||||
if (mNewKeys > 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_OK_NEWKEYS;
|
||||
}
|
||||
if (mUpdatedKeys > 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_OK_UPDATED;
|
||||
}
|
||||
if (mBadKeys > 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_WITH_ERRORS;
|
||||
if (mNewKeys == 0 && mUpdatedKeys == 0) {
|
||||
mResultType |= ImportKeyResult.RESULT_ERROR;
|
||||
}
|
||||
}
|
||||
if (mImportLog.containsWarnings()) {
|
||||
mResultType |= ImportKeyResult.RESULT_WARNINGS;
|
||||
}
|
||||
}
|
||||
|
||||
long masterKeyIds[] = new long[mImportedMasterKeyIds.size()];
|
||||
for (int i = 0; i < masterKeyIds.length; i++) {
|
||||
masterKeyIds[i] = mImportedMasterKeyIds.get(i);
|
||||
}
|
||||
|
||||
return new ImportKeyResult(mResultType, mImportLog, mNewKeys, mUpdatedKeys, mBadKeys,
|
||||
mSecret, masterKeyIds);
|
||||
}
|
||||
|
||||
public boolean isImportFinished() {
|
||||
return mTotalKeys == mImportedKeys;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -35,9 +35,12 @@ import org.sufficientlysecure.keychain.keyimport.ImportKeysListEntry;
|
||||
import org.sufficientlysecure.keychain.keyimport.ParcelableKeyRing;
|
||||
import org.sufficientlysecure.keychain.operations.results.ImportKeyResult;
|
||||
import org.sufficientlysecure.keychain.operations.results.OperationResult;
|
||||
import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
|
||||
import org.sufficientlysecure.keychain.service.KeychainService;
|
||||
import org.sufficientlysecure.keychain.service.SaveKeyringParcel;
|
||||
import org.sufficientlysecure.keychain.ui.base.BaseNfcActivity;
|
||||
import org.sufficientlysecure.keychain.service.ServiceProgressHandler;
|
||||
import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
|
||||
import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
|
||||
import org.sufficientlysecure.keychain.ui.util.Notify;
|
||||
import org.sufficientlysecure.keychain.util.Log;
|
||||
@ -47,7 +50,8 @@ import org.sufficientlysecure.keychain.util.ParcelableFileCache.IteratorWithSize
|
||||
import java.io.IOException;
|
||||
import java.util.ArrayList;
|
||||
|
||||
public class ImportKeysActivity extends BaseNfcActivity {
|
||||
public class ImportKeysActivity extends BaseNfcActivity
|
||||
implements CryptoOperationHelper.Callback<ImportKeyringParcel, ImportKeyResult> {
|
||||
|
||||
public static final String ACTION_IMPORT_KEY = OpenKeychainIntents.IMPORT_KEY;
|
||||
public static final String ACTION_IMPORT_KEY_FROM_KEYSERVER = OpenKeychainIntents.IMPORT_KEY_FROM_KEYSERVER;
|
||||
@ -82,6 +86,10 @@ public class ImportKeysActivity extends BaseNfcActivity {
|
||||
private Fragment mTopFragment;
|
||||
private View mImportButton;
|
||||
|
||||
// for CryptoOperationHelper.Callback
|
||||
private String mKeyserver;
|
||||
private ArrayList<ParcelableKeyRing> mKeyList;
|
||||
|
||||
@Override
|
||||
protected void onCreate(Bundle savedInstanceState) {
|
||||
super.onCreate(savedInstanceState);
|
||||
@ -388,23 +396,10 @@ public class ImportKeysActivity extends BaseNfcActivity {
|
||||
return;
|
||||
}
|
||||
|
||||
ServiceProgressHandler serviceHandler = new ServiceProgressHandler(this) {
|
||||
@Override
|
||||
public void handleMessage(Message message) {
|
||||
// handle messages by standard KeychainIntentServiceHandler first
|
||||
super.handleMessage(message);
|
||||
|
||||
ImportKeysActivity.this.handleMessage(message);
|
||||
}
|
||||
};
|
||||
|
||||
// Send all information needed to service to import key in other thread
|
||||
Intent intent = new Intent(this, KeychainService.class);
|
||||
|
||||
intent.setAction(KeychainService.ACTION_IMPORT_KEYRING);
|
||||
|
||||
// fill values for this action
|
||||
Bundle data = new Bundle();
|
||||
CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> operationHelper
|
||||
= new CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult>(
|
||||
this, this, R.string.progress_importing
|
||||
);
|
||||
|
||||
ImportKeysListFragment.LoaderState ls = mListFragment.getLoaderState();
|
||||
if (ls instanceof ImportKeysListFragment.BytesLoaderState) {
|
||||
@ -423,30 +418,18 @@ public class ImportKeysActivity extends BaseNfcActivity {
|
||||
new ParcelableFileCache<>(this, "key_import.pcl");
|
||||
cache.writeCache(selectedEntries);
|
||||
|
||||
intent.putExtra(KeychainService.EXTRA_DATA, data);
|
||||
mKeyList = null;
|
||||
mKeyserver = null;
|
||||
operationHelper.cryptoOperation();
|
||||
|
||||
// Create a new Messenger for the communication back
|
||||
Messenger messenger = new Messenger(serviceHandler);
|
||||
intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
|
||||
|
||||
// show progress dialog
|
||||
serviceHandler.showProgressDialog(
|
||||
getString(R.string.progress_importing),
|
||||
ProgressDialog.STYLE_HORIZONTAL,
|
||||
true
|
||||
);
|
||||
|
||||
// start service with intent
|
||||
startService(intent);
|
||||
} catch (IOException e) {
|
||||
Log.e(Constants.TAG, "Problem writing cache file", e);
|
||||
Notify.create(this, "Problem writing cache file!", Notify.Style.ERROR)
|
||||
.show((ViewGroup) findViewById(R.id.import_snackbar));
|
||||
}
|
||||
} else if (ls instanceof ImportKeysListFragment.CloudLoaderState) {
|
||||
ImportKeysListFragment.CloudLoaderState sls = (ImportKeysListFragment.CloudLoaderState) ls;
|
||||
|
||||
data.putString(KeychainService.IMPORT_KEY_SERVER, sls.mCloudPrefs.keyserver);
|
||||
ImportKeysListFragment.CloudLoaderState sls =
|
||||
(ImportKeysListFragment.CloudLoaderState) ls;
|
||||
|
||||
// get selected key entries
|
||||
ArrayList<ParcelableKeyRing> keys = new ArrayList<>();
|
||||
@ -459,22 +442,11 @@ public class ImportKeysActivity extends BaseNfcActivity {
|
||||
);
|
||||
}
|
||||
}
|
||||
data.putParcelableArrayList(KeychainService.IMPORT_KEY_LIST, keys);
|
||||
|
||||
intent.putExtra(KeychainService.EXTRA_DATA, data);
|
||||
mKeyList = keys;
|
||||
mKeyserver = sls.mCloudPrefs.keyserver;
|
||||
operationHelper.cryptoOperation();
|
||||
|
||||
// Create a new Messenger for the communication back
|
||||
Messenger messenger = new Messenger(serviceHandler);
|
||||
intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger);
|
||||
|
||||
// show progress dialog
|
||||
serviceHandler.showProgressDialog(
|
||||
getString(R.string.progress_importing),
|
||||
ProgressDialog.STYLE_HORIZONTAL, true
|
||||
);
|
||||
|
||||
// start service with intent
|
||||
startService(intent);
|
||||
}
|
||||
}
|
||||
|
||||
@ -485,4 +457,26 @@ public class ImportKeysActivity extends BaseNfcActivity {
|
||||
// either way, finish afterwards
|
||||
finish();
|
||||
}
|
||||
|
||||
// methods from CryptoOperationHelper.Callback
|
||||
|
||||
@Override
|
||||
public ImportKeyringParcel createOperationInput() {
|
||||
return new ImportKeyringParcel(mKeyList, mKeyserver);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCryptoOperationSuccess(ImportKeyResult result) {
|
||||
result.createNotify(this).show();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCryptoOperationCancelled() {
|
||||
// do nothing
|
||||
}
|
||||
|
||||
@Override
|
||||
public void onCryptoOperationError(ImportKeyResult result) {
|
||||
result.createNotify(this).show();
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user