diff --git a/OpenKeychain/src/main/AndroidManifest.xml b/OpenKeychain/src/main/AndroidManifest.xml index 89bdc49ac..75d94ae69 100644 --- a/OpenKeychain/src/main/AndroidManifest.xml +++ b/OpenKeychain/src/main/AndroidManifest.xml @@ -716,6 +716,9 @@ android:name=".remote.CryptoInputParcelCacheService" android:exported="false" android:process=":remote_api" /> + diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BaseOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BaseOperation.java index 5a3321ac8..fae59b7a4 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BaseOperation.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/BaseOperation.java @@ -18,17 +18,20 @@ package org.sufficientlysecure.keychain.operations; import android.content.Context; +import android.os.Parcelable; +import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.PassphraseCacheInterface; import org.sufficientlysecure.keychain.pgp.Progressable; import org.sufficientlysecure.keychain.provider.ProviderHelper; import org.sufficientlysecure.keychain.provider.ProviderHelper.NotFoundException; import org.sufficientlysecure.keychain.service.PassphraseCacheService; +import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.util.Passphrase; import java.util.concurrent.atomic.AtomicBoolean; -public abstract class BaseOperation implements PassphraseCacheInterface { +public abstract class BaseOperation implements PassphraseCacheInterface { final public Context mContext; final public Progressable mProgressable; @@ -73,6 +76,10 @@ public abstract class BaseOperation implements PassphraseCacheInterface { mCancelled = cancelled; } + public OperationResult execute(T input, CryptoInputParcel cryptoInput) { + return null; + } + public void updateProgress(int message, int current, int total) { if (mProgressable != null) { mProgressable.setProgress(message, current, total); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/CertifyOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/CertifyOperation.java index 186d0531d..439260b74 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/CertifyOperation.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/CertifyOperation.java @@ -64,7 +64,7 @@ public class CertifyOperation extends BaseOperation { super(context, providerHelper, progressable, cancelled); } - public CertifyResult certify(CertifyActionsParcel parcel, CryptoInputParcel cryptoInput, String keyServerUri) { + public CertifyResult execute(CertifyActionsParcel parcel, CryptoInputParcel cryptoInput) { OperationLog log = new OperationLog(); log.add(LogType.MSG_CRT, 0); @@ -186,8 +186,8 @@ public class CertifyOperation extends BaseOperation { HkpKeyserver keyServer = null; ImportExportOperation importExportOperation = null; - if (keyServerUri != null) { - keyServer = new HkpKeyserver(keyServerUri); + if (parcel.keyServerUri != null) { + keyServer = new HkpKeyserver(parcel.keyServerUri); importExportOperation = new ImportExportOperation(mContext, mProviderHelper, mProgressable); } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/EditKeyOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/EditKeyOperation.java index e8e888c7a..469e386cb 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/EditKeyOperation.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/EditKeyOperation.java @@ -37,7 +37,6 @@ import org.sufficientlysecure.keychain.service.PassphraseCacheService; import org.sufficientlysecure.keychain.service.SaveKeyringParcel; import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; -import org.sufficientlysecure.keychain.util.Passphrase; import org.sufficientlysecure.keychain.util.ProgressScaler; import java.util.concurrent.atomic.AtomicBoolean; @@ -51,7 +50,7 @@ import java.util.concurrent.atomic.AtomicBoolean; * @see SaveKeyringParcel * */ -public class EditKeyOperation extends BaseOperation { +public class EditKeyOperation extends BaseOperation { public EditKeyOperation(Context context, ProviderHelper providerHelper, Progressable progressable, AtomicBoolean cancelled) { diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java index 651d15e8f..7c58d62f8 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/SignEncryptOperation.java @@ -55,7 +55,7 @@ import java.util.concurrent.atomic.AtomicBoolean; * a pending result, it will terminate. * */ -public class SignEncryptOperation extends BaseOperation { +public class SignEncryptOperation extends BaseOperation { public SignEncryptOperation(Context context, ProviderHelper providerHelper, Progressable progressable, AtomicBoolean cancelled) { diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java index 4382c9fae..fd3d41f93 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpDecryptVerify.java @@ -76,10 +76,7 @@ import java.security.SignatureException; import java.util.Date; import java.util.Iterator; -/** - * This class uses a Builder pattern! - */ -public class PgpDecryptVerify extends BaseOperation { +public class PgpDecryptVerify extends BaseOperation { public PgpDecryptVerify(Context context, ProviderHelper providerHelper, Progressable progressable) { super(context, providerHelper, progressable); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInputParcel.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInputParcel.java index fd3c4910c..fa6268758 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInputParcel.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/pgp/PgpSignEncryptInputParcel.java @@ -20,13 +20,8 @@ package org.sufficientlysecure.keychain.pgp; import org.spongycastle.bcpg.CompressionAlgorithmTags; import org.sufficientlysecure.keychain.Constants; -import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.util.Passphrase; -import java.nio.ByteBuffer; -import java.util.Date; -import java.util.Map; - import android.os.Parcel; import android.os.Parcelable; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/CertifyActionsParcel.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/CertifyActionsParcel.java index 8721f4c0c..a11f81658 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/CertifyActionsParcel.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/CertifyActionsParcel.java @@ -43,6 +43,8 @@ public class CertifyActionsParcel implements Parcelable { public ArrayList mCertifyActions = new ArrayList<>(); + public String keyServerUri; + public CertifyActionsParcel(long masterKeyId) { mMasterKeyId = masterKeyId; mLevel = CertifyLevel.DEFAULT; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainNewService.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainNewService.java new file mode 100644 index 000000000..9e33a1421 --- /dev/null +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainNewService.java @@ -0,0 +1,188 @@ +/* + * Copyright (C) 2012-2014 Dominik Schürmann + * Copyright (C) 2014 Vincent Breitmoser + * + * 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 . + */ + +package org.sufficientlysecure.keychain.service; + + +import java.util.concurrent.atomic.AtomicBoolean; + +import android.app.Service; +import android.content.Intent; +import android.os.Bundle; +import android.os.IBinder; +import android.os.Message; +import android.os.Messenger; +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.results.OperationResult; +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.provider.ProviderHelper; +import org.sufficientlysecure.keychain.service.CertifyActionsParcel.CertifyAction; +import org.sufficientlysecure.keychain.service.ServiceProgressHandler.MessageStatus; +import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; +import org.sufficientlysecure.keychain.util.Log; + +/** + * This Service contains all important long lasting operations for OpenKeychain. It receives Intents with + * data from the activities or other apps, executes them, and stops itself after doing them. + */ +public class KeychainNewService extends Service implements Progressable { + + // messenger for communication (hack) + public static final String EXTRA_MESSENGER = "messenger"; + + // extras for operation + public static final String EXTRA_OPERATION_INPUT = "op_input"; + public static final String EXTRA_CRYPTO_INPUT = "crypto_input"; + + // this attribute can possibly merged with the one above? not sure... + private AtomicBoolean mActionCanceled = new AtomicBoolean(false); + + ThreadLocal mMessenger = new ThreadLocal<>(); + + @Override + public IBinder onBind(Intent intent) { + return null; + } + + /** + * This is run on the main thread, we need to spawn a runnable which runs on another thread for the actual operation + */ + @Override + public int onStartCommand(final Intent intent, int flags, int startId) { + + Runnable actionRunnable = new Runnable() { + @Override + public void run() { + // We have not been cancelled! (yet) + mActionCanceled.set(false); + + Bundle extras = intent.getExtras(); + + // Set messenger for communication (for this particular thread) + mMessenger.set(extras.getParcelable(EXTRA_MESSENGER)); + + // Input + Parcelable inputParcel = extras.getParcelable(EXTRA_OPERATION_INPUT); + CryptoInputParcel cryptoInput = extras.getParcelable(EXTRA_CRYPTO_INPUT); + + // Operation + BaseOperation op; + + // just for brevity + KeychainNewService outerThis = KeychainNewService.this; + if (inputParcel instanceof SignEncryptParcel) { + 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); + } else if (inputParcel instanceof CertifyAction) { + op = new CertifyOperation(outerThis, new ProviderHelper(outerThis), outerThis, mActionCanceled); + } else { + return; + } + + @SuppressWarnings("unchecked") // this is unchecked, we make sure it's the correct op above! + OperationResult result = op.execute(inputParcel, cryptoInput); + + sendMessageToHandler(MessageStatus.OKAY, result); + + } + }; + + Thread actionThread = new Thread(actionRunnable); + actionThread.start(); + + return START_NOT_STICKY; + } + + private void sendMessageToHandler(MessageStatus status, Integer arg2, Bundle data) { + + Message msg = Message.obtain(); + assert msg != null; + msg.arg1 = status.ordinal(); + if (arg2 != null) { + msg.arg2 = arg2; + } + if (data != null) { + msg.setData(data); + } + + try { + mMessenger.get().send(msg); + } catch (RemoteException e) { + Log.w(Constants.TAG, "Exception sending message, Is handler present?", e); + } catch (NullPointerException e) { + Log.w(Constants.TAG, "Messenger is null!", e); + } + } + + private void sendMessageToHandler(MessageStatus status, OperationResult data) { + Bundle bundle = new Bundle(); + bundle.putParcelable(OperationResult.EXTRA_RESULT, data); + sendMessageToHandler(status, null, bundle); + } + + private void sendMessageToHandler(MessageStatus status) { + sendMessageToHandler(status, null, null); + } + + /** + * Set progress of ProgressDialog by sending message to handler on UI thread + */ + @Override + public void setProgress(String message, int progress, int max) { + Log.d(Constants.TAG, "Send message by setProgress with progress=" + progress + ", max=" + + max); + + Bundle data = new Bundle(); + if (message != null) { + data.putString(ServiceProgressHandler.DATA_MESSAGE, message); + } + data.putInt(ServiceProgressHandler.DATA_PROGRESS, progress); + data.putInt(ServiceProgressHandler.DATA_PROGRESS_MAX, max); + + sendMessageToHandler(MessageStatus.UPDATE_PROGRESS, null, data); + } + + @Override + public void setProgress(int resourceId, int progress, int max) { + setProgress(getString(resourceId), progress, max); + } + + @Override + public void setProgress(int progress, int max) { + setProgress(null, progress, max); + } + + @Override + public void setPreventCancel() { + sendMessageToHandler(MessageStatus.PREVENT_CANCEL); + } + +} diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainService.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainService.java index b8cb9de27..ba877c2a2 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainService.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainService.java @@ -96,14 +96,9 @@ public class KeychainService extends Service implements Progressable { public static final String EXTRA_DATA = "data"; /* possible actions */ - public static final String ACTION_SIGN_ENCRYPT = Constants.INTENT_PREFIX + "SIGN_ENCRYPT"; - - public static final String ACTION_DECRYPT_VERIFY = Constants.INTENT_PREFIX + "DECRYPT_VERIFY"; public static final String ACTION_VERIFY_KEYBASE_PROOF = Constants.INTENT_PREFIX + "VERIFY_KEYBASE_PROOF"; - public static final String ACTION_DECRYPT_METADATA = Constants.INTENT_PREFIX + "DECRYPT_METADATA"; - public static final String ACTION_EDIT_KEYRING = Constants.INTENT_PREFIX + "EDIT_KEYRING"; public static final String ACTION_PROMOTE_KEYRING = Constants.INTENT_PREFIX + "PROMOTE_KEYRING"; @@ -113,8 +108,6 @@ public class KeychainService extends Service implements Progressable { public static final String ACTION_UPLOAD_KEYRING = Constants.INTENT_PREFIX + "UPLOAD_KEYRING"; - public static final String ACTION_CERTIFY_KEYRING = Constants.INTENT_PREFIX + "SIGN_KEYRING"; - public static final String ACTION_DELETE = Constants.INTENT_PREFIX + "DELETE"; public static final String ACTION_CONSOLIDATE = Constants.INTENT_PREFIX + "CONSOLIDATE"; @@ -123,14 +116,6 @@ public class KeychainService extends Service implements Progressable { /* keys for data bundle */ - // encrypt - public static final String ENCRYPT_DECRYPT_INPUT_URI = "input_uri"; - public static final String ENCRYPT_DECRYPT_OUTPUT_URI = "output_uri"; - public static final String SIGN_ENCRYPT_PARCEL = "sign_encrypt_parcel"; - - // decrypt/verify - public static final String DECRYPT_VERIFY_PARCEL = "decrypt_verify_parcel"; - // keybase proof public static final String KEYBASE_REQUIRED_FINGERPRINT = "keybase_required_fingerprint"; public static final String KEYBASE_PROOF = "keybase_proof"; @@ -158,9 +143,6 @@ public class KeychainService extends Service implements Progressable { // upload key public static final String UPLOAD_KEY_SERVER = "upload_key_server"; - // certify key - public static final String CERTIFY_PARCEL = "certify_parcel"; - // promote key public static final String PROMOTE_MASTER_KEY_ID = "promote_master_key_id"; public static final String PROMOTE_CARD_AID = "promote_card_aid"; @@ -232,23 +214,6 @@ public class KeychainService extends Service implements Progressable { // executeServiceMethod action from extra bundle switch (action) { - case ACTION_CERTIFY_KEYRING: { - - // Input - CertifyActionsParcel parcel = data.getParcelable(CERTIFY_PARCEL); - CryptoInputParcel cryptoInput = data.getParcelable(EXTRA_CRYPTO_INPUT); - String keyServerUri = data.getString(UPLOAD_KEY_SERVER); - - // Operation - CertifyOperation op = new CertifyOperation(mKeychainService, providerHelper, mKeychainService, - mActionCanceled); - CertifyResult result = op.certify(parcel, cryptoInput, keyServerUri); - - // Result - sendMessageToHandler(MessageStatus.OKAY, result); - - break; - } case ACTION_CONSOLIDATE: { // Operation @@ -264,24 +229,6 @@ public class KeychainService extends Service implements Progressable { break; } - case ACTION_DECRYPT_METADATA: { - - // Input - CryptoInputParcel cryptoInput = data.getParcelable(EXTRA_CRYPTO_INPUT); - PgpDecryptVerifyInputParcel input = data.getParcelable(DECRYPT_VERIFY_PARCEL); - - // this action is here for compatibility only - input.setDecryptMetadataOnly(true); - - // Operation - PgpDecryptVerify op = new PgpDecryptVerify(mKeychainService, providerHelper, mKeychainService); - DecryptVerifyResult decryptVerifyResult = op.execute(input, cryptoInput); - - // Result - sendMessageToHandler(MessageStatus.OKAY, decryptVerifyResult); - - break; - } case ACTION_VERIFY_KEYBASE_PROOF: { try { @@ -376,25 +323,6 @@ public class KeychainService extends Service implements Progressable { break; } - case ACTION_DECRYPT_VERIFY: { - - // Input - CryptoInputParcel cryptoInput = data.getParcelable(EXTRA_CRYPTO_INPUT); - PgpDecryptVerifyInputParcel input = data.getParcelable(DECRYPT_VERIFY_PARCEL); - - // for compatibility - // TODO merge with ACTION_DECRYPT_METADATA - input.setDecryptMetadataOnly(false); - - // Operation - PgpDecryptVerify op = new PgpDecryptVerify(mKeychainService, providerHelper, mKeychainService); - DecryptVerifyResult decryptVerifyResult = op.execute(input, cryptoInput); - - // Output - sendMessageToHandler(MessageStatus.OKAY, decryptVerifyResult); - - break; - } case ACTION_DELETE: { // Input @@ -495,22 +423,6 @@ public class KeychainService extends Service implements Progressable { break; } - case ACTION_SIGN_ENCRYPT: { - - // Input - SignEncryptParcel inputParcel = data.getParcelable(SIGN_ENCRYPT_PARCEL); - CryptoInputParcel cryptoInput = data.getParcelable(EXTRA_CRYPTO_INPUT); - - // Operation - SignEncryptOperation op = new SignEncryptOperation( - mKeychainService, providerHelper, mKeychainService, mActionCanceled); - SignEncryptResult result = op.execute(inputParcel, cryptoInput); - - // Result - sendMessageToHandler(MessageStatus.OKAY, result); - - break; - } case ACTION_UPLOAD_KEYRING: { try { diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ServiceProgressHandler.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ServiceProgressHandler.java index a0bb250d4..76aa1a618 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ServiceProgressHandler.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ServiceProgressHandler.java @@ -17,8 +17,7 @@ package org.sufficientlysecure.keychain.service; -import android.app.Activity; -import android.content.Intent; +import android.app.ProgressDialog; import android.os.Bundle; import android.os.Handler; import android.os.Message; @@ -27,7 +26,6 @@ import android.support.v4.app.FragmentManager; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; -import org.sufficientlysecure.keychain.operations.results.CertifyResult; import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.util.Log; @@ -65,68 +63,58 @@ public class ServiceProgressHandler extends Handler { public static final String KEYBASE_PRESENCE_URL = "keybase_presence_url"; public static final String KEYBASE_PRESENCE_LABEL = "keybase_presence_label"; - Activity mActivity; - ProgressDialogFragment mProgressDialogFragment; + FragmentActivity mActivity; - public ServiceProgressHandler(Activity activity) { - this.mActivity = activity; + public ServiceProgressHandler(FragmentActivity activity) { + mActivity = activity; } - public ServiceProgressHandler(Activity activity, ProgressDialogFragment progressDialogFragment) { - this.mActivity = activity; - this.mProgressDialogFragment = progressDialogFragment; + public void showProgressDialog() { + showProgressDialog("", ProgressDialog.STYLE_SPINNER, false); } - public ServiceProgressHandler(Activity activity, String progressDialogMessage, int progressDialogStyle) { - this(activity, progressDialogMessage, progressDialogStyle, false); - } + public void showProgressDialog( + String progressDialogMessage, int progressDialogStyle, boolean cancelable) { - public ServiceProgressHandler(Activity activity, - String progressDialogMessage, - int progressDialogStyle, - boolean cancelable) { - this.mActivity = activity; - this.mProgressDialogFragment = ProgressDialogFragment.newInstance( + final ProgressDialogFragment frag = ProgressDialogFragment.newInstance( progressDialogMessage, progressDialogStyle, cancelable); - } - - public void showProgressDialog(FragmentActivity activity) { - if (mProgressDialogFragment == null) { - return; - } // TODO: This is a hack!, see // http://stackoverflow.com/questions/10114324/show-dialogfragment-from-onactivityresult - final FragmentManager manager = activity.getSupportFragmentManager(); + final FragmentManager manager = mActivity.getSupportFragmentManager(); Handler handler = new Handler(); handler.post(new Runnable() { public void run() { - mProgressDialogFragment.show(manager, "progressDialog"); + frag.show(manager, "progressDialog"); } }); + } @Override public void handleMessage(Message message) { Bundle data = message.getData(); - if (mProgressDialogFragment == null) { - // Log.e(Constants.TAG, - // "Progress has not been updated because mProgressDialogFragment was null!"); + ProgressDialogFragment progressDialogFragment = + (ProgressDialogFragment) mActivity.getSupportFragmentManager() + .findFragmentByTag("progressDialog"); + + if (progressDialogFragment == null) { + Log.e(Constants.TAG, "Progress has not been updated because mProgressDialogFragment was null!"); return; } MessageStatus status = MessageStatus.fromInt(message.arg1); switch (status) { case OKAY: - mProgressDialogFragment.dismissAllowingStateLoss(); + progressDialogFragment.dismissAllowingStateLoss(); break; case EXCEPTION: - mProgressDialogFragment.dismissAllowingStateLoss(); + progressDialogFragment.dismissAllowingStateLoss(); // show error from service if (data.containsKey(DATA_ERROR)) { @@ -142,13 +130,13 @@ public class ServiceProgressHandler extends Handler { // update progress from service if (data.containsKey(DATA_MESSAGE)) { - mProgressDialogFragment.setProgress(data.getString(DATA_MESSAGE), + progressDialogFragment.setProgress(data.getString(DATA_MESSAGE), data.getInt(DATA_PROGRESS), data.getInt(DATA_PROGRESS_MAX)); } else if (data.containsKey(DATA_MESSAGE_ID)) { - mProgressDialogFragment.setProgress(data.getInt(DATA_MESSAGE_ID), + progressDialogFragment.setProgress(data.getInt(DATA_MESSAGE_ID), data.getInt(DATA_PROGRESS), data.getInt(DATA_PROGRESS_MAX)); } else { - mProgressDialogFragment.setProgress(data.getInt(DATA_PROGRESS), + progressDialogFragment.setProgress(data.getInt(DATA_PROGRESS), data.getInt(DATA_PROGRESS_MAX)); } } @@ -156,7 +144,7 @@ public class ServiceProgressHandler extends Handler { break; case PREVENT_CANCEL: - mProgressDialogFragment.setPreventCancel(true); + progressDialogFragment.setPreventCancel(true); break; default: diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java index 6afe2256b..e39a3a0bf 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CertifyKeyFragment.java @@ -64,7 +64,8 @@ import org.sufficientlysecure.keychain.util.Preferences; import java.util.ArrayList; -public class CertifyKeyFragment extends CachingCryptoOperationFragment +public class CertifyKeyFragment + extends CachingCryptoOperationFragment implements LoaderManager.LoaderCallbacks { public static final String ARG_CHECK_STATES = "check_states"; @@ -89,7 +90,6 @@ public class CertifyKeyFragment extends CachingCryptoOperationFragment checkedStates; if (savedInstanceState != null) { checkedStates = (ArrayList) savedInstanceState.getSerializable(ARG_CHECK_STATES); @@ -306,97 +302,39 @@ public class CertifyKeyFragment extends CachingCryptoOperationFragment certifyActions = mUserIdsAdapter.getSelectedCertifyActions(); - if (certifyActions.isEmpty()) { - Notify.create(getActivity(), "No identities selected!", - Notify.Style.ERROR).show(); - return; - } - - long selectedKeyId = mCertifyKeySpinner.getSelectedKeyId(); - - // fill values for this action - actionsParcel = new CertifyActionsParcel(selectedKeyId); - actionsParcel.mCertifyActions.addAll(certifyActions); - - // cached for next cryptoOperation loop - cacheActionsParcel(actionsParcel); - } - - data.putParcelable(KeychainService.EXTRA_CRYPTO_INPUT, cryptoInput); - data.putParcelable(KeychainService.CERTIFY_PARCEL, actionsParcel); - - if (mUploadKeyCheckbox.isChecked()) { - String keyserver = Preferences.getPreferences(getActivity()).getPreferredKeyserver(); - data.putString(KeychainService.UPLOAD_KEY_SERVER, keyserver); - } + // Bail out if there is not at least one user id selected + ArrayList certifyActions = mUserIdsAdapter.getSelectedCertifyActions(); + if (certifyActions.isEmpty()) { + Notify.create(getActivity(), "No identities selected!", + Notify.Style.ERROR).show(); + return null; } - // Send all information needed to service to sign key in other thread - Intent intent = new Intent(getActivity(), KeychainService.class); - intent.setAction(KeychainService.ACTION_CERTIFY_KEYRING); - intent.putExtra(KeychainService.EXTRA_DATA, data); + long selectedKeyId = mCertifyKeySpinner.getSelectedKeyId(); - if (mPassthroughMessenger != null) { - intent.putExtra(KeychainService.EXTRA_MESSENGER, mPassthroughMessenger); - } else { + // fill values for this action + CertifyActionsParcel actionsParcel = new CertifyActionsParcel(selectedKeyId); + actionsParcel.mCertifyActions.addAll(certifyActions); - // Message is received after signing is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_certifying), - ProgressDialog.STYLE_SPINNER, - true - ) { - @Override - public void handleMessage(Message message) { - // handle messages by KeychainIntentCryptoServiceHandler first - super.handleMessage(message); + // cached for next cryptoOperation loop + cacheActionsParcel(actionsParcel); - // handle pending messages - if (handlePendingMessage(message)) { - return; - } - - if (message.arg1 == MessageStatus.OKAY.ordinal()) { - Bundle data = message.getData(); - - CertifyResult result = data.getParcelable(CertifyResult.EXTRA_RESULT); - - Intent intent = new Intent(); - intent.putExtra(CertifyResult.EXTRA_RESULT, result); - getActivity().setResult(Activity.RESULT_OK, intent); - getActivity().finish(); - } - } - }; - - // Create a new Messenger for the communication back - Messenger messenger = new Messenger(saveHandler); - intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - } - - // start service with intent - getActivity().startService(intent); - - if (mPassthroughMessenger != null) { - getActivity().setResult(Activity.RESULT_OK); - getActivity().finish(); - } + return actionsParcel; + } + @Override + protected void onCryptoOperationSuccess(CertifyResult result) { + Intent intent = new Intent(); + intent.putExtra(CertifyResult.EXTRA_RESULT, result); + getActivity().setResult(Activity.RESULT_OK, intent); + getActivity().finish(); } @Override protected void onCryptoOperationCancelled() { super.onCryptoOperationCancelled(); } + } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ConsolidateDialogActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ConsolidateDialogActivity.java index 054e43f21..6a9bb7b11 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ConsolidateDialogActivity.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ConsolidateDialogActivity.java @@ -49,11 +49,7 @@ public class ConsolidateDialogActivity extends FragmentActivity { private void consolidateRecovery(boolean recovery) { // Message is received after importing is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - this, - getString(R.string.progress_importing), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(this) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -94,7 +90,10 @@ public class ConsolidateDialogActivity extends FragmentActivity { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - saveHandler.showProgressDialog(this); + saveHandler.showProgressDialog( + getString(R.string.progress_importing), + ProgressDialog.STYLE_HORIZONTAL, false + ); // start service with intent startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java index b39064e20..ebbd01afe 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyFinalFragment.java @@ -197,11 +197,7 @@ public class CreateKeyFinalFragment extends Fragment { Intent intent = new Intent(getActivity(), KeychainService.class); intent.setAction(KeychainService.ACTION_EDIT_KEYRING); - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_building_key), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -245,7 +241,8 @@ public class CreateKeyFinalFragment extends Fragment { Messenger messenger = new Messenger(saveHandler); intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - saveHandler.showProgressDialog(getActivity()); + saveHandler.showProgressDialog(getString(R.string.progress_building_key), + ProgressDialog.STYLE_HORIZONTAL, false); getActivity().startService(intent); } @@ -271,11 +268,7 @@ public class CreateKeyFinalFragment extends Fragment { intent.putExtra(KeychainService.EXTRA_DATA, data); - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_uploading), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -301,10 +294,13 @@ public class CreateKeyFinalFragment extends Fragment { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - saveHandler.showProgressDialog(getActivity()); + saveHandler.showProgressDialog( + getString(R.string.progress_uploading), + ProgressDialog.STYLE_HORIZONTAL, false); // start service with intent getActivity().startService(intent); + } } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyYubiKeyImportFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyYubiKeyImportFragment.java index ba8e8321a..2ab8c5967 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyYubiKeyImportFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/CreateKeyYubiKeyImportFragment.java @@ -176,11 +176,7 @@ public class CreateKeyYubiKeyImportFragment extends Fragment implements NfcListe public void importKey() { // Message is received after decrypting is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_importing), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -243,7 +239,10 @@ public class CreateKeyYubiKeyImportFragment extends Fragment implements NfcListe Messenger messenger = new Messenger(saveHandler); intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - saveHandler.showProgressDialog(getActivity()); + saveHandler.showProgressDialog( + getString(R.string.progress_importing), + ProgressDialog.STYLE_HORIZONTAL, false + ); // start service with intent getActivity().startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java index b2d9596fd..bc7705233 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFilesFragment.java @@ -63,8 +63,6 @@ public class DecryptFilesFragment extends DecryptFragment { private Uri mInputUri = null; private Uri mOutputUri = null; - private String mCurrentCryptoOperation; - /** * Creates new instance of this fragment */ @@ -151,7 +149,7 @@ public class DecryptFilesFragment extends DecryptFragment { return; } - startDecryptFilenames(); + cryptoOperation(); } private String removeEncryptedAppend(String name) { @@ -179,112 +177,6 @@ public class DecryptFilesFragment extends DecryptFragment { } } - private void startDecrypt() { - mCurrentCryptoOperation = KeychainService.ACTION_DECRYPT_VERIFY; - cryptoOperation(new CryptoInputParcel()); - } - - private void startDecryptFilenames() { - mCurrentCryptoOperation = KeychainService.ACTION_DECRYPT_METADATA; - cryptoOperation(new CryptoInputParcel()); - } - - @Override - @SuppressLint("HandlerLeak") - protected void cryptoOperation(CryptoInputParcel cryptoInput) { - // Send all information needed to service to decrypt in other thread - Intent intent = new Intent(getActivity(), KeychainService.class); - - // fill values for this action - Bundle data = new Bundle(); - // use current operation, either decrypt metadata or decrypt payload - intent.setAction(mCurrentCryptoOperation); - - // data - - Log.d(Constants.TAG, "mInputUri=" + mInputUri + ", mOutputUri=" + mOutputUri); - - PgpDecryptVerifyInputParcel input = new PgpDecryptVerifyInputParcel(mInputUri, mOutputUri) - .setAllowSymmetricDecryption(true); - - data.putParcelable(KeychainService.DECRYPT_VERIFY_PARCEL, input); - data.putParcelable(KeychainService.EXTRA_CRYPTO_INPUT, cryptoInput); - - intent.putExtra(KeychainService.EXTRA_DATA, data); - - // Message is received after decrypting is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_decrypting), - ProgressDialog.STYLE_HORIZONTAL - ) { - @Override - public void handleMessage(Message message) { - // handle messages by standard KeychainIntentServiceHandler first - super.handleMessage(message); - - // handle pending messages - if (handlePendingMessage(message)) { - return; - } - - if (message.arg1 == MessageStatus.OKAY.ordinal()) { - // get returned data bundle - Bundle returnData = message.getData(); - - DecryptVerifyResult pgpResult = - returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT); - - if (pgpResult.success()) { - switch (mCurrentCryptoOperation) { - case KeychainService.ACTION_DECRYPT_METADATA: { - askForOutputFilename(pgpResult.getDecryptMetadata().getFilename()); - break; - } - case KeychainService.ACTION_DECRYPT_VERIFY: { - // display signature result in activity - loadVerifyResult(pgpResult); - - if (mDeleteAfter.isChecked()) { - // Create and show dialog to delete original file - DeleteFileDialogFragment deleteFileDialog = DeleteFileDialogFragment.newInstance(mInputUri); - deleteFileDialog.show(getActivity().getSupportFragmentManager(), "deleteDialog"); - setInputUri(null); - } - - /* - // A future open after decryption feature - if () { - Intent viewFile = new Intent(Intent.ACTION_VIEW); - viewFile.setInputData(mOutputUri); - startActivity(viewFile); - } - */ - break; - } - default: { - Log.e(Constants.TAG, "Bug: not supported operation!"); - break; - } - } - } - pgpResult.createNotify(getActivity()).show(DecryptFilesFragment.this); - } - - } - }; - - // Create a new Messenger for the communication back - Messenger messenger = new Messenger(saveHandler); - intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - - // start service with intent - getActivity().startService(intent); - } - @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { switch (requestCode) { @@ -299,7 +191,7 @@ public class DecryptFilesFragment extends DecryptFragment { // This happens after output file was selected, so start our operation if (resultCode == Activity.RESULT_OK && data != null) { mOutputUri = data.getData(); - startDecrypt(); + cryptoOperation(); } return; } @@ -314,4 +206,20 @@ public class DecryptFilesFragment extends DecryptFragment { protected void onVerifyLoaded(boolean hideErrorOverlay) { } + + @Override + protected PgpDecryptVerifyInputParcel createOperationInput() { + return new PgpDecryptVerifyInputParcel(mInputUri, mOutputUri).setAllowSymmetricDecryption(true); + } + + @Override + protected void onCryptoOperationSuccess(DecryptVerifyResult result) { + + // display signature result in activity + loadVerifyResult(result); + + // TODO delete after decrypt not implemented! + + } + } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java index 3d87ce894..0626326fc 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptFragment.java @@ -43,12 +43,14 @@ import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult; import org.sufficientlysecure.keychain.operations.results.ImportKeyResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.pgp.KeyRing; +import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyInputParcel; import org.sufficientlysecure.keychain.pgp.exception.PgpKeyNotFoundException; import org.sufficientlysecure.keychain.provider.KeychainContract; import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings; import org.sufficientlysecure.keychain.provider.ProviderHelper; import org.sufficientlysecure.keychain.service.KeychainService; import org.sufficientlysecure.keychain.service.ServiceProgressHandler; +import org.sufficientlysecure.keychain.ui.base.CachingCryptoOperationFragment; import org.sufficientlysecure.keychain.ui.base.CryptoOperationFragment; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils; import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils.State; @@ -56,8 +58,9 @@ import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.Style; import org.sufficientlysecure.keychain.util.Preferences; -public abstract class DecryptFragment extends CryptoOperationFragment implements - LoaderManager.LoaderCallbacks { +public abstract class DecryptFragment + extends CachingCryptoOperationFragment + implements LoaderManager.LoaderCallbacks { public static final int LOADER_ID_UNIFIED = 0; public static final String ARG_DECRYPT_VERIFY_RESULT = "decrypt_verify_result"; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java index b7ea90a36..1dcda5b8d 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/DecryptTextFragment.java @@ -17,11 +17,8 @@ package org.sufficientlysecure.keychain.ui; -import android.app.ProgressDialog; import android.content.Intent; import android.os.Bundle; -import android.os.Message; -import android.os.Messenger; import android.view.LayoutInflater; import android.view.Menu; import android.view.MenuInflater; @@ -35,9 +32,6 @@ import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.compatibility.ClipboardReflection; import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult; import org.sufficientlysecure.keychain.pgp.PgpDecryptVerifyInputParcel; -import org.sufficientlysecure.keychain.service.KeychainService; -import org.sufficientlysecure.keychain.service.ServiceProgressHandler; -import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.util.ShareHelper; @@ -115,7 +109,7 @@ public class DecryptTextFragment extends DecryptFragment { mShowMenuOptions = args.getBoolean(ARG_SHOW_MENU, false); if (savedInstanceState == null) { - cryptoOperation(new CryptoInputParcel()); + cryptoOperation(); } } @@ -158,77 +152,8 @@ public class DecryptTextFragment extends DecryptFragment { } @Override - protected void cryptoOperation(CryptoInputParcel cryptoInput) { - // Send all information needed to service to decrypt in other thread - Intent intent = new Intent(getActivity(), KeychainService.class); - - // fill values for this action - Bundle data = new Bundle(); - - intent.setAction(KeychainService.ACTION_DECRYPT_VERIFY); - - PgpDecryptVerifyInputParcel input = new PgpDecryptVerifyInputParcel(mCiphertext.getBytes()); - data.putParcelable(KeychainService.DECRYPT_VERIFY_PARCEL, input); - data.putParcelable(KeychainService.EXTRA_CRYPTO_INPUT, cryptoInput); - - intent.putExtra(KeychainService.EXTRA_DATA, data); - - // Message is received after encrypting is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_decrypting), - ProgressDialog.STYLE_HORIZONTAL - ) { - public void handleMessage(Message message) { - // handle messages by standard KeychainIntentServiceHandler first - super.handleMessage(message); - - // handle pending messages - if (handlePendingMessage(message)) { - return; - } - - if (message.arg1 == MessageStatus.OKAY.ordinal()) { - // get returned data bundle - Bundle returnData = message.getData(); - - DecryptVerifyResult pgpResult = - returnData.getParcelable(DecryptVerifyResult.EXTRA_RESULT); - - if (pgpResult.success()) { - byte[] decryptedMessage = pgpResult.getOutputBytes(); - String displayMessage; - if (pgpResult.getCharset() != null) { - try { - displayMessage = new String(decryptedMessage, pgpResult.getCharset()); - } catch (UnsupportedEncodingException e) { - // if we can't decode properly, just fall back to utf-8 - displayMessage = new String(decryptedMessage); - } - } else { - displayMessage = new String(decryptedMessage); - } - mText.setText(displayMessage); - - // display signature result in activity - loadVerifyResult(pgpResult); - } else { - // TODO: show also invalid layout with different text? - } - pgpResult.createNotify(getActivity()).show(DecryptTextFragment.this); - } - } - }; - - // Create a new Messenger for the communication back - Messenger messenger = new Messenger(saveHandler); - intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - - // start service with intent - getActivity().startService(intent); + protected PgpDecryptVerifyInputParcel createOperationInput() { + return new PgpDecryptVerifyInputParcel(mCiphertext.getBytes()); } @Override @@ -236,4 +161,27 @@ public class DecryptTextFragment extends DecryptFragment { mShowMenuOptions = hideErrorOverlay; getActivity().supportInvalidateOptionsMenu(); } + + @Override + protected void onCryptoOperationSuccess(DecryptVerifyResult result) { + + byte[] decryptedMessage = result.getOutputBytes(); + String displayMessage; + if (result.getCharset() != null) { + try { + displayMessage = new String(decryptedMessage, result.getCharset()); + } catch (UnsupportedEncodingException e) { + // if we can't decode properly, just fall back to utf-8 + displayMessage = new String(decryptedMessage); + } + } else { + displayMessage = new String(decryptedMessage); + } + mText.setText(displayMessage); + + // display signature result in activity + loadVerifyResult(result); + + } + } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java index 63fb8413b..48aa3016d 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EditKeyFragment.java @@ -26,6 +26,7 @@ import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.os.Messenger; +import android.os.Parcelable; import android.support.v4.app.LoaderManager; import android.support.v4.content.CursorLoader; import android.support.v4.content.Loader; @@ -39,6 +40,9 @@ import android.widget.ListView; import org.sufficientlysecure.keychain.Constants; import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.compatibility.DialogFragmentWorkaround; +import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult; +import org.sufficientlysecure.keychain.operations.results.EditKeyResult; +import org.sufficientlysecure.keychain.operations.results.InputPendingResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; import org.sufficientlysecure.keychain.operations.results.OperationResult.LogType; import org.sufficientlysecure.keychain.operations.results.SingletonResult; @@ -66,9 +70,8 @@ import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.util.Log; import org.sufficientlysecure.keychain.util.Passphrase; - -public class EditKeyFragment extends CryptoOperationFragment implements - LoaderManager.LoaderCallbacks { +public class EditKeyFragment extends CryptoOperationFragment + implements LoaderManager.LoaderCallbacks { public static final String ARG_DATA_URI = "uri"; public static final String ARG_SAVE_KEYRING_PARCEL = "save_keyring_parcel"; @@ -572,7 +575,7 @@ public class EditKeyFragment extends CryptoOperationFragment implements addSubkeyDialogFragment.show(getActivity().getSupportFragmentManager(), "addSubkeyDialog"); } - private void returnKeyringParcel() { + protected void returnKeyringParcel() { if (mSaveKeyringParcel.mAddUserIds.size() == 0) { Notify.create(getActivity(), R.string.edit_key_error_add_identity, Notify.Style.ERROR).show(); return; @@ -591,76 +594,6 @@ public class EditKeyFragment extends CryptoOperationFragment implements getActivity().finish(); } - @Override - protected void cryptoOperation(CryptoInputParcel cryptoInput) { - - Log.d(Constants.TAG, "cryptoInput:\n" + cryptoInput); - Log.d(Constants.TAG, "mSaveKeyringParcel:\n" + mSaveKeyringParcel); - - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_saving), - ProgressDialog.STYLE_HORIZONTAL, - true - ) { - public void handleMessage(Message message) { - // handle messages by standard KeychainIntentServiceHandler first - super.handleMessage(message); - - if (handlePendingMessage(message)) { - return; - } - - if (message.arg1 == MessageStatus.OKAY.ordinal()) { - - // get returned data bundle - Bundle returnData = message.getData(); - if (returnData == null) { - return; - } - final OperationResult result = - returnData.getParcelable(OperationResult.EXTRA_RESULT); - if (result == null) { - return; - } - - // if bad -> display here! - if (!result.success()) { - result.createNotify(getActivity()).show(); - return; - } - - // if good -> finish, return result to showkey and display there! - Intent intent = new Intent(); - intent.putExtra(OperationResult.EXTRA_RESULT, result); - getActivity().setResult(EditKeyActivity.RESULT_OK, intent); - getActivity().finish(); - - } - } - }; - - // Send all information needed to service to import key in other thread - Intent intent = new Intent(getActivity(), KeychainService.class); - intent.setAction(KeychainService.ACTION_EDIT_KEYRING); - - // fill values for this action - Bundle data = new Bundle(); - data.putParcelable(KeychainService.EXTRA_CRYPTO_INPUT, cryptoInput); - data.putParcelable(KeychainService.EDIT_KEYRING_PARCEL, mSaveKeyringParcel); - intent.putExtra(KeychainService.EXTRA_DATA, data); - - // Create a new Messenger for the communication back - Messenger messenger = new Messenger(saveHandler); - intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - - // show progress dialog - saveHandler.showProgressDialog(getActivity()); - - // start service with intent - getActivity().startService(intent); - } - /** * Closes this activity, returning a result parcel with a single error log entry. */ @@ -675,4 +608,20 @@ public class EditKeyFragment extends CryptoOperationFragment implements getActivity().finish(); } + @Override + protected SaveKeyringParcel createOperationInput() { + return mSaveKeyringParcel; + } + + @Override + protected void onCryptoOperationSuccess(OperationResult result) { + + // if good -> finish, return result to showkey and display there! + Intent intent = new Intent(); + intent.putExtra(OperationResult.EXTRA_RESULT, result); + getActivity().setResult(EditKeyActivity.RESULT_OK, intent); + getActivity().finish(); + + } + } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java index ddfdecca3..d290c57a6 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptFilesFragment.java @@ -18,7 +18,6 @@ package org.sufficientlysecure.keychain.ui; import android.app.Activity; -import android.app.ProgressDialog; import android.content.Context; import android.content.Intent; import android.graphics.Bitmap; @@ -26,8 +25,6 @@ import android.graphics.Point; import android.net.Uri; import android.os.Build; import android.os.Bundle; -import android.os.Message; -import android.os.Messenger; import android.support.v7.widget.DefaultItemAnimator; import android.support.v7.widget.LinearLayoutManager; import android.support.v7.widget.RecyclerView; @@ -49,9 +46,6 @@ import org.sufficientlysecure.keychain.pgp.KeyRing; import org.sufficientlysecure.keychain.pgp.PgpConstants; import org.sufficientlysecure.keychain.pgp.SignEncryptParcel; import org.sufficientlysecure.keychain.provider.TemporaryStorageProvider; -import org.sufficientlysecure.keychain.service.KeychainService; -import org.sufficientlysecure.keychain.service.ServiceProgressHandler; -import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.ui.adapter.SpacesItemDecoration; import org.sufficientlysecure.keychain.ui.base.CachingCryptoOperationFragment; import org.sufficientlysecure.keychain.ui.dialog.DeleteFileDialogFragment; @@ -72,7 +66,8 @@ import java.util.HashSet; import java.util.List; import java.util.Set; -public class EncryptFilesFragment extends CachingCryptoOperationFragment { +public class EncryptFilesFragment + extends CachingCryptoOperationFragment { public static final String ARG_DELETE_AFTER_ENCRYPT = "delete_after_encrypt"; public static final String ARG_ENCRYPT_FILENAMES = "encrypt_filenames"; @@ -272,11 +267,13 @@ public class EncryptFilesFragment extends CachingCryptoOperationFragment(1); mOutputUris.add(data.getData()); - cryptoOperation(false); + mShareAfterEncrypt = false; + cryptoOperation(); } return; } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java index e206169bb..83fede917 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/EncryptTextFragment.java @@ -18,11 +18,8 @@ package org.sufficientlysecure.keychain.ui; import android.app.Activity; -import android.app.ProgressDialog; import android.content.Intent; import android.os.Bundle; -import android.os.Message; -import android.os.Messenger; import android.text.Editable; import android.text.TextWatcher; import android.view.LayoutInflater; @@ -41,9 +38,6 @@ import org.sufficientlysecure.keychain.operations.results.SignEncryptResult; import org.sufficientlysecure.keychain.pgp.KeyRing; import org.sufficientlysecure.keychain.pgp.PgpConstants; import org.sufficientlysecure.keychain.pgp.SignEncryptParcel; -import org.sufficientlysecure.keychain.service.KeychainService; -import org.sufficientlysecure.keychain.service.ServiceProgressHandler; -import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.ui.base.CachingCryptoOperationFragment; import org.sufficientlysecure.keychain.ui.util.Notify; import org.sufficientlysecure.keychain.ui.util.Notify.ActionListener; @@ -55,7 +49,8 @@ import org.sufficientlysecure.keychain.util.ShareHelper; import java.util.HashSet; import java.util.Set; -public class EncryptTextFragment extends CachingCryptoOperationFragment { +public class EncryptTextFragment + extends CachingCryptoOperationFragment { public static final String ARG_TEXT = "text"; public static final String ARG_USE_COMPRESSION = "use_compression"; @@ -145,6 +140,7 @@ public class EncryptTextFragment extends CachingCryptoOperationFragment keyRings) { // Message is received after importing is done in KeychainService - ServiceProgressHandler serviceHandler = new ServiceProgressHandler( - this, - getString(R.string.progress_importing), - ProgressDialog.STYLE_HORIZONTAL, - true - ) { + ServiceProgressHandler serviceHandler = new ServiceProgressHandler(this) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -273,7 +268,9 @@ public class ImportKeysProxyActivity extends FragmentActivity { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - serviceHandler.showProgressDialog(this); + serviceHandler.showProgressDialog( + getString(R.string.progress_importing), + ProgressDialog.STYLE_HORIZONTAL, true); // start service with intent startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java index ddc527847..36074f6ba 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java @@ -572,12 +572,7 @@ public class KeyListFragment extends LoaderFragment keyList.add(keyEntry); } - ServiceProgressHandler serviceHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_updating), - ProgressDialog.STYLE_HORIZONTAL, - true - ) { + ServiceProgressHandler serviceHandler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -625,7 +620,9 @@ public class KeyListFragment extends LoaderFragment intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - serviceHandler.showProgressDialog(getActivity()); + serviceHandler.showProgressDialog( + getString(R.string.progress_updating), + ProgressDialog.STYLE_HORIZONTAL, true); // start service with intent getActivity().startService(intent); @@ -633,11 +630,7 @@ public class KeyListFragment extends LoaderFragment private void consolidate() { // Message is received after importing is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_importing), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -675,7 +668,9 @@ public class KeyListFragment extends LoaderFragment intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - saveHandler.showProgressDialog(getActivity()); + saveHandler.showProgressDialog( + getString(R.string.progress_importing), + ProgressDialog.STYLE_HORIZONTAL, false); // start service with intent getActivity().startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SafeSlingerActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SafeSlingerActivity.java index 273acc23d..7408135ae 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SafeSlingerActivity.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/SafeSlingerActivity.java @@ -124,12 +124,7 @@ public class SafeSlingerActivity extends BaseActivity { final FragmentActivity activity = SafeSlingerActivity.this; // Message is received after importing is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - activity, - getString(R.string.progress_importing), - ProgressDialog.STYLE_HORIZONTAL, - true - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(activity) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -202,7 +197,10 @@ public class SafeSlingerActivity extends BaseActivity { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - saveHandler.showProgressDialog(activity); + saveHandler.showProgressDialog( + getString(R.string.progress_importing), + ProgressDialog.STYLE_HORIZONTAL, true + ); // start service with intent activity.startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/UploadKeyActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/UploadKeyActivity.java index 2a195a4da..e4dff6083 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/UploadKeyActivity.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/UploadKeyActivity.java @@ -108,11 +108,7 @@ public class UploadKeyActivity extends BaseActivity { intent.putExtra(KeychainService.EXTRA_DATA, data); // Message is received after uploading is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - this, - getString(R.string.progress_uploading), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(this) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -132,7 +128,9 @@ public class UploadKeyActivity extends BaseActivity { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - saveHandler.showProgressDialog(this); + saveHandler.showProgressDialog( + getString(R.string.progress_uploading), + ProgressDialog.STYLE_HORIZONTAL, false); // start service with intent startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java index 995b07720..5f6a32e5a 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyActivity.java @@ -698,9 +698,6 @@ public class ViewKeyActivity extends BaseNfcActivity implements Messenger messenger = new Messenger(serviceHandler); intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); - // show progress dialog - serviceHandler.showProgressDialog(this); - // start service with intent startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyTrustFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyTrustFragment.java index 1f5c540ba..c33485adc 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyTrustFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ViewKeyTrustFragment.java @@ -360,12 +360,7 @@ public class ViewKeyTrustFragment extends LoaderFragment implements mProofVerifyDetail.setVisibility(View.GONE); // Create a new Messenger for the communication back after proof work is done - // - ServiceProgressHandler handler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_verifying_signature), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler handler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -454,7 +449,10 @@ public class ViewKeyTrustFragment extends LoaderFragment implements intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - handler.showProgressDialog(getActivity()); + handler.showProgressDialog( + getString(R.string.progress_verifying_signature), + ProgressDialog.STYLE_HORIZONTAL, false + ); // start service with intent getActivity().startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CachingCryptoOperationFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CachingCryptoOperationFragment.java index d0b6f502f..87c6ee3ca 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CachingCryptoOperationFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CachingCryptoOperationFragment.java @@ -2,24 +2,18 @@ package org.sufficientlysecure.keychain.ui.base; import android.os.Bundle; -import android.os.Message; import android.os.Parcelable; -import org.sufficientlysecure.keychain.service.ServiceProgressHandler; -import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; +import org.sufficientlysecure.keychain.operations.results.OperationResult; -public abstract class CachingCryptoOperationFragment extends CryptoOperationFragment { +public abstract class CachingCryptoOperationFragment + extends CryptoOperationFragment { public static final String ARG_CACHED_ACTIONS = "cached_actions"; private T mCachedActionsParcel; - @Override - protected void cryptoOperation(CryptoInputParcel cryptoInput) { - cryptoOperation(cryptoInput, mCachedActionsParcel); - } - @Override public void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); @@ -37,21 +31,16 @@ public abstract class CachingCryptoOperationFragment exte } @Override - public boolean handlePendingMessage(Message message) { - // see if it's an InputPendingResult, and if so don't care - if (super.handlePendingMessage(message)) { - return true; - } - - // if it's a non-input-pending OKAY message, always clear the cached actions parcel - if (message.arg1 == ServiceProgressHandler.MessageStatus.OKAY.ordinal()) { - mCachedActionsParcel = null; - } - - return false; + protected void onCryptoOperationResult(S result) { + super.onCryptoOperationResult(result); + mCachedActionsParcel = null; } - protected abstract void cryptoOperation(CryptoInputParcel cryptoInput, T cachedActionsParcel); + protected abstract T createOperationInput(); + + protected T getCachedActionsParcel() { + return mCachedActionsParcel; + } protected void cacheActionsParcel(T cachedActionsParcel) { mCachedActionsParcel = cachedActionsParcel; diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationFragment.java index 7fc5eb1f4..2be162e95 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/base/CryptoOperationFragment.java @@ -19,24 +19,32 @@ package org.sufficientlysecure.keychain.ui.base; import android.app.Activity; +import android.app.ProgressDialog; import android.content.Intent; import android.os.Bundle; import android.os.Message; +import android.os.Messenger; +import android.os.Parcelable; import android.support.v4.app.Fragment; +import org.sufficientlysecure.keychain.R; import org.sufficientlysecure.keychain.operations.results.InputPendingResult; import org.sufficientlysecure.keychain.operations.results.OperationResult; +import org.sufficientlysecure.keychain.service.KeychainNewService; +import org.sufficientlysecure.keychain.service.KeychainService; import org.sufficientlysecure.keychain.service.ServiceProgressHandler; import org.sufficientlysecure.keychain.service.input.CryptoInputParcel; import org.sufficientlysecure.keychain.service.input.RequiredInputParcel; import org.sufficientlysecure.keychain.ui.NfcOperationActivity; import org.sufficientlysecure.keychain.ui.PassphraseDialogActivity; +import org.sufficientlysecure.keychain.ui.dialog.ProgressDialogFragment; /** * All fragments executing crypto operations need to extend this class. */ -public abstract class CryptoOperationFragment extends Fragment { +public abstract class CryptoOperationFragment + extends Fragment { public static final int REQUEST_CODE_PASSPHRASE = 0x00008001; public static final int REQUEST_CODE_NFC = 0x00008002; @@ -99,35 +107,111 @@ public abstract class CryptoOperationFragment extends Fragment { } } - public boolean handlePendingMessage(Message message) { + protected void dismissProgress() { - if (message.arg1 == ServiceProgressHandler.MessageStatus.OKAY.ordinal()) { - Bundle data = message.getData(); + ProgressDialogFragment progressDialogFragment = + (ProgressDialogFragment) getFragmentManager().findFragmentByTag("progressDialog"); - OperationResult result = data.getParcelable(OperationResult.EXTRA_RESULT); - if (result == null || !(result instanceof InputPendingResult)) { - return false; - } - - InputPendingResult pendingResult = (InputPendingResult) result; - if (pendingResult.isPending()) { - RequiredInputParcel requiredInput = pendingResult.getRequiredInputParcel(); - initiateInputActivity(requiredInput); - return true; - } + if (progressDialogFragment == null) { + return; } - return false; + progressDialogFragment.dismissAllowingStateLoss(); + + } + + protected abstract T createOperationInput(); + + protected void cryptoOperation(CryptoInputParcel cryptoInput) { + + T operationInput = createOperationInput(); + if (operationInput == null) { + return; + } + + // Send all information needed to service to edit key in other thread + Intent intent = new Intent(getActivity(), KeychainNewService.class); + + intent.putExtra(KeychainNewService.EXTRA_OPERATION_INPUT, operationInput); + intent.putExtra(KeychainNewService.EXTRA_CRYPTO_INPUT, cryptoInput); + + ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) { + @Override + public void handleMessage(Message message) { + // handle messages by standard KeychainIntentServiceHandler first + super.handleMessage(message); + + if (message.arg1 == MessageStatus.OKAY.ordinal()) { + + // get returned data bundle + Bundle returnData = message.getData(); + if (returnData == null) { + return; + } + + final OperationResult result = + returnData.getParcelable(OperationResult.EXTRA_RESULT); + + onHandleResult(result); + } + } + }; + + // Create a new Messenger for the communication back + Messenger messenger = new Messenger(saveHandler); + intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); + + saveHandler.showProgressDialog( + getString(R.string.progress_building_key), + ProgressDialog.STYLE_HORIZONTAL, false); + + getActivity().startService(intent); + } protected void cryptoOperation() { cryptoOperation(new CryptoInputParcel()); } - protected abstract void cryptoOperation(CryptoInputParcel cryptoInput); - - protected void onCryptoOperationCancelled() { - // Nothing to do here, in most cases + protected void onCryptoOperationResult(S result) { + if (result.success()) { + onCryptoOperationSuccess(result); + } else { + onCryptoOperationError(result); + } } + abstract protected void onCryptoOperationSuccess(S result); + + protected void onCryptoOperationError(S result) { + result.createNotify(getActivity()).show(); + } + + protected void onCryptoOperationCancelled() { + } + + public void onHandleResult(OperationResult result) { + + if (result instanceof InputPendingResult) { + InputPendingResult pendingResult = (InputPendingResult) result; + if (pendingResult.isPending()) { + RequiredInputParcel requiredInput = pendingResult.getRequiredInputParcel(); + initiateInputActivity(requiredInput); + return; + } + } + + dismissProgress(); + + try { + // noinspection unchecked, because type erasure :( + onCryptoOperationResult((S) result); + } catch (ClassCastException e) { + throw new AssertionError("bad return class (" + + result.getClass().getSimpleName() + "), this is a programming error!"); + } + + } + + } diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java index 58dce50a7..076876b5b 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/dialog/DeleteKeyDialogFragment.java @@ -135,12 +135,7 @@ public class DeleteKeyDialogFragment extends DialogFragment { intent.setAction(KeychainService.ACTION_DELETE); // Message is received after importing is done in KeychainService - ServiceProgressHandler saveHandler = new ServiceProgressHandler( - getActivity(), - getString(R.string.progress_deleting), - ProgressDialog.STYLE_HORIZONTAL, - true - ) { + ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) { @Override public void handleMessage(Message message) { super.handleMessage(message); @@ -168,7 +163,8 @@ public class DeleteKeyDialogFragment extends DialogFragment { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - saveHandler.showProgressDialog(getActivity()); + saveHandler.showProgressDialog(getString(R.string.progress_deleting), + ProgressDialog.STYLE_HORIZONTAL, true); // start service with intent getActivity().startService(intent); diff --git a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/ExportHelper.java b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/ExportHelper.java index 88b0289d4..2fd09dc79 100644 --- a/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/ExportHelper.java +++ b/OpenKeychain/src/main/java/org/sufficientlysecure/keychain/util/ExportHelper.java @@ -97,10 +97,7 @@ public class ExportHelper { intent.putExtra(KeychainService.EXTRA_DATA, data); // Message is received after exporting is done in KeychainService - ServiceProgressHandler exportHandler = new ServiceProgressHandler(mActivity, - mActivity.getString(R.string.progress_exporting), - ProgressDialog.STYLE_HORIZONTAL - ) { + ServiceProgressHandler exportHandler = new ServiceProgressHandler(mActivity) { @Override public void handleMessage(Message message) { // handle messages by standard KeychainIntentServiceHandler first @@ -121,7 +118,10 @@ public class ExportHelper { intent.putExtra(KeychainService.EXTRA_MESSENGER, messenger); // show progress dialog - exportHandler.showProgressDialog(mActivity); + exportHandler.showProgressDialog( + mActivity.getString(R.string.progress_exporting), + ProgressDialog.STYLE_HORIZONTAL, false + ); // start service with intent mActivity.startService(intent); diff --git a/OpenKeychain/src/main/res/values/strings.xml b/OpenKeychain/src/main/res/values/strings.xml index 7323d19cd..ba2ae002e 100644 --- a/OpenKeychain/src/main/res/values/strings.xml +++ b/OpenKeychain/src/main/res/values/strings.xml @@ -341,6 +341,7 @@ "exporting keys…" + "preparing operation…" "extracting signature key…" "extracting key…" "preparing streams…" diff --git a/OpenKeychain/src/test/java/org/sufficientlysecure/keychain/operations/CertifyOperationTest.java b/OpenKeychain/src/test/java/org/sufficientlysecure/keychain/operations/CertifyOperationTest.java index d4a6a105e..6984f126e 100644 --- a/OpenKeychain/src/test/java/org/sufficientlysecure/keychain/operations/CertifyOperationTest.java +++ b/OpenKeychain/src/test/java/org/sufficientlysecure/keychain/operations/CertifyOperationTest.java @@ -158,7 +158,7 @@ public class CertifyOperationTest { CertifyActionsParcel actions = new CertifyActionsParcel(mStaticRing1.getMasterKeyId()); actions.add(new CertifyAction(mStaticRing2.getMasterKeyId(), mStaticRing2.getPublicKey().getUnorderedUserIds())); - CertifyResult result = op.certify(actions, new CryptoInputParcel(mKeyPhrase1), null); + CertifyResult result = op.execute(actions, new CryptoInputParcel(mKeyPhrase1)); Assert.assertTrue("certification must succeed", result.success()); @@ -186,7 +186,7 @@ public class CertifyOperationTest { CertifyActionsParcel actions = new CertifyActionsParcel(mStaticRing1.getMasterKeyId()); actions.add(new CertifyAction(mStaticRing2.getMasterKeyId(), null, mStaticRing2.getPublicKey().getUnorderedUserAttributes())); - CertifyResult result = op.certify(actions, new CryptoInputParcel(mKeyPhrase1), null); + CertifyResult result = op.execute(actions, new CryptoInputParcel(mKeyPhrase1)); Assert.assertTrue("certification must succeed", result.success()); @@ -209,7 +209,7 @@ public class CertifyOperationTest { actions.add(new CertifyAction(mStaticRing1.getMasterKeyId(), mStaticRing2.getPublicKey().getUnorderedUserIds())); - CertifyResult result = op.certify(actions, new CryptoInputParcel(mKeyPhrase1), null); + CertifyResult result = op.execute(actions, new CryptoInputParcel(mKeyPhrase1)); Assert.assertFalse("certification with itself must fail!", result.success()); Assert.assertTrue("error msg must be about self certification", @@ -228,7 +228,7 @@ public class CertifyOperationTest { uids.add("nonexistent"); actions.add(new CertifyAction(1234L, uids)); - CertifyResult result = op.certify(actions, new CryptoInputParcel(mKeyPhrase1), null); + CertifyResult result = op.execute(actions, new CryptoInputParcel(mKeyPhrase1)); Assert.assertFalse("certification of nonexistent key must fail", result.success()); Assert.assertTrue("must contain error msg about not found", @@ -240,7 +240,7 @@ public class CertifyOperationTest { actions.add(new CertifyAction(mStaticRing1.getMasterKeyId(), mStaticRing2.getPublicKey().getUnorderedUserIds())); - CertifyResult result = op.certify(actions, new CryptoInputParcel(mKeyPhrase1), null); + CertifyResult result = op.execute(actions, new CryptoInputParcel(mKeyPhrase1)); Assert.assertFalse("certification of nonexistent key must fail", result.success()); Assert.assertTrue("must contain error msg about not found",