migrated consolidation

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/operations/ConsolidateOperation.java

@@ -0,0 +1,27 @@
+package org.sufficientlysecure.keychain.operations;
+
+import android.content.Context;
+
+import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
+import org.sufficientlysecure.keychain.pgp.Progressable;
+import org.sufficientlysecure.keychain.provider.ProviderHelper;
+import org.sufficientlysecure.keychain.service.ConsolidateInputParcel;
+import org.sufficientlysecure.keychain.service.input.CryptoInputParcel;
+
+public class ConsolidateOperation extends BaseOperation<ConsolidateInputParcel> {
+
+    public ConsolidateOperation(Context context, ProviderHelper providerHelper, Progressable
+            progressable) {
+        super(context, providerHelper, progressable);
+    }
+
+    @Override
+    public ConsolidateResult execute(ConsolidateInputParcel consolidateInputParcel,
+                                     CryptoInputParcel cryptoInputParcel) {
+        if (consolidateInputParcel.mConsolidateRecovery) {
+            return mProviderHelper.consolidateDatabaseStep2(mProgressable);
+        } else {
+            return mProviderHelper.consolidateDatabaseStep1(mProgressable);
+        }
+    }
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/ConsolidateInputParcel.java

@@ -0,0 +1,39 @@
+package org.sufficientlysecure.keychain.service;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class ConsolidateInputParcel implements Parcelable {
+
+    public boolean mConsolidateRecovery;
+
+    public ConsolidateInputParcel(boolean consolidateRecovery) {
+        mConsolidateRecovery = consolidateRecovery;
+    }
+
+    protected ConsolidateInputParcel(Parcel in) {
+        mConsolidateRecovery = in.readByte() != 0x00;
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeByte((byte) (mConsolidateRecovery ? 0x01 : 0x00));
+    }
+
+    public static final Parcelable.Creator<ConsolidateInputParcel> CREATOR = new Parcelable.Creator<ConsolidateInputParcel>() {
+        @Override
+        public ConsolidateInputParcel createFromParcel(Parcel in) {
+            return new ConsolidateInputParcel(in);
+        }
+
+        @Override
+        public ConsolidateInputParcel[] newArray(int size) {
+            return new ConsolidateInputParcel[size];
+        }
+    };
+}

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainNewService.java

@@ -113,6 +113,9 @@ public class KeychainNewService extends Service implements Progressable {
                         || inputParcel instanceof ExportKeyringParcel){
                     op = new ImportExportOperation(outerThis, new ProviderHelper(outerThis),
                             outerThis, mActionCanceled);
+                } else if (inputParcel instanceof ConsolidateInputParcel) {
+                    op = new ConsolidateOperation(outerThis, new ProviderHelper(outerThis),
+                            outerThis);
                 } else {
                     return;
                 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/service/KeychainService.java

@@ -37,10 +37,7 @@ 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.DeleteOperation;
+import org.sufficientlysecure.keychain.operations.*;
-import org.sufficientlysecure.keychain.operations.EditKeyOperation;
-import org.sufficientlysecure.keychain.operations.ImportExportOperation;
-import org.sufficientlysecure.keychain.operations.PromoteKeyOperation;
 import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
 import org.sufficientlysecure.keychain.operations.results.DecryptVerifyResult;
 import org.sufficientlysecure.keychain.operations.results.DeleteResult;
@@ -157,21 +154,6 @@ public class KeychainService extends Service implements Progressable {
 
                 // executeServiceMethod action from extra bundle
                 switch (action) {
-                    case ACTION_CONSOLIDATE: {
-
-                        // Operation
-                        ConsolidateResult result;
-                        if (data.containsKey(CONSOLIDATE_RECOVERY) && data.getBoolean(CONSOLIDATE_RECOVERY)) {
-                            result = providerHelper.consolidateDatabaseStep2(KeychainService.this);
-                        } else {
-                            result = providerHelper.consolidateDatabaseStep1(KeychainService.this);
-                        }
-
-                        // Result
-                        sendMessageToHandler(MessageStatus.OKAY, result);
-
-                        break;
-                    }
                     case ACTION_VERIFY_KEYBASE_PROOF: {
 
                         try {

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/ConsolidateDialogActivity.java

@@ -17,25 +17,27 @@
 
 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.support.v4.app.FragmentActivity;
 
 import org.sufficientlysecure.keychain.R;
-import org.sufficientlysecure.keychain.service.KeychainService;
+import org.sufficientlysecure.keychain.operations.results.ConsolidateResult;
-import org.sufficientlysecure.keychain.service.ServiceProgressHandler;
+import org.sufficientlysecure.keychain.service.ConsolidateInputParcel;
+import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
 
 /**
  * We can not directly create a dialog on the application context.
  * This activity encapsulates a DialogFragment to emulate a dialog.
  */
-public class ConsolidateDialogActivity extends FragmentActivity {
+public class ConsolidateDialogActivity extends FragmentActivity
+        implements CryptoOperationHelper.Callback<ConsolidateInputParcel, ConsolidateResult> {
 
     public static final String EXTRA_CONSOLIDATE_RECOVERY = "consolidate_recovery";
 
+    private CryptoOperationHelper<ConsolidateInputParcel, ConsolidateResult> mConsolidateOpHelper;
+    private boolean mRecovery;
+
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -48,55 +50,40 @@ public class ConsolidateDialogActivity extends FragmentActivity {
     }
 
     private void consolidateRecovery(boolean recovery) {
-        // Message is received after importing is done in KeychainService
-        ServiceProgressHandler saveHandler = new ServiceProgressHandler(this) {
-            @Override
-            public void handleMessage(Message message) {
-                // handle messages by standard KeychainIntentServiceHandler first
-                super.handleMessage(message);
 
-                if (message.arg1 == MessageStatus.OKAY.ordinal()) {
+        mRecovery = recovery;
-                    /* don't care about the results (for now?)
 
-                    // get returned data bundle
+        mConsolidateOpHelper = new CryptoOperationHelper<>(this, this, R.string.progress_importing);
-                    Bundle returnData = message.getInputData();
+        mConsolidateOpHelper.cryptoOperation();
-                    if (returnData == null) {
-                        return;
-                    }
-                    final ConsolidateResult result =
-                            returnData.getParcelable(KeychainService.RESULT_CONSOLIDATE);
-                    if (result == null) {
-                        return;
-                    }
-                    result.createNotify(ConsolidateDialogActivity.this).show();
-                    */
-
-                    ConsolidateDialogActivity.this.finish();
-                }
-            }
-        };
-
-        // Send all information needed to service to import key in other thread
-        Intent intent = new Intent(this, KeychainService.class);
-        intent.setAction(KeychainService.ACTION_CONSOLIDATE);
-
-        // fill values for this action
-        Bundle data = new Bundle();
-        data.putBoolean(KeychainService.CONSOLIDATE_RECOVERY, recovery);
-        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(
-                getString(R.string.progress_importing),
-                ProgressDialog.STYLE_HORIZONTAL, false
-        );
-
-        // start service with intent
-        startService(intent);
     }
 
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        if (mConsolidateOpHelper != null) {
+            mConsolidateOpHelper.handleActivityResult(requestCode, resultCode, data);
+        }
+    }
+
+    @Override
+    public ConsolidateInputParcel createOperationInput() {
+        return new ConsolidateInputParcel(mRecovery);
+    }
+
+    @Override
+    public void onCryptoOperationSuccess(ConsolidateResult result) {
+        // don't care about result (for now?)
+        ConsolidateDialogActivity.this.finish();
+    }
+
+    @Override
+    public void onCryptoOperationCancelled() {
+
+    }
+
+    @Override
+    public void onCryptoOperationError(ConsolidateResult result) {
+        // don't care about result (for now?)
+        ConsolidateDialogActivity.this.finish();
+    }
 }

OpenKeychain/src/main/java/org/sufficientlysecure/keychain/ui/KeyListFragment.java

@@ -64,10 +64,7 @@ import org.sufficientlysecure.keychain.provider.KeychainContract;
 import org.sufficientlysecure.keychain.provider.KeychainContract.KeyRings;
 import org.sufficientlysecure.keychain.provider.KeychainDatabase;
 import org.sufficientlysecure.keychain.provider.ProviderHelper;
-import org.sufficientlysecure.keychain.service.ImportKeyringParcel;
+import org.sufficientlysecure.keychain.service.*;
-import org.sufficientlysecure.keychain.service.KeychainService;
-import org.sufficientlysecure.keychain.service.ServiceProgressHandler;
-import org.sufficientlysecure.keychain.service.PassphraseCacheService;
 import org.sufficientlysecure.keychain.ui.base.CryptoOperationHelper;
 import org.sufficientlysecure.keychain.ui.dialog.DeleteKeyDialogFragment;
 import org.sufficientlysecure.keychain.ui.util.KeyFormattingUtils;
@@ -115,6 +112,9 @@ public class KeyListFragment extends LoaderFragment
     private String mKeyserver;
     private CryptoOperationHelper<ImportKeyringParcel, ImportKeyResult> mImportOpHelper;
 
+    // for ConsolidateOperation
+    private CryptoOperationHelper<ConsolidateInputParcel, ConsolidateResult> mConsolidateOpHelper;
+
     // This ids for multiple key export.
     private ArrayList<Long> mIdsForRepeatAskPassphrase;
     // This index for remembering the number of master key.
@@ -607,51 +607,35 @@ public class KeyListFragment extends LoaderFragment
     }
 
     private void consolidate() {
-        // Message is received after importing is done in KeychainService
+
-        ServiceProgressHandler saveHandler = new ServiceProgressHandler(getActivity()) {
+        CryptoOperationHelper.Callback<ConsolidateInputParcel, ConsolidateResult> callback
+                = new CryptoOperationHelper.Callback<ConsolidateInputParcel, ConsolidateResult>() {
+
             @Override
-            public void handleMessage(Message message) {
+            public ConsolidateInputParcel createOperationInput() {
-                // handle messages by standard KeychainIntentServiceHandler first
+                return new ConsolidateInputParcel(false); // we want to perform a full consolidate
-                super.handleMessage(message);
+            }
 
-                if (message.arg1 == MessageStatus.OKAY.ordinal()) {
+            @Override
-                    // get returned data bundle
+            public void onCryptoOperationSuccess(ConsolidateResult result) {
-                    Bundle returnData = message.getData();
+                result.createNotify(getActivity()).show();
-                    if (returnData == null) {
+            }
-                        return;
-                    }
-                    final ConsolidateResult result =
-                            returnData.getParcelable(OperationResult.EXTRA_RESULT);
-                    if (result == null) {
-                        return;
-                    }
 
-                    result.createNotify(getActivity()).show();
+            @Override
-                }
+            public void onCryptoOperationCancelled() {
+
+            }
+
+            @Override
+            public void onCryptoOperationError(ConsolidateResult result) {
+                result.createNotify(getActivity()).show();
             }
         };
 
-        // Send all information needed to service to import key in other thread
+        mConsolidateOpHelper =
-        Intent intent = new Intent(getActivity(), KeychainService.class);
+                new CryptoOperationHelper<>(this, callback, R.string.progress_importing);
 
-        intent.setAction(KeychainService.ACTION_CONSOLIDATE);
+        mConsolidateOpHelper.cryptoOperation();
-
-        // fill values for this action
-        Bundle data = new Bundle();
-
-        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(
-                getString(R.string.progress_importing),
-                ProgressDialog.STYLE_HORIZONTAL, false);
-
-        // start service with intent
-        getActivity().startService(intent);
     }
 
     private void showMultiExportDialog(long[] masterKeyIds) {
@@ -693,6 +677,11 @@ public class KeyListFragment extends LoaderFragment
         if (mImportOpHelper != null) {
             mImportOpHelper.handleActivityResult(requestCode, resultCode, data);
         }
+
+        if (mConsolidateOpHelper != null) {
+            mConsolidateOpHelper.handleActivityResult(requestCode, resultCode, data);
+        }
+
         if (requestCode == REQUEST_REPEAT_PASSPHRASE) {
             if (resultCode != Activity.RESULT_OK) {
                 return;